release: v2.4.0

- Remove dedicated prove-yourself mode (frustration keyword detector)
- Add ZERO TOLERANCE FAILURES section to ultrawork mode
- Consolidate completion enforcement rules: no scope reduction, no partial completion, no assumed shortcuts, no premature stopping
- Simplify constants by removing separate frustration handler

🤖 Generated with assistance of OhMyOpenCode (https://github.com/code-yeongyu/oh-my-opencode)

.github/workflows/ci.yml

@@ -0,0 +1,117 @@
+name: CI
+
+on:
+  push:
+    branches: [master]
+  pull_request:
+    branches: [master]
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: oven-sh/setup-bun@v2
+        with:
+          bun-version: latest
+
+      - name: Install dependencies
+        run: bun install
+        env:
+          BUN_INSTALL_ALLOW_SCRIPTS: "@ast-grep/napi"
+
+      - name: Run tests
+        run: bun test
+
+  typecheck:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: oven-sh/setup-bun@v2
+        with:
+          bun-version: latest
+
+      - name: Install dependencies
+        run: bun install
+        env:
+          BUN_INSTALL_ALLOW_SCRIPTS: "@ast-grep/napi"
+
+      - name: Type check
+        run: bun run typecheck
+
+  build:
+    runs-on: ubuntu-latest
+    needs: [test, typecheck]
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: oven-sh/setup-bun@v2
+        with:
+          bun-version: latest
+
+      - name: Install dependencies
+        run: bun install
+        env:
+          BUN_INSTALL_ALLOW_SCRIPTS: "@ast-grep/napi"
+
+      - name: Build
+        run: bun run build
+
+      - name: Verify build output
+        run: |
+          test -f dist/index.js || (echo "ERROR: dist/index.js not found!" && exit 1)
+          test -f dist/index.d.ts || (echo "ERROR: dist/index.d.ts not found!" && exit 1)
+
+  draft-release:
+    runs-on: ubuntu-latest
+    needs: [build]
+    if: github.event_name == 'push' && github.ref == 'refs/heads/master'
+    permissions:
+      contents: write
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - run: git fetch --force --tags
+
+      - uses: oven-sh/setup-bun@v2
+        with:
+          bun-version: latest
+
+      - name: Generate release notes
+        id: notes
+        run: |
+          NOTES=$(bun run script/generate-changelog.ts)
+          echo "notes<<EOF" >> $GITHUB_OUTPUT
+          echo "$NOTES" >> $GITHUB_OUTPUT
+          echo "EOF" >> $GITHUB_OUTPUT
+        env:
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Create or update draft release
+        run: |
+          EXISTING_DRAFT=$(gh release list --json tagName,isDraft --jq '.[] | select(.isDraft == true and .tagName == "next") | .tagName')
+          
+          if [ -n "$EXISTING_DRAFT" ]; then
+            echo "Updating existing draft release..."
+            gh release edit next \
+              --title "Upcoming Changes 🍿" \
+              --notes "${{ steps.notes.outputs.notes }}" \
+              --draft
+          else
+            echo "Creating new draft release..."
+            gh release create next \
+              --title "Upcoming Changes 🍿" \
+              --notes "${{ steps.notes.outputs.notes }}" \
+              --draft \
+              --target ${{ github.sha }}
+          fi
+        env:
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}

.github/workflows/publish.yml

@@ -89,3 +89,8 @@ jobs:
           CI: true
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
           NPM_CONFIG_PROVENANCE: true
+
+      - name: Delete draft release
+        run: gh release delete next --yes 2>/dev/null || echo "No draft release to delete"
+        env:
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}

README.ja.md

@@ -156,11 +156,22 @@ Windows から Linux に初めて乗り換えた時のこと、自分の思い
 
 ### ステップ 0: セットアップについてユーザーに尋ねる
 
-OpenCode は様々なモデルをサポートしており、当プラグインは様々な最先端 LLM の使用を提案しています。そのため、ユーザーに以下の質問をする必要があります：
+OpenCode は様々なモデルをサポートしており、当プラグインは様々な最先端 LLM の使用を提案しています。そのため、ユーザーに以下の質問をする必要があります。
+
+**重要**: ユーザーがどのプロバイダーを持っているか追跡してください。ユーザーが Claude を持っていると確認した場合のみ、`anthropic/claude-opus-4-5` をフォールバックとして使用できます。Claude がない場合は、代わりに `opencode/big-pickle` をフォールバックとして使用してください。
 
 1. **Claude Pro/Max のサブスクリプションをお持ちですか？** お持ちでない場合、メインオーケストレーターモデルとして 'opencode/big-pickle' (GLM 4.6 として知られる) を使用することになります (非推奨)。
-   - ユーザーが**「はい」**と答えた場合、ToDo 追加: "ユーザーの Claude Pro/Max 認証設定"
-   - ユーザーが**「いいえ」**と答えた場合、`~/.config/opencode/oh-my-opencode.json` に以下を保存:
+   - ユーザーが**「はい」**と答えた場合、追加質問: **max20 (20x モード) を使用していますか？**
+     - **「はい」 (max20)**: ToDo 追加: "ユーザーの Claude Pro/Max 認証設定" — librarian に Claude Sonnet 4.5 をフル使用。**記憶: Claude がフォールバックとして使用可能。**
+     - **「いいえ」 (max20 ではない)**: ToDo 追加: "ユーザーの Claude Pro/Max 認証設定"、そして `~/.config/opencode/oh-my-opencode.json` に以下をマージ。**記憶: Claude がフォールバックとして使用可能。**
+       ```json
+       {
+         "agents": {
+           "librarian": { "model": "opencode/big-pickle" }
+         }
+       }
+       ```
+   - ユーザーが**「いいえ」** (Claude サブスクリプションなし) と答えた場合、`~/.config/opencode/oh-my-opencode.json` に以下を保存。**記憶: Claude は使用不可 — すべてのフォールバックは `opencode/big-pickle` を使用する必要があります。**
      ```json
      {
        "agents": {
@@ -170,29 +181,49 @@ OpenCode は様々なモデルをサポートしており、当プラグイン
      }
      ```
 
-2. **ChatGPT のサブスクリプションをお持ちですか？** お持ちでない場合、oracle エージェントに 'anthropic/claude-opus-4-5' を使用することになります。
+2. **ChatGPT のサブスクリプションをお持ちですか？** お持ちでない場合、oracle エージェントにフォールバックモデルを使用することになります。
    - ユーザーが**「はい」**と答えた場合、ToDo 追加: "ユーザーの ChatGPT 認証設定"
-   - ユーザーが**「いいえ」**と答えた場合、`oh-my-opencode.json` に以下をマージ:
-     ```json
-     {
-       "agents": {
-         "oracle": { "model": "anthropic/claude-opus-4-5" }
+   - ユーザーが**「いいえ」**と答えた場合:
+     - **Claude が使用可能な場合**: `oh-my-opencode.json` に以下をマージ:
+       ```json
+       {
+         "agents": {
+           "oracle": { "model": "anthropic/claude-opus-4-5" }
+         }
        }
-     }
-     ```
+       ```
+     - **Claude が使用不可の場合**: `oh-my-opencode.json` に以下をマージ:
+       ```json
+       {
+         "agents": {
+           "oracle": { "model": "opencode/big-pickle" }
+         }
+       }
+       ```
 
 3. **Gemini モデルを統合しますか？** 統合しない場合、美しいデザインを享受できません。
    - ユーザーが**「はい」**と答えた場合、ToDo 追加: "Google OAuth 設定"
-   - ユーザーが**「いいえ」**と答えた場合、`oh-my-opencode.json` に以下をマージ:
-     ```json
-     {
-       "agents": {
-         "frontend-ui-ux-engineer": { "model": "anthropic/claude-opus-4-5" },
-         "document-writer": { "model": "anthropic/claude-opus-4-5" },
-         "multimodal-looker": { "model": "anthropic/claude-opus-4-5" }
+   - ユーザーが**「いいえ」**と答えた場合:
+     - **Claude が使用可能な場合**: `oh-my-opencode.json` に以下をマージ:
+       ```json
+       {
+         "agents": {
+           "frontend-ui-ux-engineer": { "model": "anthropic/claude-opus-4-5" },
+           "document-writer": { "model": "anthropic/claude-opus-4-5" },
+           "multimodal-looker": { "model": "anthropic/claude-opus-4-5" }
+         }
        }
-     }
-     ```
+       ```
+     - **Claude が使用不可の場合**: `oh-my-opencode.json` に以下をマージ:
+       ```json
+       {
+         "agents": {
+           "frontend-ui-ux-engineer": { "model": "opencode/big-pickle" },
+           "document-writer": { "model": "opencode/big-pickle" },
+           "multimodal-looker": { "model": "opencode/big-pickle" }
+         }
+       }
+       ```
 
 ### ステップ 1: OpenCode インストール確認
 

README.ko.md

@@ -153,43 +153,74 @@ OpenCode 가 낭만이 사라진것같은 오늘날의 시대에, 당신에게
 
 ### 0단계: 사용자에게 설정에 대해 물어보세요.
 
-OpenCode는 다양한 모델을 지원하며, 이 플러그인은 다양한 프론티어 LLM 사용을 제안합니다. 따라서 사용자에게 다음 질문을 해야 합니다:
+OpenCode는 다양한 모델을 지원하며, 이 플러그인은 다양한 프론티어 LLM 사용을 제안합니다. 따라서 사용자에게 다음 질문을 해야 합니다.
+
+**중요**: 사용자가 어떤 프로바이더를 가지고 있는지 추적하세요. 사용자가 Claude가 있다고 확인한 경우에만 `anthropic/claude-opus-4-5`를 폴백으로 사용할 수 있습니다. Claude가 없다면 `opencode/big-pickle`을 폴백으로 사용해야 합니다.
 
 1. **Claude Pro/Max 구독이 있으신가요?** 그렇지 않다면 메인 오케스트레이터 모델로 'opencode/big-pickle'(GLM 4.6으로 알려짐)을 사용하게 됩니다 (권장하지 않음).
-   - 사용자가 **'예'**라고 답하면, 할 일 추가: "사용자 Claude Pro/Max 인증 설정"
-   - 사용자가 **'아니오'**라고 답하면, `~/.config/opencode/oh-my-opencode.json`에 다음을 저장:
+   - 사용자가 **'예'**라고 답하면, 추가 질문: **max20 (20x 모드)를 사용하고 계신가요?**
+     - **'예' (max20)**: 할 일 추가: "사용자 Claude Pro/Max 인증 설정" — librarian에 Claude Sonnet 4.5 전체 사용. **기억: Claude를 폴백으로 사용 가능.**
+     - **'아니오' (max20 아님)**: 할 일 추가: "사용자 Claude Pro/Max 인증 설정", 그리고 `~/.config/opencode/oh-my-opencode.json`에 다음을 병합. **기억: Claude를 폴백으로 사용 가능.**
+       ```json
+       {
+         "agents": {
+           "librarian": { "model": "opencode/big-pickle" }
+         }
+       }
+       ```
+   - 사용자가 **'아니오'** (Claude 구독 없음)라고 답하면, `~/.config/opencode/oh-my-opencode.json`에 다음을 저장. **기억: Claude 사용 불가 — 모든 폴백은 `opencode/big-pickle`을 사용해야 함.**
      ```json
      {
        "agents": {
-         "sisyphus": { "model": "opencode/big-pickle" },
+         "Sisyphus": { "model": "opencode/big-pickle" },
          "librarian": { "model": "opencode/big-pickle" }
        }
      }
      ```
 
-2. **ChatGPT 구독이 있으신가요?** 그렇지 않다면 oracle 에이전트에 'anthropic/claude-opus-4-5'를 사용하게 됩니다.
+2. **ChatGPT 구독이 있으신가요?** 그렇지 않다면 oracle 에이전트에 폴백 모델을 사용하게 됩니다.
    - 사용자가 **'예'**라고 답하면, 할 일 추가: "사용자 ChatGPT 인증 설정"
-   - 사용자가 **'아니오'**라고 답하면, `oh-my-opencode.json`에 다음을 병합:
-     ```json
-     {
-       "agents": {
-         "oracle": { "model": "anthropic/claude-opus-4-5" }
+   - 사용자가 **'아니오'**라고 답하면:
+     - **Claude가 사용 가능한 경우**: `oh-my-opencode.json`에 다음을 병합:
+       ```json
+       {
+         "agents": {
+           "oracle": { "model": "anthropic/claude-opus-4-5" }
+         }
        }
-     }
-     ```
+       ```
+     - **Claude가 사용 불가능한 경우**: `oh-my-opencode.json`에 다음을 병합:
+       ```json
+       {
+         "agents": {
+           "oracle": { "model": "opencode/big-pickle" }
+         }
+       }
+       ```
 
 3. **Gemini 모델을 통합하시겠습니까?** 그렇지 않다면 아름다운 디자인을 즐길 수 없습니다.
    - 사용자가 **'예'**라고 답하면, 할 일 추가: "Google OAuth 설정"
-   - 사용자가 **'아니오'**라고 답하면, `oh-my-opencode.json`에 다음을 병합:
-     ```json
-     {
-       "agents": {
-         "frontend-ui-ux-engineer": { "model": "anthropic/claude-opus-4-5" },
-         "document-writer": { "model": "anthropic/claude-opus-4-5" },
-         "multimodal-looker": { "model": "anthropic/claude-opus-4-5" }
+   - 사용자가 **'아니오'**라고 답하면:
+     - **Claude가 사용 가능한 경우**: `oh-my-opencode.json`에 다음을 병합:
+       ```json
+       {
+         "agents": {
+           "frontend-ui-ux-engineer": { "model": "anthropic/claude-opus-4-5" },
+           "document-writer": { "model": "anthropic/claude-opus-4-5" },
+           "multimodal-looker": { "model": "anthropic/claude-opus-4-5" }
+         }
        }
-     }
-     ```
+       ```
+     - **Claude가 사용 불가능한 경우**: `oh-my-opencode.json`에 다음을 병합:
+       ```json
+       {
+         "agents": {
+           "frontend-ui-ux-engineer": { "model": "opencode/big-pickle" },
+           "document-writer": { "model": "opencode/big-pickle" },
+           "multimodal-looker": { "model": "opencode/big-pickle" }
+         }
+       }
+       ```
 
 ### 1단계: OpenCode 설치 확인
 

README.md

@@ -1,3 +1,5 @@
+NOTICE: News regarding oh-my-opencode used to posted on my X account, but since it got suspended innocently, my friend [@_junhoyeo](https://x.com/_junhoyeo) will post on behalf of me. (THE GUY WHO MADE HERO IMAGE)
+
 <!-- <CENTERED SECTION FOR GITHUB DISPLAY> -->
 
 <div align="center">
@@ -181,11 +183,22 @@ follow these steps:
 
 ### Step 0: Ask user about the setup.
 
-Since OpenCode Supports various models, and our plugin suggests various frontier LLMs. Thus, you must ask user, following questions:
+Since OpenCode supports various models, and our plugin suggests various frontier LLMs, you must ask user the following questions.
+
+**IMPORTANT**: Track which providers the user has. Only use `anthropic/claude-opus-4-5` as fallback when the user confirmed they have Claude. If they don't have Claude, use `opencode/big-pickle` as fallback instead.
 
 1. **Do you have a Claude Pro/Max Subscription?** Otherwise, we'll use 'opencode/big-pickle' (known for GLM 4.6) as a main orchestrator model (not recommended)
-   - If user said **yes**, add ToDo: "Setup user Claude Pro/Max Auth"
-   - If user said **no**, merge the following to `~/.config/opencode/oh-my-opencode.json`:
+   - If user said **yes**, ask follow-up: **Are you on max20 (20x mode)?**
+     - If **yes (max20)**: Add ToDo: "Setup user Claude Pro/Max Auth" — full Claude Sonnet 4.5 for librarian. **Remember: Claude is available for fallbacks.**
+     - If **no (not max20)**: Add ToDo: "Setup user Claude Pro/Max Auth", then merge the following to `~/.config/opencode/oh-my-opencode.json`. **Remember: Claude is available for fallbacks.**
+       ```json
+       {
+         "agents": {
+           "librarian": { "model": "opencode/big-pickle" }
+         }
+       }
+       ```
+   - If user said **no** (no Claude subscription), merge the following to `~/.config/opencode/oh-my-opencode.json`. **Remember: Claude is NOT available — all fallbacks must use `opencode/big-pickle`.**
      ```json
      {
        "agents": {
@@ -195,29 +208,49 @@ Since OpenCode Supports various models, and our plugin suggests various frontier
      }
      ```
 
-2. **Do you have a ChatGPT Subscription?** Otherwise, we'll use 'anthropic/claude-opus-4-5' with 32k thinking option for oracle agent.
+2. **Do you have a ChatGPT Subscription?** Otherwise, we'll use a fallback model for oracle agent.
    - If user said **yes**, add ToDo: "Setup user ChatGPT Auth"
-   - If user said **no**, merge the following to `oh-my-opencode.json`:
-     ```json
-     {
-       "agents": {
-         "oracle": { "model": "anthropic/claude-opus-4-5" }
+   - If user said **no**:
+     - **If Claude is available**: merge the following to `oh-my-opencode.json`:
+       ```json
+       {
+         "agents": {
+           "oracle": { "model": "anthropic/claude-opus-4-5" }
+         }
        }
-     }
-     ```
+       ```
+     - **If Claude is NOT available**: merge the following to `oh-my-opencode.json`:
+       ```json
+       {
+         "agents": {
+           "oracle": { "model": "opencode/big-pickle" }
+         }
+       }
+       ```
 
 3. **Will you integrate Gemini models?** Otherwise, you cannot enjoy the beautiful design.
    - If user said **yes**, add ToDo: "Setup Google OAuth"
-   - If user said **no**, merge the following to `oh-my-opencode.json`:
-     ```json
-     {
-       "agents": {
-         "frontend-ui-ux-engineer": { "model": "anthropic/claude-opus-4-5" },
-         "document-writer": { "model": "anthropic/claude-opus-4-5" },
-         "multimodal-looker": { "model": "anthropic/claude-opus-4-5" }
+   - If user said **no**:
+     - **If Claude is available**: merge the following to `oh-my-opencode.json`:
+       ```json
+       {
+         "agents": {
+           "frontend-ui-ux-engineer": { "model": "anthropic/claude-opus-4-5" },
+           "document-writer": { "model": "anthropic/claude-opus-4-5" },
+           "multimodal-looker": { "model": "anthropic/claude-opus-4-5" }
+         }
        }
-     }
-     ```
+       ```
+     - **If Claude is NOT available**: merge the following to `oh-my-opencode.json`:
+       ```json
+       {
+         "agents": {
+           "frontend-ui-ux-engineer": { "model": "opencode/big-pickle" },
+           "document-writer": { "model": "opencode/big-pickle" },
+           "multimodal-looker": { "model": "opencode/big-pickle" }
+         }
+       }
+       ```
 
 ### Step 1: Install OpenCode, if not
 

README.zh-cn.md

@@ -162,11 +162,22 @@ Install and configure by following the instructions here https://raw.githubuserc
 
 ### 步骤 0：摸清用户底细
 
-OpenCode 支持各种模型，我们这个插件也建议用各种前沿 LLM。所以先问清楚：
+OpenCode 支持各种模型，我们这个插件也建议用各种前沿 LLM。所以先问清楚。
+
+**重要**：追踪用户有哪些 provider。只有用户确认有 Claude 的情况下，才能用 `anthropic/claude-opus-4-5` 做 fallback。没有 Claude 就用 `opencode/big-pickle` 做 fallback。
 
 1. **有 Claude Pro/Max 订阅吗？** 没有的话，主编排模型只能用 'opencode/big-pickle'（也就是 GLM 4.6），这体验可不太好（不推荐）。
-   - 用户说**有**，加个待办："配置用户 Claude Pro/Max 认证"
-   - 用户说**没有**，把这坨配置写到 `~/.config/opencode/oh-my-opencode.json`：
+   - 用户说**有**，继续问：**你用的是 max20 (20x 模式) 吗？**
+     - **是 (max20)**：加个待办："配置用户 Claude Pro/Max 认证" — librarian 用完整的 Claude Sonnet 4.5。**记住：Claude 可以做 fallback。**
+     - **不是 (没有 max20)**：加个待办："配置用户 Claude Pro/Max 认证"，然后把这个合并到 `~/.config/opencode/oh-my-opencode.json`。**记住：Claude 可以做 fallback。**
+       ```json
+       {
+         "agents": {
+           "librarian": { "model": "opencode/big-pickle" }
+         }
+       }
+       ```
+   - 用户说**没有** (没有 Claude 订阅)，把这坨配置写到 `~/.config/opencode/oh-my-opencode.json`。**记住：没有 Claude — 所有 fallback 都得用 `opencode/big-pickle`。**
      ```json
      {
        "agents": {
@@ -176,29 +187,49 @@ OpenCode 支持各种模型，我们这个插件也建议用各种前沿 LLM。
      }
      ```
 
-2. **有 ChatGPT 订阅吗？** 没有的话，oracle Agent 就用 'anthropic/claude-opus-4-5' 带 32k thinking 了。
+2. **有 ChatGPT 订阅吗？** 没有的话，oracle Agent 就用 fallback 模型了。
    - 用户说**有**，加个待办："配置用户 ChatGPT 认证"
-   - 用户说**没有**，把这个合并到 `oh-my-opencode.json`：
-     ```json
-     {
-       "agents": {
-         "oracle": { "model": "anthropic/claude-opus-4-5" }
+   - 用户说**没有**：
+     - **有 Claude 的情况下**：把这个合并到 `oh-my-opencode.json`：
+       ```json
+       {
+         "agents": {
+           "oracle": { "model": "anthropic/claude-opus-4-5" }
+         }
        }
-     }
-     ```
+       ```
+     - **没有 Claude 的情况下**：把这个合并到 `oh-my-opencode.json`：
+       ```json
+       {
+         "agents": {
+           "oracle": { "model": "opencode/big-pickle" }
+         }
+       }
+       ```
 
 3. **要接 Gemini 模型吗？** 不接的话，那么漂亮的 UI 设计你就无福消受了。
    - 用户说**要**，加个待办："配置 Google OAuth"
-   - 用户说**不要**，把这个合并到 `oh-my-opencode.json`：
-     ```json
-     {
-       "agents": {
-         "frontend-ui-ux-engineer": { "model": "anthropic/claude-opus-4-5" },
-         "document-writer": { "model": "anthropic/claude-opus-4-5" },
-         "multimodal-looker": { "model": "anthropic/claude-opus-4-5" }
+   - 用户说**不要**：
+     - **有 Claude 的情况下**：把这个合并到 `oh-my-opencode.json`：
+       ```json
+       {
+         "agents": {
+           "frontend-ui-ux-engineer": { "model": "anthropic/claude-opus-4-5" },
+           "document-writer": { "model": "anthropic/claude-opus-4-5" },
+           "multimodal-looker": { "model": "anthropic/claude-opus-4-5" }
+         }
        }
-     }
-     ```
+       ```
+     - **没有 Claude 的情况下**：把这个合并到 `oh-my-opencode.json`：
+       ```json
+       {
+         "agents": {
+           "frontend-ui-ux-engineer": { "model": "opencode/big-pickle" },
+           "document-writer": { "model": "opencode/big-pickle" },
+           "multimodal-looker": { "model": "opencode/big-pickle" }
+         }
+       }
+       ```
 
 ### 步骤 1：确认 OpenCode 装没装
 

assets/oh-my-opencode.schema.json

@@ -24,7 +24,7 @@
       "items": {
         "type": "string",
         "enum": [
-          "OmO",
+          "Sisyphus",
           "oracle",
           "librarian",
           "explore",
@@ -288,7 +288,7 @@
             }
           }
         },
-        "OmO": {
+        "Sisyphus": {
           "type": "object",
           "properties": {
             "model": {
@@ -399,7 +399,7 @@
             }
           }
         },
-        "OmO-Plan": {
+        "Planner-Sisyphus": {
           "type": "object",
           "properties": {
             "model": {
@@ -1201,13 +1201,30 @@
     "google_auth": {
       "type": "boolean"
     },
-    "omo_agent": {
+    "sisyphus_agent": {
       "type": "object",
       "properties": {
         "disabled": {
           "type": "boolean"
         }
       }
+    },
+    "experimental": {
+      "type": "object",
+      "properties": {
+        "aggressive_truncation": {
+          "type": "boolean"
+        },
+        "empty_message_recovery": {
+          "type": "boolean"
+        },
+        "auto_resume": {
+          "type": "boolean"
+        }
+      }
+    },
+    "auto_update": {
+      "type": "boolean"
     }
   }
 }

package.json

@@ -1,6 +1,6 @@
 {
   "name": "oh-my-opencode",
-  "version": "2.3.0",
+  "version": "2.4.0",
   "description": "OpenCode plugin - custom agents (oracle, librarian) and enhanced features",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -24,7 +24,8 @@
     "build:schema": "bun run script/build-schema.ts",
     "clean": "rm -rf dist",
     "prepublishOnly": "bun run clean && bun run build",
-    "typecheck": "tsc --noEmit"
+    "typecheck": "tsc --noEmit",
+    "test": "bun test"
   },
   "keywords": [
     "opencode",

script/generate-changelog.ts

@@ -0,0 +1,92 @@
+#!/usr/bin/env bun
+
+import { $ } from "bun"
+
+const TEAM = ["actions-user", "github-actions[bot]", "code-yeongyu"]
+
+async function getLatestReleasedTag(): Promise<string | null> {
+  try {
+    const tag = await $`gh release list --exclude-drafts --exclude-pre-releases --limit 1 --json tagName --jq '.[0].tagName // empty'`.text()
+    return tag.trim() || null
+  } catch {
+    return null
+  }
+}
+
+async function generateChangelog(previousTag: string): Promise<string[]> {
+  const notes: string[] = []
+
+  try {
+    const log = await $`git log ${previousTag}..HEAD --oneline --format="%h %s"`.text()
+    const commits = log
+      .split("\n")
+      .filter((line) => line && !line.match(/^\w+ (ignore:|test:|chore:|ci:|release:)/i))
+
+    if (commits.length > 0) {
+      for (const commit of commits) {
+        notes.push(`- ${commit}`)
+      }
+    }
+  } catch {
+    // No previous tags found
+  }
+
+  return notes
+}
+
+async function getContributors(previousTag: string): Promise<string[]> {
+  const notes: string[] = []
+
+  try {
+    const compare =
+      await $`gh api "/repos/code-yeongyu/oh-my-opencode/compare/${previousTag}...HEAD" --jq '.commits[] | {login: .author.login, message: .commit.message}'`.text()
+    const contributors = new Map<string, string[]>()
+
+    for (const line of compare.split("\n").filter(Boolean)) {
+      const { login, message } = JSON.parse(line) as { login: string | null; message: string }
+      const title = message.split("\n")[0] ?? ""
+      if (title.match(/^(ignore:|test:|chore:|ci:|release:)/i)) continue
+
+      if (login && !TEAM.includes(login)) {
+        if (!contributors.has(login)) contributors.set(login, [])
+        contributors.get(login)?.push(title)
+      }
+    }
+
+    if (contributors.size > 0) {
+      notes.push("")
+      notes.push(`**Thank you to ${contributors.size} community contributor${contributors.size > 1 ? "s" : ""}:**`)
+      for (const [username, userCommits] of contributors) {
+        notes.push(`- @${username}:`)
+        for (const commit of userCommits) {
+          notes.push(`  - ${commit}`)
+        }
+      }
+    }
+  } catch {
+    // Failed to fetch contributors
+  }
+
+  return notes
+}
+
+async function main() {
+  const previousTag = await getLatestReleasedTag()
+
+  if (!previousTag) {
+    console.log("Initial release")
+    process.exit(0)
+  }
+
+  const changelog = await generateChangelog(previousTag)
+  const contributors = await getContributors(previousTag)
+  const notes = [...changelog, ...contributors]
+
+  if (notes.length === 0) {
+    console.log("No notable changes")
+  } else {
+    console.log(notes.join("\n"))
+  }
+}
+
+main()

src/config/schema.ts

@@ -122,6 +122,7 @@ export const OhMyOpenCodeConfigSchema = z.object({
   google_auth: z.boolean().optional(),
   sisyphus_agent: SisyphusAgentConfigSchema.optional(),
   experimental: ExperimentalConfigSchema.optional(),
+  auto_update: z.boolean().optional(),
 })
 
 export type OhMyOpenCodeConfig = z.infer<typeof OhMyOpenCodeConfigSchema>

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

@@ -492,14 +492,19 @@ export async function executeCompact(
         fallbackState.revertAttempt++
         fallbackState.lastRevertedMessageID = pair.userMessageID
 
-        retryState.attempt = 0
-        truncateState.truncateAttempt = 0
+        // Clear all state after successful revert - don't recurse
+        clearSessionState(autoCompactState, sessionID)
 
-        autoCompactState.compactionInProgress.delete(sessionID)
-
-        setTimeout(() => {
-          executeCompact(sessionID, msg, autoCompactState, client, directory, experimental)
-        }, 1000)
+        // Send "Continue" prompt to resume session
+        setTimeout(async () => {
+          try {
+            await (client as Client).session.prompt_async({
+              path: { sessionID },
+              body: { parts: [{ type: "text", text: "Continue" }] },
+              query: { directory },
+            })
+          } catch {}
+        }, 500)
         return
       } catch {}
     } else {

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

@@ -3,6 +3,49 @@ import * as path from "node:path"
 import { CACHE_DIR, PACKAGE_NAME } from "./constants"
 import { log } from "../../shared/logger"
 
+interface BunLockfile {
+  workspaces?: {
+    ""?: {
+      dependencies?: Record<string, string>
+    }
+  }
+  packages?: Record<string, unknown>
+}
+
+function stripTrailingCommas(json: string): string {
+  return json.replace(/,(\s*[}\]])/g, "$1")
+}
+
+function removeFromBunLock(packageName: string): boolean {
+  const lockPath = path.join(CACHE_DIR, "bun.lock")
+  if (!fs.existsSync(lockPath)) return false
+
+  try {
+    const content = fs.readFileSync(lockPath, "utf-8")
+    const lock = JSON.parse(stripTrailingCommas(content)) as BunLockfile
+    let modified = false
+
+    if (lock.workspaces?.[""]?.dependencies?.[packageName]) {
+      delete lock.workspaces[""].dependencies[packageName]
+      modified = true
+    }
+
+    if (lock.packages?.[packageName]) {
+      delete lock.packages[packageName]
+      modified = true
+    }
+
+    if (modified) {
+      fs.writeFileSync(lockPath, JSON.stringify(lock, null, 2))
+      log(`[auto-update-checker] Removed from bun.lock: ${packageName}`)
+    }
+
+    return modified
+  } catch {
+    return false
+  }
+}
+
 export function invalidatePackage(packageName: string = PACKAGE_NAME): boolean {
   try {
     const pkgDir = path.join(CACHE_DIR, "node_modules", packageName)
@@ -10,6 +53,7 @@ export function invalidatePackage(packageName: string = PACKAGE_NAME): boolean {
 
     let packageRemoved = false
     let dependencyRemoved = false
+    let lockRemoved = false
 
     if (fs.existsSync(pkgDir)) {
       fs.rmSync(pkgDir, { recursive: true, force: true })
@@ -28,7 +72,9 @@ export function invalidatePackage(packageName: string = PACKAGE_NAME): boolean {
       }
     }
 
-    if (!packageRemoved && !dependencyRemoved) {
+    lockRemoved = removeFromBunLock(packageName)
+
+    if (!packageRemoved && !dependencyRemoved && !lockRemoved) {
       log(`[auto-update-checker] Package not found, nothing to invalidate: ${packageName}`)
       return false
     }

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

@@ -97,6 +97,7 @@ export interface PluginEntryInfo {
   entry: string
   isPinned: boolean
   pinnedVersion: string | null
+  configPath: string
 }
 
 export function findPluginEntry(directory: string): PluginEntryInfo | null {
@@ -109,12 +110,12 @@ export function findPluginEntry(directory: string): PluginEntryInfo | null {
 
       for (const entry of plugins) {
         if (entry === PACKAGE_NAME) {
-          return { entry, isPinned: false, pinnedVersion: null }
+          return { entry, isPinned: false, pinnedVersion: null, configPath }
         }
         if (entry.startsWith(`${PACKAGE_NAME}@`)) {
           const pinnedVersion = entry.slice(PACKAGE_NAME.length + 1)
           const isPinned = pinnedVersion !== "latest"
-          return { entry, isPinned, pinnedVersion: isPinned ? pinnedVersion : null }
+          return { entry, isPinned, pinnedVersion: isPinned ? pinnedVersion : null, configPath }
         }
       }
     } catch {
@@ -149,6 +150,64 @@ export function getCachedVersion(): string | null {
   return null
 }
 
+/**
+ * Updates a pinned version entry in the config file.
+ * Only replaces within the "plugin" array to avoid unintended edits.
+ * Preserves JSONC comments and formatting via string replacement.
+ */
+export function updatePinnedVersion(configPath: string, oldEntry: string, newVersion: string): boolean {
+  try {
+    const content = fs.readFileSync(configPath, "utf-8")
+    const newEntry = `${PACKAGE_NAME}@${newVersion}`
+    
+    // Find the "plugin" array region to scope replacement
+    const pluginMatch = content.match(/"plugin"\s*:\s*\[/)
+    if (!pluginMatch || pluginMatch.index === undefined) {
+      log(`[auto-update-checker] No "plugin" array found in ${configPath}`)
+      return false
+    }
+    
+    // Find the closing bracket of the plugin array
+    const startIdx = pluginMatch.index + pluginMatch[0].length
+    let bracketCount = 1
+    let endIdx = startIdx
+    
+    for (let i = startIdx; i < content.length && bracketCount > 0; i++) {
+      if (content[i] === "[") bracketCount++
+      else if (content[i] === "]") bracketCount--
+      endIdx = i
+    }
+    
+    const before = content.slice(0, startIdx)
+    const pluginArrayContent = content.slice(startIdx, endIdx)
+    const after = content.slice(endIdx)
+    
+    // Only replace first occurrence within plugin array
+    const escapedOldEntry = oldEntry.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")
+    const regex = new RegExp(`["']${escapedOldEntry}["']`)
+    
+    if (!regex.test(pluginArrayContent)) {
+      log(`[auto-update-checker] Entry "${oldEntry}" not found in plugin array of ${configPath}`)
+      return false
+    }
+    
+    const updatedPluginArray = pluginArrayContent.replace(regex, `"${newEntry}"`)
+    const updatedContent = before + updatedPluginArray + after
+    
+    if (updatedContent === content) {
+      log(`[auto-update-checker] No changes made to ${configPath}`)
+      return false
+    }
+    
+    fs.writeFileSync(configPath, updatedContent, "utf-8")
+    log(`[auto-update-checker] Updated ${configPath}: ${oldEntry} → ${newEntry}`)
+    return true
+  } catch (err) {
+    log(`[auto-update-checker] Failed to update config file ${configPath}:`, err)
+    return false
+  }
+}
+
 export async function getLatestVersion(): Promise<string | null> {
   const controller = new AbortController()
   const timeoutId = setTimeout(() => controller.abort(), NPM_FETCH_TIMEOUT)

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

@@ -1,5 +1,5 @@
 import type { PluginInput } from "@opencode-ai/plugin"
-import { checkForUpdate, getCachedVersion, getLocalDevVersion } from "./checker"
+import { getCachedVersion, getLocalDevVersion, findPluginEntry, getLatestVersion, updatePinnedVersion } from "./checker"
 import { invalidatePackage } from "./cache"
 import { PACKAGE_NAME } from "./constants"
 import { log } from "../../shared/logger"
@@ -7,7 +7,7 @@ import { getConfigLoadErrors, clearConfigLoadErrors } from "../../shared/config-
 import type { AutoUpdateCheckerOptions } from "./types"
 
 export function createAutoUpdateCheckerHook(ctx: PluginInput, options: AutoUpdateCheckerOptions = {}) {
-  const { showStartupToast = true, isSisyphusEnabled = false } = options
+  const { showStartupToast = true, isSisyphusEnabled = false, autoUpdate = true } = options
 
   const getToastMessage = (isUpdate: boolean, latestVersion?: string): string => {
     if (isSisyphusEnabled) {
@@ -20,25 +20,10 @@ export function createAutoUpdateCheckerHook(ctx: PluginInput, options: AutoUpdat
       : `OpenCode is now on Steroids. oMoMoMoMo...`
   }
 
-  const showVersionToast = async (version: string | null): Promise<void> => {
-    const displayVersion = version ?? "unknown"
-    await ctx.client.tui
-      .showToast({
-        body: {
-          title: `OhMyOpenCode ${displayVersion}`,
-          message: getToastMessage(false),
-          variant: "info" as const,
-          duration: 5000,
-        },
-      })
-      .catch(() => {})
-    log(`[auto-update-checker] Startup toast shown: v${displayVersion}`)
-  }
-
   let hasChecked = false
 
   return {
-    event: async ({ event }: { event: { type: string; properties?: unknown } }) => {
+    event: ({ event }: { event: { type: string; properties?: unknown } }) => {
       if (event.type !== "session.created") return
       if (hasChecked) return
 
@@ -47,57 +32,85 @@ export function createAutoUpdateCheckerHook(ctx: PluginInput, options: AutoUpdat
 
       hasChecked = true
 
-      try {
-        const result = await checkForUpdate(ctx.directory)
+      setTimeout(() => {
+        const cachedVersion = getCachedVersion()
+        const localDevVersion = getLocalDevVersion(ctx.directory)
+        const displayVersion = localDevVersion ?? cachedVersion
 
-        if (result.isLocalDev) {
-          log("[auto-update-checker] Skipped: local development mode")
+        showConfigErrorsIfAny(ctx).catch(() => {})
+
+        if (localDevVersion) {
           if (showStartupToast) {
-            const version = getLocalDevVersion(ctx.directory) ?? getCachedVersion()
-            await showVersionToast(version)
+            showLocalDevToast(ctx, displayVersion, isSisyphusEnabled).catch(() => {})
           }
+          log("[auto-update-checker] Local development mode")
           return
         }
 
-        if (result.isPinned) {
-          log(`[auto-update-checker] Skipped: version pinned to ${result.currentVersion}`)
-          if (showStartupToast) {
-            await showVersionToast(result.currentVersion)
-          }
-          return
+        if (showStartupToast) {
+          showVersionToast(ctx, displayVersion, getToastMessage(false)).catch(() => {})
         }
 
-        if (!result.needsUpdate) {
-          log("[auto-update-checker] No update needed")
-          if (showStartupToast) {
-            await showVersionToast(result.currentVersion)
-          }
-          return
-        }
-
-        invalidatePackage(PACKAGE_NAME)
-
-        await ctx.client.tui
-          .showToast({
-            body: {
-              title: `OhMyOpenCode ${result.latestVersion}`,
-              message: getToastMessage(true, result.latestVersion ?? undefined),
-              variant: "info" as const,
-              duration: 8000,
-            },
-          })
-          .catch(() => {})
-
-        log(`[auto-update-checker] Update notification sent: v${result.currentVersion} → v${result.latestVersion}`)
-      } catch (err) {
-        log("[auto-update-checker] Error during update check:", err)
-      }
-
-      await showConfigErrorsIfAny(ctx)
+        runBackgroundUpdateCheck(ctx, autoUpdate, getToastMessage).catch(err => {
+          log("[auto-update-checker] Background update check failed:", err)
+        })
+      }, 0)
     },
   }
 }
 
+async function runBackgroundUpdateCheck(
+  ctx: PluginInput, 
+  autoUpdate: boolean,
+  getToastMessage: (isUpdate: boolean, latestVersion?: string) => string
+): Promise<void> {
+  const pluginInfo = findPluginEntry(ctx.directory)
+  if (!pluginInfo) {
+    log("[auto-update-checker] Plugin not found in config")
+    return
+  }
+
+  const cachedVersion = getCachedVersion()
+  const currentVersion = cachedVersion ?? pluginInfo.pinnedVersion
+  if (!currentVersion) {
+    log("[auto-update-checker] No version found (cached or pinned)")
+    return
+  }
+
+  const latestVersion = await getLatestVersion()
+  if (!latestVersion) {
+    log("[auto-update-checker] Failed to fetch latest version")
+    return
+  }
+
+  if (currentVersion === latestVersion) {
+    log("[auto-update-checker] Already on latest version")
+    return
+  }
+
+  log(`[auto-update-checker] Update available: ${currentVersion} → ${latestVersion}`)
+
+  if (!autoUpdate) {
+    await showUpdateAvailableToast(ctx, latestVersion, getToastMessage)
+    log("[auto-update-checker] Auto-update disabled, notification only")
+    return
+  }
+
+  if (pluginInfo.isPinned) {
+    const updated = updatePinnedVersion(pluginInfo.configPath, pluginInfo.entry, latestVersion)
+    if (updated) {
+      invalidatePackage(PACKAGE_NAME)
+      await showAutoUpdatedToast(ctx, currentVersion, latestVersion)
+      log(`[auto-update-checker] Config updated: ${pluginInfo.entry} → ${PACKAGE_NAME}@${latestVersion}`)
+    } else {
+      await showUpdateAvailableToast(ctx, latestVersion, getToastMessage)
+    }
+  } else {
+    invalidatePackage(PACKAGE_NAME)
+    await showUpdateAvailableToast(ctx, latestVersion, getToastMessage)
+  }
+}
+
 async function showConfigErrorsIfAny(ctx: PluginInput): Promise<void> {
   const errors = getConfigLoadErrors()
   if (errors.length === 0) return
@@ -118,6 +131,71 @@ async function showConfigErrorsIfAny(ctx: PluginInput): Promise<void> {
   clearConfigLoadErrors()
 }
 
+async function showVersionToast(ctx: PluginInput, version: string | null, message: string): Promise<void> {
+  const displayVersion = version ?? "unknown"
+  await ctx.client.tui
+    .showToast({
+      body: {
+        title: `OhMyOpenCode ${displayVersion}`,
+        message,
+        variant: "info" as const,
+        duration: 5000,
+      },
+    })
+    .catch(() => {})
+  log(`[auto-update-checker] Startup toast shown: v${displayVersion}`)
+}
+
+async function showUpdateAvailableToast(
+  ctx: PluginInput, 
+  latestVersion: string,
+  getToastMessage: (isUpdate: boolean, latestVersion?: string) => string
+): Promise<void> {
+  await ctx.client.tui
+    .showToast({
+      body: {
+        title: `OhMyOpenCode ${latestVersion}`,
+        message: getToastMessage(true, latestVersion),
+        variant: "info" as const,
+        duration: 8000,
+      },
+    })
+    .catch(() => {})
+  log(`[auto-update-checker] Update available toast shown: v${latestVersion}`)
+}
+
+async function showAutoUpdatedToast(ctx: PluginInput, oldVersion: string, newVersion: string): Promise<void> {
+  await ctx.client.tui
+    .showToast({
+      body: {
+        title: `OhMyOpenCode Updated!`,
+        message: `v${oldVersion} → v${newVersion}\nRestart OpenCode to apply.`,
+        variant: "success" as const,
+        duration: 8000,
+      },
+    })
+    .catch(() => {})
+  log(`[auto-update-checker] Auto-updated toast shown: v${oldVersion} → v${newVersion}`)
+}
+
+async function showLocalDevToast(ctx: PluginInput, version: string | null, isSisyphusEnabled: boolean): Promise<void> {
+  const displayVersion = version ?? "dev"
+  const message = isSisyphusEnabled
+    ? "Sisyphus running in local development mode."
+    : "Running in local development mode. oMoMoMo..."
+  await ctx.client.tui
+    .showToast({
+      body: {
+        title: `OhMyOpenCode ${displayVersion} (dev)`,
+        message,
+        variant: "warning" as const,
+        duration: 5000,
+      },
+    })
+    .catch(() => {})
+  log(`[auto-update-checker] Local dev toast shown: v${displayVersion}`)
+}
+
 export type { UpdateCheckResult, AutoUpdateCheckerOptions } from "./types"
 export { checkForUpdate } from "./checker"
 export { invalidatePackage, invalidateCache } from "./cache"

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

@@ -25,4 +25,5 @@ export interface UpdateCheckResult {
 export interface AutoUpdateCheckerOptions {
   showStartupToast?: boolean
   isSisyphusEnabled?: boolean
+  autoUpdate?: boolean
 }

src/hooks/grep-output-truncator.ts

@@ -1,131 +0,0 @@
-import type { PluginInput } from "@opencode-ai/plugin"
-
-const ANTHROPIC_ACTUAL_LIMIT = 200_000
-const CHARS_PER_TOKEN_ESTIMATE = 4
-const TARGET_MAX_TOKENS = 50_000
-
-interface AssistantMessageInfo {
-  role: "assistant"
-  tokens: {
-    input: number
-    output: number
-    reasoning: number
-    cache: { read: number; write: number }
-  }
-}
-
-interface MessageWrapper {
-  info: { role: string } & Partial<AssistantMessageInfo>
-}
-
-function estimateTokens(text: string): number {
-  return Math.ceil(text.length / CHARS_PER_TOKEN_ESTIMATE)
-}
-
-function truncateToTokenLimit(output: string, maxTokens: number): { result: string; truncated: boolean } {
-  const currentTokens = estimateTokens(output)
-
-  if (currentTokens <= maxTokens) {
-    return { result: output, truncated: false }
-  }
-
-  const lines = output.split("\n")
-
-  if (lines.length <= 3) {
-    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, 3)
-  const contentLines = lines.slice(3)
-
-  const headerText = headerLines.join("\n")
-  const headerTokens = estimateTokens(headerText)
-  const availableTokens = maxTokens - headerTokens - 50
-
-  if (availableTokens <= 0) {
-    return {
-      result: headerText + "\n\n[Content truncated due to context window limit]",
-      truncated: true,
-    }
-  }
-
-  let 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
-  }
-
-  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,
-  }
-}
-
-export function createGrepOutputTruncatorHook(ctx: PluginInput) {
-  const GREP_TOOLS = ["grep", "Grep", "safe_grep"]
-
-  const toolExecuteAfter = async (
-    input: { tool: string; sessionID: string; callID: string },
-    output: { title: string; output: string; metadata: unknown }
-  ) => {
-    if (!GREP_TOOLS.includes(input.tool)) return
-
-    const { sessionID } = input
-
-    try {
-      const response = await ctx.client.session.messages({
-        path: { id: sessionID },
-      })
-
-      const messages = (response.data ?? response) as MessageWrapper[]
-
-      const assistantMessages = messages
-        .filter((m) => m.info.role === "assistant")
-        .map((m) => m.info as AssistantMessageInfo)
-
-      if (assistantMessages.length === 0) return
-
-      // Use only the last assistant message's input tokens
-      // This reflects the ACTUAL current context window usage (post-compaction)
-      const lastAssistant = assistantMessages[assistantMessages.length - 1]
-      const lastTokens = lastAssistant.tokens
-      const totalInputTokens = (lastTokens?.input ?? 0) + (lastTokens?.cache?.read ?? 0)
-
-      const remainingTokens = ANTHROPIC_ACTUAL_LIMIT - totalInputTokens
-
-      const maxOutputTokens = Math.min(
-        remainingTokens * 0.5,
-        TARGET_MAX_TOKENS
-      )
-
-      if (maxOutputTokens <= 0) {
-        output.output = "[Output suppressed - context window exhausted]"
-        return
-      }
-
-      const { result, truncated } = truncateToTokenLimit(output.output, maxOutputTokens)
-      if (truncated) {
-        output.output = result
-      }
-    } catch {
-      // Graceful degradation
-    }
-  }
-
-  return {
-    "tool.execute.after": toolExecuteAfter,
-  }
-}

src/hooks/index.ts

@@ -3,7 +3,6 @@ export { createContextWindowMonitorHook } from "./context-window-monitor";
 export { createSessionNotification } from "./session-notification";
 export { createSessionRecoveryHook, type SessionRecoveryHook, type SessionRecoveryOptions } from "./session-recovery";
 export { createCommentCheckerHooks } from "./comment-checker";
-export { createGrepOutputTruncatorHook } from "./grep-output-truncator";
 export { createToolOutputTruncatorHook } from "./tool-output-truncator";
 export { createDirectoryAgentsInjectorHook } from "./directory-agents-injector";
 export { createDirectoryReadmeInjectorHook } from "./directory-readme-injector";

src/hooks/keyword-detector/constants.ts

@@ -31,6 +31,14 @@ 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
 
+## ZERO TOLERANCE FAILURES
+- **NO Scope Reduction**: Never make "demo", "skeleton", "simplified", "basic" versions - deliver FULL implementation
+- **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
+
+THE USER ASKED FOR X. DELIVER EXACTLY X. NOT A SUBSET. NOT A DEMO. NOT A STARTING POINT.
+
 </ultrawork-mode>
 
 ---
@@ -53,17 +61,16 @@ NEVER stop at first result - be exhaustive.`,
     pattern:
       /\b(analyze|analyse|investigate|examine|research|study|deep[\s-]?dive|inspect|audit|evaluate|assess|review|diagnose|scrutinize|dissect|debug|comprehend|interpret|breakdown|understand)\b|why\s+is|how\s+does|how\s+to|분석|조사|파악|연구|검토|진단|이해|설명|원인|이유|뜯어봐|따져봐|평가|해석|디버깅|디버그|어떻게|왜|살펴|分析|調査|解析|検討|研究|診断|理解|説明|検証|精査|究明|デバッグ|なぜ|どう|仕組み|调查|检查|剖析|深入|诊断|解释|调试|为什么|原理|搞清楚|弄明白|phân tích|điều tra|nghiên cứu|kiểm tra|xem xét|chẩn đoán|giải thích|tìm hiểu|gỡ lỗi|tại sao/i,
     message: `[analyze-mode]
-DEEP ANALYSIS MODE. Execute in phases:
+ANALYSIS MODE. Gather context before diving deep:
 
-PHASE 1 - GATHER CONTEXT (10+ agents parallel):
-- 3+ explore agents (codebase structure, patterns, implementations)
-- 3+ librarian agents (official docs, best practices, examples)
-- 2+ general agents (different analytical perspectives)
+CONTEXT GATHERING (parallel):
+- 1-2 explore agents (codebase patterns, implementations)
+- 1-2 librarian agents (if external library involved)
+- Direct tools: Grep, AST-grep, LSP for targeted searches
 
-PHASE 2 - EXPERT CONSULTATION (after Phase 1):
-- 3+ oracle agents in parallel with gathered context
-- Each oracle: different angle (architecture, performance, edge cases)
+IF COMPLEX (architecture, multi-system, debugging after 2+ failures):
+- Consult oracle for strategic guidance
 
-SYNTHESIZE: Cross-reference findings, identify consensus & contradictions.`,
+SYNTHESIZE findings before proceeding.`,
   },
 ]

src/hooks/keyword-detector/index.ts

@@ -6,6 +6,8 @@ export * from "./detector"
 export * from "./constants"
 export * from "./types"
 
+const sessionFirstMessageProcessed = new Set<string>()
+
 export function createKeywordDetectorHook() {
   return {
     "chat.message": async (
@@ -20,6 +22,14 @@ export function createKeywordDetectorHook() {
         parts: Array<{ type: string; text?: string; [key: string]: unknown }>
       }
     ): Promise<void> => {
+      const isFirstMessage = !sessionFirstMessageProcessed.has(input.sessionID)
+      sessionFirstMessageProcessed.add(input.sessionID)
+
+      if (isFirstMessage) {
+        log("Skipping keyword detection on first message for title generation", { sessionID: input.sessionID })
+        return
+      }
+
       const promptText = extractPromptText(output.parts)
       const messages = detectKeywords(promptText)
 

src/hooks/non-interactive-env/constants.ts

@@ -6,4 +6,12 @@ export const NON_INTERACTIVE_ENV: Record<string, string> = {
   GIT_TERMINAL_PROMPT: "0",
   GCM_INTERACTIVE: "never",
   HOMEBREW_NO_AUTO_UPDATE: "1",
+  // Block interactive editors - git rebase, commit, etc.
+  GIT_EDITOR: "true",
+  EDITOR: "true",
+  VISUAL: "true",
+  GIT_SEQUENCE_EDITOR: "true",
+  // Block pagers
+  GIT_PAGER: "cat",
+  PAGER: "cat",
 }

src/hooks/todo-continuation-enforcer.ts

@@ -1,6 +1,7 @@
 import { existsSync, readdirSync } from "node:fs"
 import { join } from "node:path"
 import type { PluginInput } from "@opencode-ai/plugin"
+import { getMainSessionID } from "../features/claude-code-session-state"
 import {
   findNearestMessageWithFields,
   MESSAGE_STORAGE,
@@ -61,12 +62,20 @@ function detectInterrupt(error: unknown): boolean {
   return false
 }
 
+const COUNTDOWN_SECONDS = 5
+const TOAST_DURATION_MS = 900 // Slightly less than 1s so toasts don't overlap
+
+interface CountdownState {
+  secondsRemaining: number
+  intervalId: ReturnType<typeof setInterval>
+}
+
 export function createTodoContinuationEnforcer(ctx: PluginInput): TodoContinuationEnforcer {
   const remindedSessions = new Set<string>()
   const interruptedSessions = new Set<string>()
   const errorSessions = new Set<string>()
   const recoveringSessions = new Set<string>()
-  const pendingTimers = new Map<string, ReturnType<typeof setTimeout>>()
+  const pendingCountdowns = new Map<string, CountdownState>()
 
   const markRecovering = (sessionID: string): void => {
     recoveringSessions.add(sessionID)
@@ -89,11 +98,10 @@ export function createTodoContinuationEnforcer(ctx: PluginInput): TodoContinuati
         }
         log(`[${HOOK_NAME}] session.error received`, { sessionID, isInterrupt, error: props?.error })
         
-        // Cancel pending continuation if error occurs
-        const timer = pendingTimers.get(sessionID)
-        if (timer) {
-          clearTimeout(timer)
-          pendingTimers.delete(sessionID)
+        const countdown = pendingCountdowns.get(sessionID)
+        if (countdown) {
+          clearInterval(countdown.intervalId)
+          pendingCountdowns.delete(sessionID)
         }
       }
       return
@@ -105,76 +113,99 @@ export function createTodoContinuationEnforcer(ctx: PluginInput): TodoContinuati
 
       log(`[${HOOK_NAME}] session.idle received`, { sessionID })
 
-      // Cancel any existing timer to debounce
-      const existingTimer = pendingTimers.get(sessionID)
-      if (existingTimer) {
-        clearTimeout(existingTimer)
-        log(`[${HOOK_NAME}] Cancelled existing timer`, { sessionID })
+      const mainSessionID = getMainSessionID()
+      if (mainSessionID && sessionID !== mainSessionID) {
+        log(`[${HOOK_NAME}] Skipped: not main session`, { sessionID, mainSessionID })
+        return
       }
 
-      // Schedule continuation check
-      const timer = setTimeout(async () => {
-        pendingTimers.delete(sessionID)
-        log(`[${HOOK_NAME}] Timer fired, checking conditions`, { sessionID })
+      const existingCountdown = pendingCountdowns.get(sessionID)
+      if (existingCountdown) {
+        clearInterval(existingCountdown.intervalId)
+        pendingCountdowns.delete(sessionID)
+        log(`[${HOOK_NAME}] Cancelled existing countdown`, { sessionID })
+      }
 
-        // Check if session is in recovery mode - if so, skip entirely without clearing state
-        if (recoveringSessions.has(sessionID)) {
-          log(`[${HOOK_NAME}] Skipped: session in recovery mode`, { sessionID })
-          return
-        }
+      // Check if session is in recovery mode - if so, skip entirely without clearing state
+      if (recoveringSessions.has(sessionID)) {
+        log(`[${HOOK_NAME}] Skipped: session in recovery mode`, { sessionID })
+        return
+      }
 
-        const shouldBypass = interruptedSessions.has(sessionID) || errorSessions.has(sessionID)
-        
+      const shouldBypass = interruptedSessions.has(sessionID) || errorSessions.has(sessionID)
+      
+      if (shouldBypass) {
         interruptedSessions.delete(sessionID)
         errorSessions.delete(sessionID)
+        log(`[${HOOK_NAME}] Skipped: error/interrupt bypass`, { sessionID })
+        return
+      }
 
-        if (shouldBypass) {
-          log(`[${HOOK_NAME}] Skipped: error/interrupt bypass`, { sessionID })
+      if (remindedSessions.has(sessionID)) {
+        log(`[${HOOK_NAME}] Skipped: already reminded this session`, { sessionID })
+        return
+      }
+
+      // Check for incomplete todos BEFORE starting countdown
+      let todos: Todo[] = []
+      try {
+        log(`[${HOOK_NAME}] Fetching todos for session`, { sessionID })
+        const response = await ctx.client.session.todo({
+          path: { id: sessionID },
+        })
+        todos = (response.data ?? response) as Todo[]
+        log(`[${HOOK_NAME}] Todo API response`, { sessionID, todosCount: todos?.length ?? 0 })
+      } catch (err) {
+        log(`[${HOOK_NAME}] Todo API error`, { sessionID, error: String(err) })
+        return
+      }
+
+      if (!todos || todos.length === 0) {
+        log(`[${HOOK_NAME}] No todos found`, { sessionID })
+        return
+      }
+
+      const incomplete = todos.filter(
+        (t) => t.status !== "completed" && t.status !== "cancelled"
+      )
+
+      if (incomplete.length === 0) {
+        log(`[${HOOK_NAME}] All todos completed`, { sessionID, total: todos.length })
+        return
+      }
+
+      log(`[${HOOK_NAME}] Found incomplete todos, starting countdown`, { sessionID, incomplete: incomplete.length, total: todos.length })
+
+      const showCountdownToast = async (seconds: number): Promise<void> => {
+        await ctx.client.tui.showToast({
+          body: {
+            title: "Todo Continuation",
+            message: `Resuming in ${seconds}s... (${incomplete.length} tasks remaining)`,
+            variant: "warning" as const,
+            duration: TOAST_DURATION_MS,
+          },
+        }).catch(() => {})
+      }
+
+      const executeAfterCountdown = async (): Promise<void> => {
+        pendingCountdowns.delete(sessionID)
+        log(`[${HOOK_NAME}] Countdown finished, executing continuation`, { sessionID })
+
+        // Re-check conditions after countdown
+        if (recoveringSessions.has(sessionID)) {
+          log(`[${HOOK_NAME}] Abort: session entered recovery mode during countdown`, { sessionID })
           return
         }
 
-        if (remindedSessions.has(sessionID)) {
-          log(`[${HOOK_NAME}] Skipped: already reminded this session`, { sessionID })
+        if (interruptedSessions.has(sessionID) || errorSessions.has(sessionID)) {
+          log(`[${HOOK_NAME}] Abort: error/interrupt occurred during countdown`, { sessionID })
+          interruptedSessions.delete(sessionID)
+          errorSessions.delete(sessionID)
           return
         }
 
-        let todos: Todo[] = []
-        try {
-          log(`[${HOOK_NAME}] Fetching todos for session`, { sessionID })
-          const response = await ctx.client.session.todo({
-            path: { id: sessionID },
-          })
-          todos = (response.data ?? response) as Todo[]
-          log(`[${HOOK_NAME}] Todo API response`, { sessionID, todosCount: todos?.length ?? 0 })
-        } catch (err) {
-          log(`[${HOOK_NAME}] Todo API error`, { sessionID, error: String(err) })
-          return
-        }
-
-        if (!todos || todos.length === 0) {
-          log(`[${HOOK_NAME}] No todos found`, { sessionID })
-          return
-        }
-
-        const incomplete = todos.filter(
-          (t) => t.status !== "completed" && t.status !== "cancelled"
-        )
-
-        if (incomplete.length === 0) {
-          log(`[${HOOK_NAME}] All todos completed`, { sessionID, total: todos.length })
-          return
-        }
-
-        log(`[${HOOK_NAME}] Found incomplete todos`, { sessionID, incomplete: incomplete.length, total: todos.length })
         remindedSessions.add(sessionID)
 
-        // Re-check if abort occurred during the delay/fetch
-        if (interruptedSessions.has(sessionID) || errorSessions.has(sessionID) || recoveringSessions.has(sessionID)) {
-          log(`[${HOOK_NAME}] Abort occurred during delay/fetch`, { sessionID })
-          remindedSessions.delete(sessionID)
-          return
-        }
-
         try {
           // Get previous message's agent info to respect agent mode
           const messageDir = getMessageDir(sessionID)
@@ -206,9 +237,32 @@ export function createTodoContinuationEnforcer(ctx: PluginInput): TodoContinuati
           log(`[${HOOK_NAME}] Prompt injection failed`, { sessionID, error: String(err) })
           remindedSessions.delete(sessionID)
         }
-      }, 5000)
+      }
 
-      pendingTimers.set(sessionID, timer)
+      let secondsRemaining = COUNTDOWN_SECONDS
+      showCountdownToast(secondsRemaining).catch(() => {})
+
+      const intervalId = setInterval(() => {
+        secondsRemaining--
+        
+        if (secondsRemaining <= 0) {
+          clearInterval(intervalId)
+          pendingCountdowns.delete(sessionID)
+          executeAfterCountdown()
+          return
+        }
+
+        const countdown = pendingCountdowns.get(sessionID)
+        if (!countdown) {
+          clearInterval(intervalId)
+          return
+        }
+
+        countdown.secondsRemaining = secondsRemaining
+        showCountdownToast(secondsRemaining).catch(() => {})
+      }, 1000)
+
+      pendingCountdowns.set(sessionID, { secondsRemaining, intervalId })
     }
 
     if (event.type === "message.updated") {
@@ -217,12 +271,11 @@ export function createTodoContinuationEnforcer(ctx: PluginInput): TodoContinuati
       log(`[${HOOK_NAME}] message.updated received`, { sessionID, role: info?.role })
       
       if (sessionID && info?.role === "user") {
-        // Cancel pending continuation on user interaction (real user input)
-        const timer = pendingTimers.get(sessionID)
-        if (timer) {
-          clearTimeout(timer)
-          pendingTimers.delete(sessionID)
-          log(`[${HOOK_NAME}] Cancelled pending timer on user message`, { sessionID })
+        const countdown = pendingCountdowns.get(sessionID)
+        if (countdown) {
+          clearInterval(countdown.intervalId)
+          pendingCountdowns.delete(sessionID)
+          log(`[${HOOK_NAME}] Cancelled countdown on user message`, { sessionID })
         }
       }
       
@@ -241,11 +294,10 @@ export function createTodoContinuationEnforcer(ctx: PluginInput): TodoContinuati
         errorSessions.delete(sessionInfo.id)
         recoveringSessions.delete(sessionInfo.id)
         
-        // Cancel pending continuation
-        const timer = pendingTimers.get(sessionInfo.id)
-        if (timer) {
-          clearTimeout(timer)
-          pendingTimers.delete(sessionInfo.id)
+        const countdown = pendingCountdowns.get(sessionInfo.id)
+        if (countdown) {
+          clearInterval(countdown.intervalId)
+          pendingCountdowns.delete(sessionInfo.id)
         }
       }
     }

src/hooks/tool-output-truncator.ts

@@ -1,8 +1,9 @@
 import type { PluginInput } from "@opencode-ai/plugin"
 import { createDynamicTruncator } from "../shared/dynamic-truncator"
 
-// Note: "grep" and "Grep" are handled by dedicated grep-output-truncator.ts
 const TRUNCATABLE_TOOLS = [
+  "grep",
+  "Grep",
   "safe_grep",
   "glob",
   "Glob",

src/index.ts

@@ -262,6 +262,7 @@ const OhMyOpenCodePlugin: Plugin = async (ctx) => {
     ? createAutoUpdateCheckerHook(ctx, {
         showStartupToast: isHookEnabled("startup-toast"),
         isSisyphusEnabled: pluginConfig.sisyphus_agent?.disabled !== true,
+        autoUpdate: pluginConfig.auto_update ?? true,
       })
     : null;
   const keywordDetector = isHookEnabled("keyword-detector")

src/tools/lsp/constants.ts

@@ -109,6 +109,10 @@ export const BUILTIN_SERVERS: Record<string, Omit<LSPServerConfig, "id">> = {
     command: ["astro-ls", "--stdio"],
     extensions: [".astro"],
   },
+  "bash-ls": {
+    command: ["bash-language-server", "start"],
+    extensions: [".sh", ".bash", ".zsh", ".ksh"],
+  },
   jdtls: {
     command: ["jdtls"],
     extensions: [".java"],