release: v0.2.0

.github/FUNDING.yml

@@ -1,15 +0,0 @@
-# These are supported funding model platforms
-
-github: code-yeongyu
-patreon: # Replace with a single Patreon username
-open_collective: # Replace with a single Open Collective username
-ko_fi: # Replace with a single Ko-fi username
-tidelift: # Replace with a single Tidelift platform-name/package-name e.g., npm/babel
-community_bridge: # Replace with a single Community Bridge project-name e.g., cloud-foundry
-liberapay: # Replace with a single Liberapay username
-issuehunt: # Replace with a single IssueHunt username
-lfx_crowdfunding: # Replace with a single LFX Crowdfunding project-name e.g., cloud-foundry
-polar: # Replace with a single Polar username
-buy_me_a_coffee: # Replace with a single Buy Me a Coffee username
-thanks_dev: # Replace with a single thanks.dev username
-custom: # Replace with up to 4 custom sponsorship URLs e.g., ['link1', 'link2']

.github/pull_request_template.md

@@ -1,34 +0,0 @@
-## Summary
-
-<!-- Brief description of what this PR does. 1-3 bullet points. -->
-
-- 
-
-## Changes
-
-<!-- What was changed and how. List specific modifications. -->
-
-- 
-
-## Screenshots
-
-<!-- If applicable, add screenshots or GIFs showing before/after. Delete this section if not needed. -->
-
-| Before | After |
-|:---:|:---:|
-|  |  |
-
-## Testing
-
-<!-- How to verify this PR works correctly. Delete if not applicable. -->
-
-```bash
-bun run typecheck
-bun test
-```
-
-## Related Issues
-
-<!-- Link related issues. Use "Closes #123" to auto-close on merge. -->
-
-<!-- Closes # -->

.github/workflows/ci.yml

@@ -1,138 +0,0 @@
-name: CI
-
-on:
-  push:
-    branches: [master, dev]
-  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]
-    permissions:
-      contents: write
-    steps:
-      - uses: actions/checkout@v4
-        with:
-          token: ${{ secrets.GITHUB_TOKEN }}
-
-      - 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)
-
-      - name: Auto-commit schema changes
-        if: github.event_name == 'push' && github.ref == 'refs/heads/master'
-        run: |
-          if git diff --quiet assets/oh-my-opencode.schema.json; then
-            echo "No schema changes to commit"
-          else
-            git config user.name "github-actions[bot]"
-            git config user.email "github-actions[bot]@users.noreply.github.com"
-            git add assets/oh-my-opencode.schema.json
-            git commit -m "chore: auto-update schema.json"
-            git push
-          fi
-
-  draft-release:
-    runs-on: ubuntu-latest
-    needs: [build]
-    if: github.event_name == 'push' && github.ref == 'refs/heads/dev'
-    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-file - \
-              --draft <<'EOF'
-          ${{ steps.notes.outputs.notes }}
-          EOF
-          else
-            echo "Creating new draft release..."
-            gh release create next \
-              --title "Upcoming Changes 🍿" \
-              --notes-file - \
-              --draft \
-              --target ${{ github.sha }} <<'EOF'
-          ${{ steps.notes.outputs.notes }}
-          EOF
-          fi
-        env:
-          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}

.github/workflows/cla.yml

@@ -1,41 +0,0 @@
-name: CLA Assistant
-
-on:
-  issue_comment:
-    types: [created]
-  pull_request_target:
-    types: [opened, closed, synchronize]
-
-permissions:
-  actions: write
-  contents: write
-  pull-requests: write
-  statuses: write
-
-jobs:
-  cla:
-    runs-on: ubuntu-latest
-    steps:
-      - name: CLA Assistant
-        if: (github.event.comment.body == 'recheck' || github.event.comment.body == 'I have read the CLA Document and I hereby sign the CLA') || github.event_name == 'pull_request_target'
-        uses: contributor-assistant/github-action@v2.6.1
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        with:
-          path-to-signatures: 'signatures/cla.json'
-          path-to-document: 'https://github.com/code-yeongyu/oh-my-opencode/blob/master/CLA.md'
-          branch: 'dev'
-          allowlist: bot*,dependabot*,github-actions*,*[bot],sisyphus-dev-ai
-          custom-notsigned-prcomment: |
-            Thank you for your contribution! Before we can merge this PR, we need you to sign our [Contributor License Agreement (CLA)](https://github.com/code-yeongyu/oh-my-opencode/blob/master/CLA.md).
-            
-            **To sign the CLA**, please comment on this PR with:
-            ```
-            I have read the CLA Document and I hereby sign the CLA
-            ```
-            
-            This is a one-time requirement. Once signed, all your future contributions will be automatically accepted.
-          custom-pr-sign-comment: 'I have read the CLA Document and I hereby sign the CLA'
-          custom-allsigned-prcomment: |
-            All contributors have signed the CLA. Thank you! ✅
-          lock-pullrequest-aftermerge: false

.github/workflows/publish.yml

@@ -24,44 +24,8 @@ permissions:
   id-token: write
 
 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
-
   publish:
     runs-on: ubuntu-latest
-    needs: [test, typecheck]
-    if: github.repository == 'code-yeongyu/oh-my-opencode'
     steps:
       - uses: actions/checkout@v4
         with:
@@ -103,10 +67,9 @@ jobs:
 
       - name: Build
         run: |
-          echo "=== Running bun build (main) ==="
-          bun build src/index.ts src/google-auth.ts --outdir dist --target bun --format esm --external @ast-grep/napi
-          echo "=== Running bun build (CLI) ==="
-          bun build src/cli/index.ts --outdir dist/cli --target bun --format esm
+          echo "=== Running bun build ==="
+          bun build src/index.ts --outdir dist --target bun --format esm --external @ast-grep/napi
+          echo "=== bun build exit code: $? ==="
           echo "=== Running tsc ==="
           tsc --emitDeclarationOnly
           echo "=== Running build:schema ==="
@@ -114,12 +77,8 @@ jobs:
       
       - name: Verify build output
         run: |
-          echo "=== dist/ contents ==="
           ls -la dist/
-          echo "=== dist/cli/ contents ==="
-          ls -la dist/cli/
           test -f dist/index.js || (echo "ERROR: dist/index.js not found!" && exit 1)
-          test -f dist/cli/index.js || (echo "ERROR: dist/cli/index.js not found!" && exit 1)
 
       - name: Publish
         run: bun run script/publish.ts
@@ -129,17 +88,3 @@ 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 }}
-
-      - name: Merge to master
-        run: |
-          git config user.name "github-actions[bot]"
-          git config user.email "github-actions[bot]@users.noreply.github.com"
-          VERSION=$(jq -r '.version' package.json)
-          git checkout master
-          git reset --hard "v${VERSION}"
-          git push -f origin master

.github/workflows/sisyphus-agent.yml

@@ -1,376 +0,0 @@
-name: Sisyphus Agent
-
-on:
-  workflow_dispatch:
-    inputs:
-      prompt:
-        description: "Custom prompt"
-        required: false
-  # Only issue_comment works for fork PRs (secrets available)
-  # pull_request_review/pull_request_review_comment do NOT get secrets for fork PRs
-  issue_comment:
-    types: [created]
-
-jobs:
-  agent:
-    runs-on: ubuntu-latest
-    # @sisyphus-dev-ai mention only (maintainers, exclude self)
-    if: |
-      github.event_name == 'workflow_dispatch' ||
-      (contains(github.event.comment.body, '@sisyphus-dev-ai') &&
-       github.event.comment.user.login != 'sisyphus-dev-ai' &&
-       contains(fromJSON('["OWNER", "MEMBER", "COLLABORATOR"]'), github.event.comment.author_association))
-
-    # Minimal default GITHUB_TOKEN permissions
-    permissions:
-      contents: read
-
-    steps:
-      # Checkout with sisyphus-dev-ai's PAT
-      - uses: actions/checkout@v5
-        with:
-          token: ${{ secrets.GH_PAT }}
-          fetch-depth: 0
-
-      # Git config - commits as sisyphus-dev-ai
-      - name: Configure Git as sisyphus-dev-ai
-        run: |
-          git config user.name "sisyphus-dev-ai"
-          git config user.email "sisyphus-dev-ai@users.noreply.github.com"
-
-      # gh CLI auth as sisyphus-dev-ai
-      - name: Authenticate gh CLI as sisyphus-dev-ai
-        run: |
-          echo "${{ secrets.GH_PAT }}" | gh auth login --with-token
-          gh auth status
-
-      - name: Ensure tmux is available (Linux)
-        if: runner.os == 'Linux'
-        run: |
-          set -euo pipefail
-          if ! command -v tmux >/dev/null 2>&1; then
-            sudo apt-get update
-            sudo apt-get install -y --no-install-recommends tmux
-          fi
-          tmux -V
-
-      - name: Setup Bun
-        uses: oven-sh/setup-bun@v2
-        with:
-          bun-version: latest
-
-      - name: Cache Bun dependencies
-        uses: actions/cache@v4
-        with:
-          path: |
-            ~/.bun/install/cache
-            node_modules
-          key: ${{ runner.os }}-bun-${{ hashFiles('**/bun.lock') }}
-          restore-keys: |
-            ${{ runner.os }}-bun-
-
-      # Build local oh-my-opencode
-      - name: Build oh-my-opencode
-        run: |
-          bun install
-          bun run build
-
-      # Install OpenCode + configure local plugin + auth in single step
-      - name: Setup OpenCode with oh-my-opencode
-        env:
-          OPENCODE_AUTH_JSON: ${{ secrets.OPENCODE_AUTH_JSON }}
-          ANTHROPIC_BASE_URL: ${{ secrets.ANTHROPIC_BASE_URL }}
-          ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
-        run: |
-          export PATH="$HOME/.opencode/bin:$PATH"
-
-          # Install OpenCode (skip if cached)
-          if ! command -v opencode &>/dev/null; then
-            echo "Installing OpenCode..."
-            curl -fsSL https://opencode.ai/install -o /tmp/opencode-install.sh
-            
-            # Try default installer first, fallback to pinned version if it fails
-            if file /tmp/opencode-install.sh | grep -q "shell script\|text"; then
-              if ! bash /tmp/opencode-install.sh 2>&1; then
-                echo "Default installer failed, trying with pinned version..."
-                bash /tmp/opencode-install.sh --version 1.0.204
-              fi
-            else
-              echo "Download corrupted, trying direct install with pinned version..."
-              bash <(curl -fsSL https://opencode.ai/install) --version 1.0.204
-            fi
-          fi
-          opencode --version
-
-          # Run local oh-my-opencode install (uses built dist)
-          bun run dist/cli/index.js install --no-tui --claude=max20 --chatgpt=no --gemini=no
-
-          # Override plugin to use local file reference
-          OPENCODE_JSON=~/.config/opencode/opencode.json
-          REPO_PATH=$(pwd)
-          jq --arg path "file://$REPO_PATH/src/index.ts" '
-            .plugin = [.plugin[] | select(. != "oh-my-opencode")] + [$path]
-          ' "$OPENCODE_JSON" > /tmp/oc.json && mv /tmp/oc.json "$OPENCODE_JSON"
-
-          OPENCODE_JSON=~/.config/opencode/opencode.json
-          jq --arg baseURL "$ANTHROPIC_BASE_URL" --arg apiKey "$ANTHROPIC_API_KEY" '
-            .provider.anthropic = {
-              "name": "Anthropic",
-              "npm": "@ai-sdk/anthropic",
-              "options": {
-                "baseURL": $baseURL,
-                "apiKey": $apiKey
-              },
-              "models": {
-                "claude-opus-4-5": {
-                  "id": "claude-opus-4-5-20251101",
-                  "name": "Opus 4.5",
-                  "limit": { "context": 190000, "output": 64000 },
-                  "options": { "effort": "high" }
-                },
-                "claude-opus-4-5-high": {
-                  "id": "claude-opus-4-5-20251101",
-                  "name": "Opus 4.5 High",
-                  "limit": { "context": 190000, "output": 128000 },
-                  "options": { "effort": "high", "thinking": { "type": "enabled", "budgetTokens": 64000 } }
-                },
-                "claude-sonnet-4-5": {
-                  "id": "claude-sonnet-4-5-20250929",
-                  "name": "Sonnet 4.5",
-                  "limit": { "context": 200000, "output": 64000 }
-                },
-                "claude-sonnet-4-5-high": {
-                  "id": "claude-sonnet-4-5-20250929",
-                  "name": "Sonnet 4.5 High",
-                  "limit": { "context": 200000, "output": 128000 },
-                  "options": { "thinking": { "type": "enabled", "budgetTokens": 64000 } }
-                },
-                "claude-haiku-4-5": {
-                  "id": "claude-haiku-4-5-20251001",
-                  "name": "Haiku 4.5",
-                  "limit": { "context": 200000, "output": 64000 }
-                }
-              }
-            }
-          ' "$OPENCODE_JSON" > /tmp/oc.json && mv /tmp/oc.json "$OPENCODE_JSON"
-
-          OMO_JSON=~/.config/opencode/oh-my-opencode.json
-          PROMPT_APPEND=$(cat << 'PROMPT_EOF'
-
-          ## GitHub Actions Environment
-
-          You are `sisyphus-dev-ai` in GitHub Actions.
-
-          ### CRITICAL: GitHub Comments = Your ONLY Output
-
-          User CANNOT see console. Post everything via `gh issue comment` or `gh pr comment`.
-
-          ### Comment Formatting (CRITICAL)
-
-          **ALWAYS use heredoc syntax for comments containing code references, backticks, or multiline content:**
-
-          ```bash
-          gh issue comment <number> --body "$(cat <<'EOF'
-          Your comment with `backticks` and code references preserved here.
-          Multiple lines work perfectly.
-          EOF
-          )"
-          ```
-
-          **NEVER use direct quotes with backticks** (shell will interpret them as command substitution):
-          ```bash
-          # WRONG - backticks disappear:
-          gh issue comment 123 --body "text with `code`"
-          
-          # CORRECT - backticks preserved:
-          gh issue comment 123 --body "$(cat <<'EOF'
-          text with `code`
-          EOF
-          )"
-          ```
-
-          ### GitHub Markdown Rules (MUST FOLLOW)
-
-          **Code blocks MUST have EXACTLY 3 backticks and language identifier:**
-          - CORRECT: ` ```bash ` ... ` ``` `
-          - WRONG: ` ``` ` (no language), ` ```` ` (4 backticks), ` `` ` (2 backticks)
-          
-          **Every opening ` ``` ` MUST have a closing ` ``` ` on its own line:**
-          ```
-          ```bash
-          code here
-          ```
-          ```
-          
-          **NO trailing backticks or spaces after closing ` ``` `**
-          
-          **For inline code, use SINGLE backticks:** `code` not ```code```
-          
-          **Lists inside code blocks break rendering - avoid them or use plain text**
-
-          ### Rules
-          - EVERY response = GitHub comment (use heredoc for proper escaping)
-          - Code changes = PR (never push main/master)
-          - Setup: bun install first
-          - Acknowledge immediately, report when done
-
-          ### Git Config
-          - user.name: sisyphus-dev-ai
-          - user.email: sisyphus-dev-ai@users.noreply.github.com
-          PROMPT_EOF
-          )
-          jq --arg append "$PROMPT_APPEND" '.agents.Sisyphus.prompt_append = $append' "$OMO_JSON" > /tmp/omo.json && mv /tmp/omo.json "$OMO_JSON"
-
-          mkdir -p ~/.local/share/opencode
-          echo "$OPENCODE_AUTH_JSON" > ~/.local/share/opencode/auth.json
-          chmod 600 ~/.local/share/opencode/auth.json
-
-          cat "$OPENCODE_JSON"
-
-      # Collect context
-      - name: Collect Context
-        id: context
-        env:
-          GITHUB_TOKEN: ${{ secrets.GH_PAT }}
-          EVENT_NAME: ${{ github.event_name }}
-          ISSUE_NUMBER: ${{ github.event.issue.number }}
-          COMMENT_BODY: ${{ github.event.comment.body }}
-          COMMENT_AUTHOR: ${{ github.event.comment.user.login }}
-          COMMENT_ID_VAL: ${{ github.event.comment.id }}
-          REPO: ${{ github.repository }}
-        run: |
-          if [[ "$EVENT_NAME" == "issue_comment" ]]; then
-            ISSUE_NUM="$ISSUE_NUMBER"
-            AUTHOR="$COMMENT_AUTHOR"
-            COMMENT_ID="$COMMENT_ID_VAL"
-
-            # Check if PR or Issue
-            if gh api "repos/$REPO/issues/${ISSUE_NUM}" | jq -e '.pull_request' > /dev/null; then
-              echo "type=pr" >> $GITHUB_OUTPUT
-              echo "number=${ISSUE_NUM}" >> $GITHUB_OUTPUT
-            else
-              echo "type=issue" >> $GITHUB_OUTPUT
-              echo "number=${ISSUE_NUM}" >> $GITHUB_OUTPUT
-            fi
-          fi
-
-          echo "comment<<EOF" >> $GITHUB_OUTPUT
-          echo "$COMMENT_BODY" >> $GITHUB_OUTPUT
-          echo "EOF" >> $GITHUB_OUTPUT
-          echo "author=$AUTHOR" >> $GITHUB_OUTPUT
-          echo "comment_id=$COMMENT_ID" >> $GITHUB_OUTPUT
-
-      # Add :eyes: reaction (as sisyphus-dev-ai)
-      - name: Add eyes reaction
-        if: steps.context.outputs.comment_id != ''
-        env:
-          GITHUB_TOKEN: ${{ secrets.GH_PAT }}
-        run: |
-          gh api "/repos/${{ github.repository }}/issues/comments/${{ steps.context.outputs.comment_id }}/reactions" \
-            -X POST -f content="eyes" || true
-
-      - name: Add working label
-        if: steps.context.outputs.number != ''
-        env:
-          GITHUB_TOKEN: ${{ secrets.GH_PAT }}
-        run: |
-          gh label create "sisyphus: working" \
-            --repo "${{ github.repository }}" \
-            --color "fcf2e1" \
-            --description "Sisyphus is currently working on this" \
-            --force || true
-          
-          if [[ "${{ steps.context.outputs.type }}" == "pr" ]]; then
-            gh pr edit "${{ steps.context.outputs.number }}" \
-              --repo "${{ github.repository }}" \
-              --add-label "sisyphus: working" || true
-          else
-            gh issue edit "${{ steps.context.outputs.number }}" \
-              --repo "${{ github.repository }}" \
-              --add-label "sisyphus: working" || true
-          fi
-
-      - name: Run oh-my-opencode
-        env:
-          GITHUB_TOKEN: ${{ secrets.GH_PAT }}
-          USER_COMMENT: ${{ steps.context.outputs.comment }}
-          COMMENT_AUTHOR: ${{ steps.context.outputs.author }}
-          CONTEXT_TYPE: ${{ steps.context.outputs.type }}
-          CONTEXT_NUMBER: ${{ steps.context.outputs.number }}
-          REPO_NAME: ${{ github.repository }}
-          DEFAULT_BRANCH: ${{ github.event.repository.default_branch }}
-        run: |
-          export PATH="$HOME/.opencode/bin:$PATH"
-
-          PROMPT=$(cat <<'PROMPT_EOF'
-          Your username is @sisyphus-dev-ai, mentioned by @AUTHOR_PLACEHOLDER in REPO_PLACEHOLDER.
-
-          ## Context
-          - Type: TYPE_PLACEHOLDER
-          - Number: #NUMBER_PLACEHOLDER
-          - Repository: REPO_PLACEHOLDER
-          - Default Branch: BRANCH_PLACEHOLDER
-
-          ## User's Request
-          COMMENT_PLACEHOLDER
-
-          ---
-
-          Write everything using the todo tools.
-          Then investigate and satisfy the request. Only if user requested to you to work explicitely, then use plan agent to plan, todo obsessivley then create a PR to `BRANCH_PLACEHOLDER` branch.
-          When done, report the result to the issue/PR with `gh issue comment NUMBER_PLACEHOLDER` or `gh pr comment NUMBER_PLACEHOLDER`.
-          PROMPT_EOF
-          )
-
-          PROMPT="${PROMPT//AUTHOR_PLACEHOLDER/$COMMENT_AUTHOR}"
-          PROMPT="${PROMPT//REPO_PLACEHOLDER/$REPO_NAME}"
-          PROMPT="${PROMPT//TYPE_PLACEHOLDER/$CONTEXT_TYPE}"
-          PROMPT="${PROMPT//NUMBER_PLACEHOLDER/$CONTEXT_NUMBER}"
-          PROMPT="${PROMPT//BRANCH_PLACEHOLDER/$DEFAULT_BRANCH}"
-          PROMPT="${PROMPT//COMMENT_PLACEHOLDER/$USER_COMMENT}"
-
-          stdbuf -oL -eL bun run dist/cli/index.js run "$PROMPT"
-
-      # Push changes (as sisyphus-dev-ai)
-      - name: Push changes
-        if: always()
-        env:
-          GITHUB_TOKEN: ${{ secrets.GH_PAT }}
-        run: |
-          if [[ -n "$(git status --porcelain)" ]]; then
-            git add -A
-            git commit -m "chore: changes by sisyphus-dev-ai" || true
-          fi
-
-          BRANCH=$(git branch --show-current)
-          if [[ "$BRANCH" != "main" && "$BRANCH" != "master" ]]; then
-            git push origin "$BRANCH" || true
-          fi
-
-      - name: Update reaction and remove label
-        if: always()
-        env:
-          GITHUB_TOKEN: ${{ secrets.GH_PAT }}
-        run: |
-          if [[ -n "${{ steps.context.outputs.comment_id }}" ]]; then
-            REACTION_ID=$(gh api "/repos/${{ github.repository }}/issues/comments/${{ steps.context.outputs.comment_id }}/reactions" \
-              --jq '.[] | select(.content == "eyes" and .user.login == "sisyphus-dev-ai") | .id' | head -1)
-            if [[ -n "$REACTION_ID" ]]; then
-              gh api -X DELETE "/repos/${{ github.repository }}/reactions/${REACTION_ID}" || true
-            fi
-
-            gh api "/repos/${{ github.repository }}/issues/comments/${{ steps.context.outputs.comment_id }}/reactions" \
-              -X POST -f content="+1" || true
-          fi
-
-          if [[ -n "${{ steps.context.outputs.number }}" ]]; then
-            if [[ "${{ steps.context.outputs.type }}" == "pr" ]]; then
-              gh pr edit "${{ steps.context.outputs.number }}" \
-                --repo "${{ github.repository }}" \
-                --remove-label "sisyphus: working" || true
-            else
-              gh issue edit "${{ steps.context.outputs.number }}" \
-                --repo "${{ github.repository }}" \
-                --remove-label "sisyphus: working" || true
-            fi
-          fi

.gitignore

@@ -25,6 +25,3 @@ yarn.lock
 # Environment
 .env
 .env.local
-test-injection/
-notepad.md
-oauth-success.html

.opencode/background-tasks.json

@@ -1,27 +0,0 @@
-[
-  {
-    "id": "bg_wzsdt60b",
-    "sessionID": "ses_4f3e89f0dffeooeXNVx5QCifse",
-    "parentSessionID": "ses_4f3e8d141ffeyfJ1taVVOdQTzx",
-    "parentMessageID": "msg_b0c172ee1001w2B52VSZrP08PJ",
-    "description": "Explore opencode in codebase",
-    "agent": "explore",
-    "status": "completed",
-    "startedAt": "2025-12-11T06:26:57.395Z",
-    "completedAt": "2025-12-11T06:27:36.778Z"
-  },
-  {
-    "id": "bg_392b9c9b",
-    "sessionID": "ses_4f38ebf4fffeJZBocIn3UVv7vE",
-    "parentSessionID": "ses_4f38eefa0ffeKV0pVNnwT37P5L",
-    "parentMessageID": "msg_b0c7110d2001TMBlPeEYIrByvs",
-    "description": "Test explore agent",
-    "agent": "explore",
-    "status": "running",
-    "startedAt": "2025-12-11T08:05:07.378Z",
-    "progress": {
-      "toolCalls": 0,
-      "lastUpdate": "2025-12-11T08:05:07.378Z"
-    }
-  }
-]

.opencode/command/get-unpublished-changes.md

@@ -1,84 +0,0 @@
----
-description: Compare HEAD with the latest published npm version and list all unpublished changes
-model: anthropic/claude-haiku-4-5
----
-
-<command-instruction>
-IMMEDIATELY output the analysis. NO questions. NO preamble.
-
-## CRITICAL: DO NOT just copy commit messages!
-
-For each commit, you MUST:
-1. Read the actual diff to understand WHAT CHANGED
-2. Describe the REAL change in plain language
-3. Explain WHY it matters (if not obvious)
-
-## Steps:
-1. Run `git diff v{published-version}..HEAD` to see actual changes
-2. Group by type (feat/fix/refactor/docs) with REAL descriptions
-3. Note breaking changes if any
-4. Recommend version bump (major/minor/patch)
-
-## Output Format:
-- feat: "Added X that does Y" (not just "add X feature")
-- fix: "Fixed bug where X happened, now Y" (not just "fix X bug")
-- refactor: "Changed X from A to B, now supports C" (not just "rename X")
-</command-instruction>
-
-<version-context>
-<published-version>
-!`npm view oh-my-opencode version 2>/dev/null || echo "not published"`
-</published-version>
-<local-version>
-!`node -p "require('./package.json').version" 2>/dev/null || echo "unknown"`
-</local-version>
-<latest-tag>
-!`git tag --sort=-v:refname | head -1 2>/dev/null || echo "no tags"`
-</latest-tag>
-</version-context>
-
-<git-context>
-<commits-since-release>
-!`npm view oh-my-opencode version 2>/dev/null | xargs -I{} git log "v{}"..HEAD --oneline 2>/dev/null || echo "no commits since release"`
-</commits-since-release>
-<diff-stat>
-!`npm view oh-my-opencode version 2>/dev/null | xargs -I{} git diff "v{}"..HEAD --stat 2>/dev/null || echo "no diff available"`
-</diff-stat>
-<files-changed-summary>
-!`npm view oh-my-opencode version 2>/dev/null | xargs -I{} git diff "v{}"..HEAD --stat 2>/dev/null | tail -1 || echo ""`
-</files-changed-summary>
-</git-context>
-
-<output-format>
-## Unpublished Changes (v{published} → HEAD)
-
-### feat
-| Scope | What Changed |
-|-------|--------------|
-| X | 실제 변경 내용 설명 |
-
-### fix
-| Scope | What Changed |
-|-------|--------------|
-| X | 실제 변경 내용 설명 |
-
-### refactor
-| Scope | What Changed |
-|-------|--------------|
-| X | 실제 변경 내용 설명 |
-
-### docs
-| Scope | What Changed |
-|-------|--------------|
-| X | 실제 변경 내용 설명 |
-
-### Breaking Changes
-None 또는 목록
-
-### Files Changed
-{diff-stat}
-
-### Suggested Version Bump
-- **Recommendation**: patch|minor|major
-- **Reason**: 이유
-</output-format>

.opencode/command/omomomo.md

@@ -1,37 +0,0 @@
----
-description: Easter egg command - about oh-my-opencode
----
-
-<command-instruction>
-You found an easter egg! 🥚✨
-
-Print the following message to the user EXACTLY as written (in a friendly, celebratory tone):
-
----
-
-# 🎉 oMoMoMoMoMo···
-
-**You found the easter egg!** 🥚✨
-
-## What is Oh My OpenCode?
-
-**Oh My OpenCode** is a powerful OpenCode plugin that transforms your AI agent into a full development team:
-
-- 🤖 **Multi-Agent Orchestration**: Oracle (GPT-5.2), Librarian (Claude), Explore (Grok), Frontend Engineer (Gemini), and more
-- 🔧 **LSP Tools**: Full IDE capabilities for your agents - hover, goto definition, find references, rename, code actions
-- 🔍 **AST-Grep**: Structural code search and replace across 25 languages
-- 📚 **Built-in MCPs**: Context7 for docs, Exa for web search, grep.app for GitHub code search
-- 🔄 **Background Agents**: Run multiple agents in parallel like a real dev team
-- 🎯 **Claude Code Compatibility**: Your existing Claude Code config just works
-
-## Who Made This?
-
-Created with ❤️ by **[code-yeongyu](https://github.com/code-yeongyu)**
-
-🔗 **GitHub**: https://github.com/code-yeongyu/oh-my-opencode
-
----
-
-*Enjoy coding on steroids!* 🚀
-
-</command-instruction>

.opencode/command/publish.md

@@ -1,258 +0,0 @@
----
-description: Publish oh-my-opencode to npm via GitHub Actions workflow
-argument-hint: <patch|minor|major>
-model: opencode/big-pickle
----
-
-<command-instruction>
-You are the release manager for oh-my-opencode. Execute the FULL publish workflow from start to finish.
-
-## CRITICAL: ARGUMENT REQUIREMENT
-
-**You MUST receive a version bump type from the user.** Valid options:
-- `patch`: Bug fixes, backward-compatible (1.1.7 → 1.1.8)
-- `minor`: New features, backward-compatible (1.1.7 → 1.2.0)
-- `major`: Breaking changes (1.1.7 → 2.0.0)
-
-**If the user did not provide a bump type argument, STOP IMMEDIATELY and ask:**
-> "배포를 진행하려면 버전 범프 타입을 지정해주세요: `patch`, `minor`, 또는 `major`"
-
-**DO NOT PROCEED without explicit user confirmation of bump type.**
-
----
-
-## STEP 0: REGISTER TODO LIST (MANDATORY FIRST ACTION)
-
-**Before doing ANYTHING else**, create a detailed todo list using TodoWrite:
-
-```
-[
-  { "id": "confirm-bump", "content": "Confirm version bump type with user (patch/minor/major)", "status": "in_progress", "priority": "high" },
-  { "id": "check-uncommitted", "content": "Check for uncommitted changes and commit if needed", "status": "pending", "priority": "high" },
-  { "id": "sync-remote", "content": "Sync with remote (pull --rebase && push if unpushed commits)", "status": "pending", "priority": "high" },
-  { "id": "run-workflow", "content": "Trigger GitHub Actions publish workflow", "status": "pending", "priority": "high" },
-  { "id": "wait-workflow", "content": "Wait for workflow completion (poll every 30s)", "status": "pending", "priority": "high" },
-  { "id": "verify-release", "content": "Verify GitHub release was created", "status": "pending", "priority": "high" },
-  { "id": "draft-release-notes", "content": "Draft enhanced release notes content", "status": "pending", "priority": "high" },
-  { "id": "update-release-notes", "content": "Update GitHub release with enhanced notes", "status": "pending", "priority": "high" },
-  { "id": "verify-npm", "content": "Verify npm package published successfully", "status": "pending", "priority": "high" },
-  { "id": "final-confirmation", "content": "Final confirmation to user with links", "status": "pending", "priority": "low" }
-]
-```
-
-**Mark each todo as `in_progress` when starting, `completed` when done. ONE AT A TIME.**
-
----
-
-## STEP 1: CONFIRM BUMP TYPE
-
-If bump type provided as argument, confirm with user:
-> "버전 범프 타입: `{bump}`. 진행할까요? (y/n)"
-
-Wait for user confirmation before proceeding.
-
----
-
-## STEP 2: CHECK UNCOMMITTED CHANGES
-
-Run: `git status --porcelain`
-
-- If there are uncommitted changes, warn user and ask if they want to commit first
-- If clean, proceed
-
----
-
-## STEP 2.5: SYNC WITH REMOTE (MANDATORY)
-
-Check if there are unpushed commits:
-```bash
-git log origin/master..HEAD --oneline
-```
-
-**If there are unpushed commits, you MUST sync before triggering workflow:**
-```bash
-git pull --rebase && git push
-```
-
-This ensures the GitHub Actions workflow runs on the latest code including all local commits.
-
----
-
-## STEP 3: TRIGGER GITHUB ACTIONS WORKFLOW
-
-Run the publish workflow:
-```bash
-gh workflow run publish -f bump={bump_type}
-```
-
-Wait 3 seconds, then get the run ID:
-```bash
-gh run list --workflow=publish --limit=1 --json databaseId,status --jq '.[0]'
-```
-
----
-
-## STEP 4: WAIT FOR WORKFLOW COMPLETION
-
-Poll workflow status every 30 seconds until completion:
-```bash
-gh run view {run_id} --json status,conclusion --jq '{status: .status, conclusion: .conclusion}'
-```
-
-Status flow: `queued` → `in_progress` → `completed`
-
-**IMPORTANT: Use polling loop, NOT sleep commands.**
-
-If conclusion is `failure`, show error and stop:
-```bash
-gh run view {run_id} --log-failed
-```
-
----
-
-## STEP 5: VERIFY GITHUB RELEASE
-
-Get the new version and verify release exists:
-```bash
-# Get new version from package.json (workflow updates it)
-git pull --rebase
-NEW_VERSION=$(node -p "require('./package.json').version")
-gh release view "v${NEW_VERSION}"
-```
-
----
-
-## STEP 6: DRAFT ENHANCED RELEASE NOTES
-
-Analyze commits since the previous version and draft release notes following project conventions:
-
-### For PATCH releases:
-Keep simple format - just list commits:
-```markdown
-- {hash} {conventional commit message}
-- ...
-```
-
-### For MINOR releases:
-Use feature-focused format:
-```markdown
-## New Features
-
-### Feature Name
-- Description of what it does
-- Why it matters
-
-## Bug Fixes
-- fix(scope): description
-
-## Improvements
-- refactor(scope): description
-```
-
-### For MAJOR releases:
-Full changelog format:
-```markdown
-# v{version}
-
-Brief description of the release.
-
-## What's New Since v{previous}
-
-### Breaking Changes
-- Description of breaking change
-
-### Features
-- **Feature Name**: Description
-
-### Bug Fixes
-- Description
-
-### Documentation
-- Description
-
-## Migration Guide (if applicable)
-...
-```
-
-**CRITICAL: The enhanced notes must ADD to existing workflow-generated notes, not replace them.**
-
----
-
-## STEP 7: UPDATE GITHUB RELEASE
-
-**ZERO CONTENT LOSS POLICY:**
-- First, fetch the existing release body with `gh release view`
-- Your enhanced notes must be PREPENDED to the existing content
-- **NOT A SINGLE CHARACTER of existing content may be removed or modified**
-- The final release body = `{your_enhanced_notes}\n\n---\n\n{existing_body_exactly_as_is}`
-
-```bash
-# Get existing body
-EXISTING_BODY=$(gh release view "v${NEW_VERSION}" --json body --jq '.body')
-
-# Write enhanced notes to temp file (prepend to existing)
-cat > /tmp/release-notes-v${NEW_VERSION}.md << 'EOF'
-{your_enhanced_notes}
-
----
-
-EOF
-
-# Append existing body EXACTLY as-is (zero modifications)
-echo "$EXISTING_BODY" >> /tmp/release-notes-v${NEW_VERSION}.md
-
-# Update release
-gh release edit "v${NEW_VERSION}" --notes-file /tmp/release-notes-v${NEW_VERSION}.md
-```
-
-**CRITICAL: This is ADDITIVE ONLY. You are adding your notes on top. The existing content remains 100% intact.**
-
----
-
-## STEP 8: VERIFY NPM PUBLICATION
-
-Poll npm registry until the new version appears:
-```bash
-npm view oh-my-opencode version
-```
-
-Compare with expected version. If not matching after 2 minutes, warn user about npm propagation delay.
-
----
-
-## STEP 9: FINAL CONFIRMATION
-
-Report success to user with:
-- New version number
-- GitHub release URL: https://github.com/code-yeongyu/oh-my-opencode/releases/tag/v{version}
-- npm package URL: https://www.npmjs.com/package/oh-my-opencode
-
----
-
-## ERROR HANDLING
-
-- **Workflow fails**: Show failed logs, suggest checking Actions tab
-- **Release not found**: Wait and retry, may be propagation delay
-- **npm not updated**: npm can take 1-5 minutes to propagate, inform user
-- **Permission denied**: User may need to re-authenticate with `gh auth login`
-
-## LANGUAGE
-
-Respond to user in Korean (한국어).
-
-</command-instruction>
-
-<current-context>
-<published-version>
-!`npm view oh-my-opencode version 2>/dev/null || echo "not published"`
-</published-version>
-<local-version>
-!`node -p "require('./package.json').version" 2>/dev/null || echo "unknown"`
-</local-version>
-<git-status>
-!`git status --porcelain`
-</git-status>
-<recent-commits>
-!`npm view oh-my-opencode version 2>/dev/null | xargs -I{} git log "v{}"..HEAD --oneline 2>/dev/null | head -15 || echo "no commits"`
-</recent-commits>
-</current-context>

AGENTS.md

@@ -1,139 +1,114 @@
 # PROJECT KNOWLEDGE BASE
 
-**Generated:** 2025-12-31T14:05:00+09:00
-**Commit:** 502e9f5
-**Branch:** dev
+**Generated:** 2025-12-05T01:16:20+09:00
+**Commit:** 6c9a2ee
+**Branch:** master
 
 ## OVERVIEW
 
-OpenCode plugin implementing Claude Code/AmpCode features. Multi-model agent orchestration (GPT-5.2, Claude, Gemini, Grok), LSP tools (11), AST-Grep search, MCP integrations (context7, websearch_exa, grep_app). "oh-my-zsh" for OpenCode.
+OpenCode plugin distribution implementing Claude Code/AmpCode features. Provides multi-model agent orchestration, LSP tools, AST-Grep search, and safe-grep utilities.
 
 ## STRUCTURE
 
 ```
 oh-my-opencode/
 ├── src/
-│   ├── agents/        # AI agents (7): Sisyphus, oracle, librarian, explore, frontend, document-writer, multimodal-looker
-│   ├── hooks/         # 21 lifecycle hooks - see src/hooks/AGENTS.md
-│   ├── tools/         # LSP, AST-Grep, Grep, Glob, etc. - see src/tools/AGENTS.md
-│   ├── mcp/           # MCP servers: context7, websearch_exa, grep_app
-│   ├── features/      # Claude Code compatibility - see src/features/AGENTS.md
-│   ├── config/        # Zod schema, TypeScript types
-│   ├── auth/          # Google Antigravity OAuth (antigravity/)
-│   ├── shared/        # Utilities: deep-merge, pattern-matcher, logger, etc. - see src/shared/AGENTS.md
-│   ├── cli/           # CLI installer, doctor, run - see src/cli/AGENTS.md
-│   └── index.ts       # Main plugin entry (OhMyOpenCodePlugin)
-├── script/            # build-schema.ts, publish.ts, generate-changelog.ts
-├── assets/            # JSON schema
-└── dist/              # Build output (ESM + .d.ts)
+│   ├── agents/        # AI agent definitions (oracle, librarian, explore, etc.)
+│   ├── hooks/         # Plugin lifecycle hooks
+│   ├── tools/         # LSP, AST-Grep, Safe-Grep tool implementations
+│   │   ├── lsp/       # 11 LSP tools (hover, definition, references, etc.)
+│   │   ├── ast-grep/  # AST-aware code search
+│   │   └── safe-grep/ # Safe grep with limits
+│   └── features/      # Terminal features
+├── dist/              # Build output (bun + tsc declarations)
+└── test-rule.yml      # AST-Grep test rules
 ```
 
 ## WHERE TO LOOK
 
 | Task | Location | Notes |
 |------|----------|-------|
-| Add agent | `src/agents/` | Create .ts, add to builtinAgents in index.ts, update types.ts |
-| Add hook | `src/hooks/` | Create dir with createXXXHook(), export from index.ts |
-| Add tool | `src/tools/` | Dir with index/types/constants/tools.ts, add to builtinTools |
-| Add MCP | `src/mcp/` | Create config, add to index.ts and types.ts |
-| LSP behavior | `src/tools/lsp/` | client.ts (connection), tools.ts (handlers) |
-| AST-Grep | `src/tools/ast-grep/` | napi.ts for @ast-grep/napi binding |
-| Google OAuth | `src/auth/antigravity/` | OAuth plugin for Google models |
-| Config schema | `src/config/schema.ts` | Zod schema, run `bun run build:schema` after changes |
-| Claude Code compat | `src/features/claude-code-*-loader/` | Command, skill, agent, mcp loaders |
-| Background agents | `src/features/background-agent/` | manager.ts for task management |
-| Interactive terminal | `src/tools/interactive-bash/` | tmux session management |
-| CLI installer | `src/cli/install.ts` | Interactive TUI installation |
-| Doctor checks | `src/cli/doctor/checks/` | Health checks for environment |
-| Shared utilities | `src/shared/` | Cross-cutting utilities |
+| Add new agent | `src/agents/` | Export from index.ts |
+| Add new hook | `src/hooks/` | Export from index.ts |
+| Add new tool | `src/tools/` | Follow lsp/ pattern: index, types, tools, utils |
+| Modify LSP behavior | `src/tools/lsp/` | client.ts for connection logic |
+| AST-Grep patterns | `src/tools/ast-grep/` | napi.ts for @ast-grep/napi |
+| Terminal features | `src/features/terminal/` | title.ts |
 
 ## CONVENTIONS
 
-- **Package manager**: Bun only (`bun run`, `bun build`, `bunx`)
+- **Package manager**: Bun only (not npm/yarn)
+- **Build**: Dual output - `bun build` + `tsc --emitDeclarationOnly`
 - **Types**: bun-types (not @types/node)
-- **Build**: Dual output - `bun build` (ESM) + `tsc --emitDeclarationOnly`
 - **Exports**: Barrel pattern - `export * from "./module"` in index.ts
-- **Directory naming**: kebab-case (`ast-grep/`, `claude-code-hooks/`)
-- **Tool structure**: index.ts, types.ts, constants.ts, tools.ts, utils.ts
-- **Hook pattern**: `createXXXHook(input: PluginInput)` returning event handlers
-- **Test style**: BDD comments `#given`, `#when`, `#then` (same as AAA)
+- **Module structure**: index.ts, types.ts, constants.ts, utils.ts, tools.ts per tool
 
 ## ANTI-PATTERNS (THIS PROJECT)
 
+- **Bash file operations**: Never use mkdir/touch/rm/cp/mv for file creation
 - **npm/yarn**: Use bun exclusively
-- **@types/node**: Use bun-types
-- **Bash file ops**: Never mkdir/touch/rm/cp/mv for file creation in code
-- **Direct bun publish**: GitHub Actions workflow_dispatch only (OIDC provenance)
-- **Local version bump**: Version managed by CI workflow
-- **Year 2024**: NEVER use 2024 in code/prompts (use current year)
+- **@types/node**: Use bun-types instead
+- **Generic AI aesthetics**: No Space Grotesk, avoid typical AI-generated UI patterns
 - **Rush completion**: Never mark tasks complete without verification
-- **Over-exploration**: Stop searching when sufficient context found
-- **High temperature**: Don't use >0.3 for code-related agents
-- **Broad tool access**: Prefer explicit `include` over unrestricted access
+- **Interrupting work**: Complete tasks fully before stopping
 
 ## UNIQUE STYLES
 
-- **Platform**: Union type `"darwin" | "linux" | "win32" | "unsupported"`
-- **Optional props**: Extensive `?` for optional interface properties
-- **Flexible objects**: `Record<string, unknown>` for dynamic configs
+- **Directory naming**: kebab-case (`ast-grep/`, `safe-grep/`)
+- **Tool organization**: Each tool has cli.ts, constants.ts, index.ts, napi.ts/tools.ts, types.ts, utils.ts
+- **Platform handling**: Union type `"darwin" | "linux" | "win32" | "unsupported"`
 - **Error handling**: Consistent try/catch with async/await
-- **Agent tools**: `tools: { include: [...] }` or `tools: { exclude: [...] }`
-- **Temperature**: Most agents use `0.1` for consistency
-- **Hook naming**: `createXXXHook` function convention
+- **Optional props**: Extensive use of `?` for optional interface properties
+- **Flexible objects**: `Record<string, unknown>` for dynamic configs
 
 ## AGENT MODELS
 
 | Agent | Model | Purpose |
 |-------|-------|---------|
-| Sisyphus | anthropic/claude-opus-4-5 | Primary orchestrator |
-| oracle | openai/gpt-5.2 | Strategic advisor, code review |
-| librarian | anthropic/claude-sonnet-4-5 | Multi-repo analysis, docs |
-| explore | opencode/grok-code | Fast codebase exploration |
-| frontend-ui-ux-engineer | google/gemini-3-pro-preview | UI generation |
-| document-writer | google/gemini-3-pro-preview | Technical docs |
-| multimodal-looker | google/gemini-3-flash | PDF/image analysis |
+| oracle | GPT-5.1 | Code review, strategic planning |
+| librarian | Claude Haiku | Documentation, example lookup |
+| explore | Grok | File/codebase exploration |
+| frontend-ui-ux-engineer | Gemini | UI generation |
+| document-writer | Gemini | Documentation writing |
 
 ## COMMANDS
 
 ```bash
-bun run typecheck      # Type check
-bun run build          # ESM + declarations + schema
-bun run rebuild        # Clean + Build
-bun run build:schema   # Schema only
-bun test               # Run tests
+# Type check
+bun run typecheck
+
+# Build
+bun run build
+
+# Clean + Build
+bun run rebuild
 ```
 
 ## DEPLOYMENT
 
-**GitHub Actions workflow_dispatch only**
+**배포는 GitHub Actions workflow_dispatch로만 진행**
 
-1. Never modify package.json version locally
-2. Commit & push changes
-3. Trigger `publish` workflow: `gh workflow run publish -f bump=patch`
+1. package.json 버전은 수정하지 않음 (워크플로우에서 자동 bump)
+2. 변경사항 커밋 & 푸시
+3. GitHub Actions에서 `publish` 워크플로우 수동 실행
+   - `bump`: major | minor | patch 선택
+   - `version`: (선택) 특정 버전 지정 가능
 
-**Critical**: Never `bun publish` directly. Never bump version locally.
+```bash
+# 워크플로우 실행 (CLI)
+gh workflow run publish -f bump=patch
 
-## CI PIPELINE
+# 워크플로우 상태 확인
+gh run list --workflow=publish
+```
 
-- **ci.yml**: Parallel test/typecheck, build verification, auto-commit schema on master, rolling `next` draft release
-- **publish.yml**: Manual workflow_dispatch, version bump, changelog, OIDC npm publish
-- **sisyphus-agent.yml**: Agent-in-CI for automated issue handling via `@sisyphus-dev-ai` mentions
-
-## COMPLEXITY HOTSPOTS
-
-| File | Lines | Description |
-|------|-------|-------------|
-| `src/index.ts` | 690 | Main plugin orchestration, all hook/tool initialization |
-| `src/hooks/anthropic-context-window-limit-recovery/executor.ts` | 670 | Session compaction, multi-stage recovery pipeline |
-| `src/cli/config-manager.ts` | 669 | JSONC parsing, environment detection, installation |
-| `src/auth/antigravity/fetch.ts` | 621 | Token refresh, URL rewriting, endpoint fallbacks |
-| `src/tools/lsp/client.ts` | 611 | LSP protocol, stdin/stdout buffering, JSON-RPC |
+**주의사항**:
+- `bun publish` 직접 실행 금지 (OIDC provenance 문제)
+- 로컬에서 버전 bump 하지 말 것
 
 ## NOTES
 
-- **Testing**: Bun native test (`bun test`), BDD-style `#given/#when/#then`
-- **OpenCode**: Requires >= 1.0.150
-- **Multi-lang docs**: README.md (EN), README.ko.md (KO), README.ja.md (JA), README.zh-cn.md (ZH-CN)
-- **Config**: `~/.config/opencode/oh-my-opencode.json` (user) or `.opencode/oh-my-opencode.json` (project)
-- **Trusted deps**: @ast-grep/cli, @ast-grep/napi, @code-yeongyu/comment-checker
-- **JSONC support**: Config files support comments (`// comment`, `/* block */`) and trailing commas
+- **No tests**: Test framework not configured
+- **CI/CD**: GitHub Actions publish workflow 사용
+- **Version requirement**: OpenCode >= 1.0.132 (earlier versions have config bugs)
+- **Multi-language docs**: README.md, README.en.md, README.ko.md

CLA.md

@@ -1,58 +0,0 @@
-# Contributor License Agreement
-
-Thank you for your interest in contributing to oh-my-opencode ("Project"), owned by YeonGyu Kim ("Owner").
-
-By signing this Contributor License Agreement ("Agreement"), you agree to the following terms:
-
-## 1. Definitions
-
-- **"Contribution"** means any original work of authorship, including any modifications or additions to existing work, that you submit to the Project.
-- **"Submit"** means any form of communication sent to the Project, including but not limited to pull requests, issues, commits, and documentation changes.
-
-## 2. Grant of Rights
-
-By submitting a Contribution, you grant the Owner:
-
-1. **Copyright License**: A perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable copyright license to reproduce, prepare derivative works of, publicly display, publicly perform, sublicense, and distribute your Contributions and such derivative works.
-
-2. **Patent License**: A perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable patent license to make, have made, use, offer to sell, sell, import, and otherwise transfer the Contribution.
-
-3. **Relicensing Rights**: The right to relicense the Contribution under any license, including proprietary licenses, without requiring additional permission from you.
-
-## 3. Representations
-
-You represent that:
-
-1. You are legally entitled to grant the above licenses.
-2. Each Contribution is your original creation or you have sufficient rights to submit it.
-3. Your Contribution does not violate any third party's intellectual property rights.
-4. If your employer has rights to intellectual property that you create, you have received permission to make Contributions on behalf of that employer.
-
-## 4. No Obligation
-
-You understand that:
-
-1. The Owner is not obligated to use or include your Contribution.
-2. The decision to include any Contribution is at the sole discretion of the Owner.
-3. You are not entitled to any compensation for your Contributions.
-
-## 5. Future License Changes
-
-You acknowledge and agree that:
-
-1. The Project may change its license in the future.
-2. Your Contributions may be distributed under a different license than the one in effect at the time of your Contribution.
-3. This includes, but is not limited to, relicensing under source-available or proprietary licenses.
-
-## 6. Miscellaneous
-
-- This Agreement is governed by the laws of the Republic of Korea.
-- This Agreement represents the entire agreement between you and the Owner concerning Contributions.
-
----
-
-## How to Sign
-
-By submitting a pull request to this repository, you agree to the terms of this Contributor License Agreement. The CLA Assistant bot will automatically track your agreement.
-
-If you have any questions, please open an issue or contact the Owner.

CONTRIBUTING.md

@@ -1,245 +0,0 @@
-# Contributing to Oh My OpenCode
-
-First off, thanks for taking the time to contribute! This document provides guidelines and instructions for contributing to oh-my-opencode.
-
-## Table of Contents
-
-- [Code of Conduct](#code-of-conduct)
-- [Getting Started](#getting-started)
-  - [Prerequisites](#prerequisites)
-  - [Development Setup](#development-setup)
-  - [Testing Your Changes Locally](#testing-your-changes-locally)
-- [Project Structure](#project-structure)
-- [Development Workflow](#development-workflow)
-  - [Build Commands](#build-commands)
-  - [Code Style & Conventions](#code-style--conventions)
-- [Making Changes](#making-changes)
-  - [Adding a New Agent](#adding-a-new-agent)
-  - [Adding a New Hook](#adding-a-new-hook)
-  - [Adding a New Tool](#adding-a-new-tool)
-  - [Adding a New MCP Server](#adding-a-new-mcp-server)
-- [Pull Request Process](#pull-request-process)
-- [Publishing](#publishing)
-- [Getting Help](#getting-help)
-
-## Code of Conduct
-
-Be respectful, inclusive, and constructive. We're all here to make better tools together.
-
-## Getting Started
-
-### Prerequisites
-
-- **Bun** (latest version) - The only supported package manager
-- **TypeScript 5.7.3+** - For type checking and declarations
-- **OpenCode 1.0.150+** - For testing the plugin
-
-### Development Setup
-
-```bash
-# Clone the repository
-git clone https://github.com/code-yeongyu/oh-my-opencode.git
-cd oh-my-opencode
-
-# Install dependencies (bun only - never use npm/yarn)
-bun install
-
-# Build the project
-bun run build
-```
-
-### Testing Your Changes Locally
-
-After making changes, you can test your local build in OpenCode:
-
-1. **Build the project**:
-   ```bash
-   bun run build
-   ```
-
-2. **Update your OpenCode config** (`~/.config/opencode/opencode.json` or `opencode.jsonc`):
-   ```json
-   {
-     "plugin": [
-       "file:///absolute/path/to/oh-my-opencode/dist/index.js"
-     ]
-   }
-   ```
-   
-   For example, if your project is at `/Users/yourname/projects/oh-my-opencode`:
-   ```json
-   {
-     "plugin": [
-       "file:///Users/yourname/projects/oh-my-opencode/dist/index.js"
-     ]
-   }
-   ```
-
-   > **Note**: Remove `"oh-my-opencode"` from the plugin array if it exists, to avoid conflicts with the npm version.
-
-3. **Restart OpenCode** to load the changes.
-
-4. **Verify** the plugin is loaded by checking for OmO agent availability or startup messages.
-
-## Project Structure
-
-```
-oh-my-opencode/
-├── src/
-│   ├── agents/        # AI agents (OmO, oracle, librarian, explore, etc.)
-│   ├── hooks/         # 21 lifecycle hooks
-│   ├── tools/         # LSP (11), AST-Grep, Grep, Glob, etc.
-│   ├── mcp/           # MCP server integrations (context7, websearch_exa, grep_app)
-│   ├── features/      # Claude Code compatibility layers
-│   ├── config/        # Zod schemas and TypeScript types
-│   ├── auth/          # Google Antigravity OAuth
-│   ├── shared/        # Common utilities
-│   └── index.ts       # Main plugin entry (OhMyOpenCodePlugin)
-├── script/            # Build utilities (build-schema.ts, publish.ts)
-├── assets/            # JSON schema
-└── dist/              # Build output (ESM + .d.ts)
-```
-
-## Development Workflow
-
-### Build Commands
-
-```bash
-# Type check only
-bun run typecheck
-
-# Full build (ESM + TypeScript declarations + JSON schema)
-bun run build
-
-# Clean build output and rebuild
-bun run rebuild
-
-# Build schema only (after modifying src/config/schema.ts)
-bun run build:schema
-```
-
-### Code Style & Conventions
-
-| Convention | Rule |
-|------------|------|
-| Package Manager | **Bun only** (`bun run`, `bun build`, `bunx`) |
-| Types | Use `bun-types`, not `@types/node` |
-| Directory Naming | kebab-case (`ast-grep/`, `claude-code-hooks/`) |
-| File Operations | Never use bash commands (mkdir/touch/rm) for file creation in code |
-| Tool Structure | Each tool: `index.ts`, `types.ts`, `constants.ts`, `tools.ts`, `utils.ts` |
-| Hook Pattern | `createXXXHook(input: PluginInput)` function naming |
-| Exports | Barrel pattern (`export * from "./module"` in index.ts) |
-
-**Anti-Patterns (Do Not Do)**:
-- Using npm/yarn instead of bun
-- Using `@types/node` instead of `bun-types`
-- Suppressing TypeScript errors with `as any`, `@ts-ignore`, `@ts-expect-error`
-- Generic AI-generated comment bloat
-- Direct `bun publish` (use GitHub Actions only)
-- Local version modifications in `package.json`
-
-## Making Changes
-
-### Adding a New Agent
-
-1. Create a new `.ts` file in `src/agents/`
-2. Define the agent configuration following existing patterns
-3. Add to `builtinAgents` in `src/agents/index.ts`
-4. Update `src/agents/types.ts` if needed
-5. Run `bun run build:schema` to update the JSON schema
-
-```typescript
-// src/agents/my-agent.ts
-import type { AgentConfig } from "./types";
-
-export const myAgent: AgentConfig = {
-  name: "my-agent",
-  model: "anthropic/claude-sonnet-4-5",
-  description: "Description of what this agent does",
-  prompt: `Your agent's system prompt here`,
-  temperature: 0.1,
-  // ... other config
-};
-```
-
-### Adding a New Hook
-
-1. Create a new directory in `src/hooks/` (kebab-case)
-2. Implement `createXXXHook()` function returning event handlers
-3. Export from `src/hooks/index.ts`
-
-```typescript
-// src/hooks/my-hook/index.ts
-import type { PluginInput } from "@opencode-ai/plugin";
-
-export function createMyHook(input: PluginInput) {
-  return {
-    onSessionStart: async () => {
-      // Hook logic here
-    },
-  };
-}
-```
-
-### Adding a New Tool
-
-1. Create a new directory in `src/tools/` with required files:
-   - `index.ts` - Main exports
-   - `types.ts` - TypeScript interfaces
-   - `constants.ts` - Constants and tool descriptions
-   - `tools.ts` - Tool implementations
-   - `utils.ts` - Helper functions
-2. Add to `builtinTools` in `src/tools/index.ts`
-
-### Adding a New MCP Server
-
-1. Create configuration in `src/mcp/`
-2. Add to `src/mcp/index.ts`
-3. Document in README if it requires external setup
-
-## Pull Request Process
-
-1. **Fork** the repository and create your branch from `master`
-2. **Make changes** following the conventions above
-3. **Build and test** locally:
-   ```bash
-   bun run typecheck  # Ensure no type errors
-   bun run build      # Ensure build succeeds
-   ```
-4. **Test in OpenCode** using the local build method described above
-5. **Commit** with clear, descriptive messages:
-   - Use present tense ("Add feature" not "Added feature")
-   - Reference issues if applicable ("Fix #123")
-6. **Push** to your fork and create a Pull Request
-7. **Describe** your changes clearly in the PR description
-
-### PR Checklist
-
-- [ ] Code follows project conventions
-- [ ] `bun run typecheck` passes
-- [ ] `bun run build` succeeds
-- [ ] Tested locally with OpenCode
-- [ ] Updated documentation if needed (README, AGENTS.md)
-- [ ] No version changes in `package.json`
-
-## Publishing
-
-**Important**: Publishing is handled exclusively through GitHub Actions.
-
-- **Never** run `bun publish` directly (OIDC provenance issues)
-- **Never** modify `package.json` version locally
-- Maintainers use GitHub Actions workflow_dispatch:
-  ```bash
-  gh workflow run publish -f bump=patch  # or minor/major
-  ```
-
-## Getting Help
-
-- **Project Knowledge**: Check `AGENTS.md` for detailed project documentation
-- **Code Patterns**: Review existing implementations in `src/`
-- **Issues**: Open an issue for bugs or feature requests
-- **Discussions**: Start a discussion for questions or ideas
-
----
-
-Thank you for contributing to Oh My OpenCode! Your efforts help make AI-assisted coding better for everyone.

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 YeonGyu Kim
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

LICENSE.md

@@ -1,82 +0,0 @@
-# License
-
-Portions of this software are licensed as follows:
-
-- All third party components incorporated into the oh-my-opencode Software are licensed under the original license
-  provided by the owner of the applicable component.
-- Content outside of the above mentioned files or restrictions is available under the "Sustainable Use
-  License" as defined below.
-
-## Sustainable Use License
-
-Version 1.0
-
-### Acceptance
-
-By using the software, you agree to all of the terms and conditions below.
-
-### Copyright License
-
-The licensor grants you a non-exclusive, royalty-free, worldwide, non-sublicensable, non-transferable license
-to use, copy, distribute, make available, and prepare derivative works of the software, in each case subject
-to the limitations below.
-
-### Limitations
-
-You may use or modify the software only for your own internal business purposes or for non-commercial or
-personal use. You may distribute the software or provide it to others only if you do so free of charge for
-non-commercial purposes. You may not alter, remove, or obscure any licensing, copyright, or other notices of
-the licensor in the software. Any use of the licensor's trademarks is subject to applicable law.
-
-### Patents
-
-The licensor grants you a license, under any patent claims the licensor can license, or becomes able to
-license, to make, have made, use, sell, offer for sale, import and have imported the software, in each case
-subject to the limitations and conditions in this license. This license does not cover any patent claims that
-you cause to be infringed by modifications or additions to the software. If you or your company make any
-written claim that the software infringes or contributes to infringement of any patent, your patent license
-for the software granted under these terms ends immediately. If your company makes such a claim, your patent
-license ends immediately for work on behalf of your company.
-
-### Notices
-
-You must ensure that anyone who gets a copy of any part of the software from you also gets a copy of these
-terms. If you modify the software, you must include in any modified copies of the software a prominent notice
-stating that you have modified the software.
-
-### No Other Rights
-
-These terms do not imply any licenses other than those expressly granted in these terms.
-
-### Termination
-
-If you use the software in violation of these terms, such use is not licensed, and your license will
-automatically terminate. If the licensor provides you with a notice of your violation, and you cease all
-violation of this license no later than 30 days after you receive that notice, your license will be reinstated
-retroactively. However, if you violate these terms after such reinstatement, any additional violation of these
-terms will cause your license to terminate automatically and permanently.
-
-### No Liability
-
-As far as the law allows, the software comes as is, without any warranty or condition, and the licensor will
-not be liable to you for any damages arising out of these terms or the use or nature of the software, under
-any kind of legal claim.
-
-### Definitions
-
-The "licensor" is the entity offering these terms.
-
-The "software" is the software the licensor makes available under these terms, including any portion of it.
-
-"You" refers to the individual or entity agreeing to these terms.
-
-"Your company" is any legal entity, sole proprietorship, or other kind of organization that you work for, plus
-all organizations that have control over, are under the control of, or are under common control with that
-organization. Control means ownership of substantially all the assets of an entity, or the power to direct its
-management and policies by vote, contract, or otherwise. Control can be direct or indirect.
-
-"Your license" is the license granted to you for the software under these terms.
-
-"Use" means anything you do with the software requiring your license.
-
-"Trademark" means trademarks, service marks, and similar rights.

bun.lock

@@ -7,24 +7,19 @@
       "dependencies": {
         "@ast-grep/cli": "^0.40.0",
         "@ast-grep/napi": "^0.40.0",
-        "@clack/prompts": "^0.11.0",
-        "@code-yeongyu/comment-checker": "^0.6.1",
-        "@openauthjs/openauth": "^0.4.3",
-        "@opencode-ai/plugin": "^1.0.162",
-        "@opencode-ai/sdk": "^1.0.162",
-        "commander": "^14.0.2",
-        "hono": "^4.10.4",
-        "jsonc-parser": "^3.3.1",
-        "picocolors": "^1.1.1",
-        "picomatch": "^4.0.2",
+        "@code-yeongyu/comment-checker": "^0.4.4",
+        "@opencode-ai/plugin": "^1.0.7",
         "xdg-basedir": "^5.1.0",
         "zod": "^4.1.8",
       },
       "devDependencies": {
-        "@types/picomatch": "^3.0.2",
         "bun-types": "latest",
+        "oh-my-opencode": "^0.1.30",
         "typescript": "^5.7.3",
       },
+      "peerDependencies": {
+        "bun": ">=1.0.0",
+      },
     },
   },
   "trustedDependencies": [
@@ -69,55 +64,43 @@
 
     "@ast-grep/napi-win32-x64-msvc": ["@ast-grep/napi-win32-x64-msvc@0.40.0", "", { "os": "win32", "cpu": "x64" }, "sha512-Hk2IwfPqMFGZt5SRxsoWmGLxBXxprow4LRp1eG6V8EEiJCNHxZ9ZiEaIc5bNvMDBjHVSnqZAXT22dROhrcSKQg=="],
 
-    "@clack/core": ["@clack/core@0.5.0", "", { "dependencies": { "picocolors": "^1.0.0", "sisteransi": "^1.0.5" } }, "sha512-p3y0FIOwaYRUPRcMO7+dlmLh8PSRcrjuTndsiA0WAFbWES0mLZlrjVoBRZ9DzkPFJZG6KGkJmoEAY0ZcVWTkow=="],
+    "@code-yeongyu/comment-checker": ["@code-yeongyu/comment-checker@0.4.4", "", { "os": [ "linux", "win32", "darwin", ], "cpu": [ "x64", "arm64", ], "bin": { "comment-checker": "bin/comment-checker" } }, "sha512-vsbdLMQYJJNDV/baTDnNqqg/MZwA+9nz7TE6Mybj8zjZVTCn4ZivH4hAdD5p4fLxhGZEJ5x1UDmXA6pAGA7lHA=="],
 
-    "@clack/prompts": ["@clack/prompts@0.11.0", "", { "dependencies": { "@clack/core": "0.5.0", "picocolors": "^1.0.0", "sisteransi": "^1.0.5" } }, "sha512-pMN5FcrEw9hUkZA4f+zLlzivQSeQf5dRGJjSUbvVYDLvpKCdQx5OaknvKzgbtXOizhP+SJJJjqEbOe55uKKfAw=="],
+    "@opencode-ai/plugin": ["@opencode-ai/plugin@1.0.128", "", { "dependencies": { "@opencode-ai/sdk": "1.0.128", "zod": "4.1.8" } }, "sha512-M5vjz3I6KeoBSNduWmT5iHXRtTLCqICM5ocs+WrB3uxVorslcO3HVwcLzrERh/ntpxJ/1xhnHQaeG6Mg+P744A=="],
 
-    "@code-yeongyu/comment-checker": ["@code-yeongyu/comment-checker@0.6.1", "", { "os": [ "linux", "win32", "darwin", ], "cpu": [ "x64", "arm64", ], "bin": { "comment-checker": "bin/comment-checker" } }, "sha512-BBremX+Y5aW8sTzlhHrLsKParupYkPOVUYmq9STrlWvBvfAme6w5IWuZCLl6nHIQScRDdvGdrAjPycJC86EZFA=="],
+    "@opencode-ai/sdk": ["@opencode-ai/sdk@1.0.128", "", {}, "sha512-Kow3Ivg8bR8dNRp8C0LwF9e8+woIrwFgw3ZALycwCfqS/UujDkJiBeYHdr1l/07GSHP9sZPmvJ6POuvfZ923EA=="],
 
-    "@openauthjs/openauth": ["@openauthjs/openauth@0.4.3", "", { "dependencies": { "@standard-schema/spec": "1.0.0-beta.3", "aws4fetch": "1.0.20", "jose": "5.9.6" }, "peerDependencies": { "arctic": "^2.2.2", "hono": "^4.0.0" } }, "sha512-RlnjqvHzqcbFVymEwhlUEuac4utA5h4nhSK/i2szZuQmxTIqbGUxZ+nM+avM+VV4Ing+/ZaNLKILoXS3yrkOOw=="],
+    "@oven/bun-darwin-aarch64": ["@oven/bun-darwin-aarch64@1.3.3", "", { "os": "darwin", "cpu": "arm64" }, "sha512-eJopQrUk0WR7jViYDC29+Rp50xGvs4GtWOXBeqCoFMzutkkO3CZvHehA4JqnjfWMTSS8toqvRhCSOpOz62Wf9w=="],
 
-    "@opencode-ai/plugin": ["@opencode-ai/plugin@1.0.162", "", { "dependencies": { "@opencode-ai/sdk": "1.0.162", "zod": "4.1.8" } }, "sha512-tiJw7SCfSlG/3tY2O0J2UT06OLuazOzsv1zYlFbLxLy/EVedtW0pzxYalO20a4e//vInvOXFkhd2jLyB5vNEVA=="],
+    "@oven/bun-darwin-x64": ["@oven/bun-darwin-x64@1.3.3", "", { "os": "darwin", "cpu": "x64" }, "sha512-xGDePueVFrNgkS+iN0QdEFeRrx2MQ5hQ9ipRFu7N73rgoSSJsFlOKKt2uGZzunczedViIfjYl0ii0K4E9aZ0Ow=="],
 
-    "@opencode-ai/sdk": ["@opencode-ai/sdk@1.0.162", "", {}, "sha512-+XqRErBUt9eb1m3i/7WkZc/QCKCCjTaGV3MvhLhs/CUwbUn767D/ugzcG/i2ec8j/4nQmjJbjPDRmrQfvF1Qjw=="],
+    "@oven/bun-darwin-x64-baseline": ["@oven/bun-darwin-x64-baseline@1.3.3", "", { "os": "darwin", "cpu": "x64" }, "sha512-1ij4wQ9ECLFf1XFry+IFUN+28if40ozDqq6+QtuyOhIwraKzXOlAUbILhRMGvM3ED3yBex2mTwlKpA4Vja/V2g=="],
 
-    "@oslojs/asn1": ["@oslojs/asn1@1.0.0", "", { "dependencies": { "@oslojs/binary": "1.0.0" } }, "sha512-zw/wn0sj0j0QKbIXfIlnEcTviaCzYOY3V5rAyjR6YtOByFtJiT574+8p9Wlach0lZH9fddD4yb9laEAIl4vXQA=="],
+    "@oven/bun-linux-aarch64": ["@oven/bun-linux-aarch64@1.3.3", "", { "os": "linux", "cpu": "arm64" }, "sha512-DabZ3Mt1XcJneWdEEug8l7bCPVvDBRBpjUIpNnRnMFWFnzr8KBEpMcaWTwYOghjXyJdhB4MPKb19MwqyQ+FHAw=="],
 
-    "@oslojs/binary": ["@oslojs/binary@1.0.0", "", {}, "sha512-9RCU6OwXU6p67H4NODbuxv2S3eenuQ4/WFLrsq+K/k682xrznH5EVWA7N4VFk9VYVcbFtKqur5YQQZc0ySGhsQ=="],
+    "@oven/bun-linux-aarch64-musl": ["@oven/bun-linux-aarch64-musl@1.3.3", "", { "os": "linux", "cpu": "arm64" }, "sha512-XWQ3tV/gtZj0wn2AdSUq/tEOKWT4OY+Uww70EbODgrrq00jxuTfq5nnYP6rkLD0M/T5BHJdQRSfQYdIni9vldw=="],
 
-    "@oslojs/crypto": ["@oslojs/crypto@1.0.1", "", { "dependencies": { "@oslojs/asn1": "1.0.0", "@oslojs/binary": "1.0.0" } }, "sha512-7n08G8nWjAr/Yu3vu9zzrd0L9XnrJfpMioQcvCMxBIiF5orECHe5/3J0jmXRVvgfqMm/+4oxlQ+Sq39COYLcNQ=="],
+    "@oven/bun-linux-x64": ["@oven/bun-linux-x64@1.3.3", "", { "os": "linux", "cpu": "x64" }, "sha512-7eIARtKZKZDtah1aCpQUj/1/zT/zHRR063J6oAxZP9AuA547j5B9OM2D/vi/F4En7Gjk9FPjgPGTSYeqpQDzJw=="],
 
-    "@oslojs/encoding": ["@oslojs/encoding@1.1.0", "", {}, "sha512-70wQhgYmndg4GCPxPPxPGevRKqTIJ2Nh4OkiMWmDAVYsTQ+Ta7Sq+rPevXyXGdzr30/qZBnyOalCszoMxlyldQ=="],
+    "@oven/bun-linux-x64-baseline": ["@oven/bun-linux-x64-baseline@1.3.3", "", { "os": "linux", "cpu": "x64" }, "sha512-IU8pxhIf845psOv55LqJyL+tSUc6HHMfs6FGhuJcAnyi92j+B1HjOhnFQh9MW4vjoo7do5F8AerXlvk59RGH2w=="],
 
-    "@oslojs/jwt": ["@oslojs/jwt@0.2.0", "", { "dependencies": { "@oslojs/encoding": "0.4.1" } }, "sha512-bLE7BtHrURedCn4Mco3ma9L4Y1GR2SMBuIvjWr7rmQ4/W/4Jy70TIAgZ+0nIlk0xHz1vNP8x8DCns45Sb2XRbg=="],
+    "@oven/bun-linux-x64-musl": ["@oven/bun-linux-x64-musl@1.3.3", "", { "os": "linux", "cpu": "x64" }, "sha512-xNSDRPn1yyObKteS8fyQogwsS4eCECswHHgaKM+/d4wy/omZQrXn8ZyGm/ZF9B73UfQytUfbhE7nEnrFq03f0w=="],
 
-    "@standard-schema/spec": ["@standard-schema/spec@1.0.0-beta.3", "", {}, "sha512-0ifF3BjA1E8SY9C+nUew8RefNOIq0cDlYALPty4rhUm8Rrl6tCM8hBT4bhGhx7I7iXD0uAgt50lgo8dD73ACMw=="],
+    "@oven/bun-linux-x64-musl-baseline": ["@oven/bun-linux-x64-musl-baseline@1.3.3", "", { "os": "linux", "cpu": "x64" }, "sha512-JoRTPdAXRkNYouUlJqEncMWUKn/3DiWP03A7weBbtbsKr787gcdNna2YeyQKCb1lIXE4v1k18RM3gaOpQobGIQ=="],
+
+    "@oven/bun-windows-x64": ["@oven/bun-windows-x64@1.3.3", "", { "os": "win32", "cpu": "x64" }, "sha512-kWqa1LKvDdAIzyfHxo3zGz3HFWbFHDlrNK77hKjUN42ycikvZJ+SHSX76+1OW4G8wmLETX4Jj+4BM1y01DQRIQ=="],
+
+    "@oven/bun-windows-x64-baseline": ["@oven/bun-windows-x64-baseline@1.3.3", "", { "os": "win32", "cpu": "x64" }, "sha512-u5eZHKq6TPJSE282KyBOicGQ2trkFml0RoUfqkPOJVo7TXGrsGYYzdsugZRnVQY/WEmnxGtBy4T3PAaPqgQViA=="],
 
     "@types/node": ["@types/node@24.10.1", "", { "dependencies": { "undici-types": "~7.16.0" } }, "sha512-GNWcUTRBgIRJD5zj+Tq0fKOJ5XZajIiBroOF0yvj2bSU1WvNdYS/dn9UxwsujGW4JX06dnHyjV2y9rRaybH0iQ=="],
 
-    "@types/picomatch": ["@types/picomatch@3.0.2", "", {}, "sha512-n0i8TD3UDB7paoMMxA3Y65vUncFJXjcUf7lQY7YyKGl6031FNjfsLs6pdLFCy2GNFxItPJG8GvvpbZc2skH7WA=="],
-
-    "arctic": ["arctic@2.3.4", "", { "dependencies": { "@oslojs/crypto": "1.0.1", "@oslojs/encoding": "1.1.0", "@oslojs/jwt": "0.2.0" } }, "sha512-+p30BOWsctZp+CVYCt7oAean/hWGW42sH5LAcRQX56ttEkFJWbzXBhmSpibbzwSJkRrotmsA+oAoJoVsU0f5xA=="],
-
-    "aws4fetch": ["aws4fetch@1.0.20", "", {}, "sha512-/djoAN709iY65ETD6LKCtyyEI04XIBP5xVvfmNxsEP0uJB5tyaGBztSryRr4HqMStr9R06PisQE7m9zDTXKu6g=="],
+    "bun": ["bun@1.3.3", "", { "optionalDependencies": { "@oven/bun-darwin-aarch64": "1.3.3", "@oven/bun-darwin-x64": "1.3.3", "@oven/bun-darwin-x64-baseline": "1.3.3", "@oven/bun-linux-aarch64": "1.3.3", "@oven/bun-linux-aarch64-musl": "1.3.3", "@oven/bun-linux-x64": "1.3.3", "@oven/bun-linux-x64-baseline": "1.3.3", "@oven/bun-linux-x64-musl": "1.3.3", "@oven/bun-linux-x64-musl-baseline": "1.3.3", "@oven/bun-windows-x64": "1.3.3", "@oven/bun-windows-x64-baseline": "1.3.3" }, "os": [ "linux", "win32", "darwin", ], "cpu": [ "x64", "arm64", ], "bin": { "bun": "bin/bun.exe", "bunx": "bin/bunx.exe" } }, "sha512-2hJ4ocTZ634/Ptph4lysvO+LbbRZq8fzRvMwX0/CqaLBxrF2UB5D1LdMB8qGcdtCer4/VR9Bx5ORub0yn+yzmw=="],
 
     "bun-types": ["bun-types@1.3.3", "", { "dependencies": { "@types/node": "*" } }, "sha512-z3Xwlg7j2l9JY27x5Qn3Wlyos8YAp0kKRlrePAOjgjMGS5IG6E7Jnlx736vH9UVI4wUICwwhC9anYL++XeOgTQ=="],
 
-    "commander": ["commander@14.0.2", "", {}, "sha512-TywoWNNRbhoD0BXs1P3ZEScW8W5iKrnbithIl0YH+uCmBd0QpPOA8yc82DS3BIE5Ma6FnBVUsJ7wVUDz4dvOWQ=="],
-
     "detect-libc": ["detect-libc@2.1.2", "", {}, "sha512-Btj2BOOO83o3WyH59e8MgXsxEQVcarkUOpEYrubB0urwnN10yQ364rsiByU11nZlqWYZm05i/of7io4mzihBtQ=="],
 
-    "hono": ["hono@4.10.8", "", {}, "sha512-DDT0A0r6wzhe8zCGoYOmMeuGu3dyTAE40HHjwUsWFTEy5WxK1x2WDSsBPlEXgPbRIFY6miDualuUDbasPogIww=="],
-
-    "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=="],
-
-    "sisteransi": ["sisteransi@1.0.5", "", {}, "sha512-bLGGlR1QxBcynn2d5YmDX4MGjlZvy2MRBDRNHLJ8VI6l6+9FUiyTFNJ0IveOSP0bcXgVDPRcfGqA0pjaqUpfVg=="],
+    "oh-my-opencode": ["oh-my-opencode@0.1.30", "", { "dependencies": { "@ast-grep/cli": "^0.40.0", "@ast-grep/napi": "^0.40.0", "@code-yeongyu/comment-checker": "^0.4.1", "@opencode-ai/plugin": "^1.0.7", "xdg-basedir": "^5.1.0", "zod": "^4.1.8" }, "peerDependencies": { "bun": ">=1.0.0" } }, "sha512-pXGGgL/7Jcz3yuGJJTI72BKern2egwfRz2LQZTBq+jl+pNCybOvGvXtFmR+WGlF8O3ZjL1wIHypBbIVuHOBzxg=="],
 
     "typescript": ["typescript@5.9.3", "", { "bin": { "tsc": "bin/tsc", "tsserver": "bin/tsserver" } }, "sha512-jl1vZzPDinLr9eUt3J/t7V6FgNEw9QjvBPdysz9KfQDD41fQrC2Y4vKQdiaUpFT4bXlb1RHhLpp8wtm6M5TgSw=="],
 
@@ -127,6 +110,6 @@
 
     "zod": ["zod@4.1.8", "", {}, "sha512-5R1P+WwQqmmMIEACyzSvo4JXHY5WiAFHRMg+zBZKgKS+Q1viRa0C1hmUKtHltoIFKtIdki3pRxkmpP74jnNYHQ=="],
 
-    "@oslojs/jwt/@oslojs/encoding": ["@oslojs/encoding@0.4.1", "", {}, "sha512-hkjo6MuIK/kQR5CrGNdAPZhS01ZCXuWDRJ187zh6qqF2+yMHZpD9fAYpX8q2bOO6Ryhl3XpCT6kUX76N8hhm4Q=="],
+    "oh-my-opencode/@code-yeongyu/comment-checker": ["@code-yeongyu/comment-checker@0.4.1", "", { "os": [ "linux", "win32", "darwin", ], "cpu": [ "x64", "arm64", ], "bin": { "comment-checker": "bin/comment-checker" } }, "sha512-E7p1V8CsRj9hMbwENd9BfxZGWYu+lKS5tXGuNNcNtkRMhWvwM/ononysKpLB7LXdxfSYAn0j7heJydyzEmm+lg=="],
   }
 }

local-ignore/comment-checker-ts-plan.md

@@ -0,0 +1,162 @@
+# Comment-Checker TypeScript Port 구현 계획
+
+## 1. 아키텍처 개요
+
+### 1.1 핵심 도전 과제
+
+**OpenCode Hook의 제약사항:**
+- `tool.execute.before`: `output.args`에서 파일 경로/내용 접근 가능
+- `tool.execute.after`: `tool_input`이 **제공되지 않음** (Claude Code와의 핵심 차이점)
+- **해결책**: Before hook에서 데이터를 캡처하여 callID로 키잉된 Map에 저장, After hook에서 조회
+
+### 1.2 디렉토리 구조
+
+```
+src/hooks/comment-checker/
+├── index.ts              # Hook factory, 메인 엔트리포인트
+├── types.ts              # 모든 타입 정의
+├── constants.ts          # 언어 레지스트리, 쿼리 템플릿, 디렉티브 목록
+├── detector.ts           # CommentDetector - web-tree-sitter 기반 코멘트 감지
+├── filters/
+│   ├── index.ts          # 필터 barrel export
+│   ├── bdd.ts            # BDD 패턴 필터
+│   ├── directive.ts      # 린터/타입체커 디렉티브 필터
+│   ├── docstring.ts      # 독스트링 필터
+│   └── shebang.ts        # Shebang 필터
+├── output/
+│   ├── index.ts          # 출력 barrel export
+│   ├── formatter.ts      # FormatHookMessage
+│   └── xml-builder.ts    # BuildCommentsXML
+└── utils.ts              # 유틸리티 함수
+```
+
+### 1.3 데이터 흐름
+
+```
+[write/edit 도구 실행]
+       │
+       ▼
+┌──────────────────────┐
+│ tool.execute.before  │
+│  - 파일 경로 캡처    │
+│  - pendingCalls Map  │
+│    에 저장           │
+└──────────┬───────────┘
+           │
+           ▼
+    [도구 실제 실행]
+           │
+           ▼
+┌──────────────────────┐
+│ tool.execute.after   │
+│  - pendingCalls에서  │
+│    데이터 조회       │
+│  - 파일 읽기         │
+│  - 코멘트 감지       │
+│  - 필터 적용         │
+│  - 메시지 주입       │
+└──────────────────────┘
+```
+
+---
+
+## 2. 구현 순서
+
+### Phase 1: 기반 구조
+1. `src/hooks/comment-checker/` 디렉토리 생성
+2. `types.ts` - 모든 타입 정의
+3. `constants.ts` - 언어 레지스트리, 디렉티브 패턴
+
+### Phase 2: 필터 구현
+4. `filters/bdd.ts` - BDD 패턴 필터
+5. `filters/directive.ts` - 디렉티브 필터
+6. `filters/docstring.ts` - 독스트링 필터
+7. `filters/shebang.ts` - Shebang 필터
+8. `filters/index.ts` - 필터 조합
+
+### Phase 3: 코어 로직
+9. `detector.ts` - web-tree-sitter 기반 코멘트 감지
+10. `output/xml-builder.ts` - XML 출력
+11. `output/formatter.ts` - 메시지 포매팅
+
+### Phase 4: Hook 통합
+12. `index.ts` - Hook factory 및 상태 관리
+13. `src/hooks/index.ts` 업데이트 - export 추가
+
+### Phase 5: 의존성 및 빌드
+14. `package.json` 업데이트 - web-tree-sitter 추가
+15. typecheck 및 build 검증
+
+---
+
+## 3. 핵심 구현 사항
+
+### 3.1 언어 레지스트리 (38개 언어)
+
+```typescript
+const LANGUAGE_REGISTRY: Record<string, LanguageConfig> = {
+  python: { extensions: [".py"], commentQuery: "(comment) @comment", docstringQuery: "..." },
+  javascript: { extensions: [".js", ".jsx"], commentQuery: "(comment) @comment" },
+  typescript: { extensions: [".ts"], commentQuery: "(comment) @comment" },
+  tsx: { extensions: [".tsx"], commentQuery: "(comment) @comment" },
+  go: { extensions: [".go"], commentQuery: "(comment) @comment" },
+  rust: { extensions: [".rs"], commentQuery: "(line_comment) @comment (block_comment) @comment" },
+  // ... 38개 전체
+}
+```
+
+### 3.2 필터 로직
+
+**BDD 필터**: `given, when, then, arrange, act, assert`
+**Directive 필터**: `noqa, pyright:, eslint-disable, @ts-ignore` 등 30+
+**Docstring 필터**: `IsDocstring || starts with /**`
+**Shebang 필터**: `starts with #!`
+
+### 3.3 출력 형식 (Go 버전과 100% 동일)
+
+```
+COMMENT/DOCSTRING DETECTED - IMMEDIATE ACTION REQUIRED
+
+Your recent changes contain comments or docstrings, which triggered this hook.
+You need to take immediate action. You must follow the conditions below.
+(Listed in priority order - you must always act according to this priority order)
+
+CRITICAL WARNING: This hook message MUST NEVER be ignored...
+
+<comments file="/path/to/file.py">
+	<comment line-number="10">// comment text</comment>
+</comments>
+```
+
+---
+
+## 4. 생성할 파일 목록
+
+1. `src/hooks/comment-checker/types.ts`
+2. `src/hooks/comment-checker/constants.ts`
+3. `src/hooks/comment-checker/filters/bdd.ts`
+4. `src/hooks/comment-checker/filters/directive.ts`
+5. `src/hooks/comment-checker/filters/docstring.ts`
+6. `src/hooks/comment-checker/filters/shebang.ts`
+7. `src/hooks/comment-checker/filters/index.ts`
+8. `src/hooks/comment-checker/output/xml-builder.ts`
+9. `src/hooks/comment-checker/output/formatter.ts`
+10. `src/hooks/comment-checker/output/index.ts`
+11. `src/hooks/comment-checker/detector.ts`
+12. `src/hooks/comment-checker/index.ts`
+
+## 5. 수정할 파일 목록
+
+1. `src/hooks/index.ts` - export 추가
+2. `package.json` - web-tree-sitter 의존성
+
+---
+
+## 6. Definition of Done
+
+- [ ] write/edit 도구 실행 시 코멘트 감지 동작
+- [ ] 4개 필터 모두 정상 작동
+- [ ] 최소 5개 언어 지원 (Python, JS, TS, TSX, Go)
+- [ ] Go 버전과 동일한 출력 형식
+- [ ] typecheck 통과
+- [ ] build 성공

local-ignore/push-and-release.sh

@@ -0,0 +1,12 @@
+#!/bin/bash
+set -e
+cd /Users/yeongyu/local-workspaces/oh-my-opencode
+
+echo "=== Pushing to origin ==="
+git push -f origin master
+
+echo "=== Triggering workflow ==="
+gh workflow run publish.yml --repo code-yeongyu/oh-my-opencode --ref master -f bump=patch -f version=$1
+
+echo "=== Done! ==="
+echo "Usage: ./local-ignore/push-and-release.sh 0.1.6"

notepad.md

@@ -0,0 +1,398 @@
+# MCP Loader Plugin - Orchestration Notepad
+
+## Task Started
+All tasks execution STARTED: Thu Dec 4 16:52:57 KST 2025
+
+---
+
+## Orchestration Overview
+
+**Todo List File**: ./tool-search-tool-plan.md
+**Total Tasks**: 5 (Phase 1-5)
+**Target Files**:
+- `~/.config/opencode/plugin/mcp-loader.ts` - Main plugin
+- `~/.config/opencode/mcp-loader.json` - Global config example
+- `~/.config/opencode/plugin/mcp-loader.test.ts` - Unit tests
+
+---
+
+## Accumulated Wisdom
+
+(To be populated by executors)
+
+---
+
+## Task Progress
+
+| Task | Description | Status |
+|------|-------------|--------|
+| 1 | Plugin skeleton + config loader | pending |
+| 2 | MCP server registry + lifecycle | pending |
+| 3 | mcp_search + mcp_status tools | pending |
+| 4 | mcp_call tool | pending |
+| 5 | Documentation | pending |
+
+---
+
+
+## 2025-12-04 16:58 - Task 1 Completed
+
+### Summary
+- Created `~/.config/opencode/plugin/mcp-loader.ts` - Plugin skeleton with config loader
+- Created `~/.config/opencode/plugin/mcp-loader.test.ts` - 14 unit tests
+
+### Key Implementation Details
+- Config merge: project overrides global for same server names, merges different
+- Env var substitution: `{env:VAR}` → `process.env.VAR`
+- Validation: type required, local needs command, remote needs url
+- Empty config returns `{ servers: {} }` (not error)
+
+### Test Results
+- 14 tests passed
+- substituteEnvVars: 4 tests
+- substituteHeaderEnvVars: 1 test
+- loadConfig: 9 tests
+
+### Files Created
+- `~/.config/opencode/plugin/mcp-loader.ts`
+- `~/.config/opencode/plugin/mcp-loader.test.ts`
+
+---
+
+## [2025-12-08 18:56] - Task 1: Remove unused import formatWorkspaceEdit from LSP tools
+
+### DISCOVERED ISSUES
+- None - simple import cleanup task
+
+### IMPLEMENTATION DECISIONS
+- Removed only `formatWorkspaceEdit` from import list at line 17
+- Kept all other imports intact (formatCodeActions, applyWorkspaceEdit, formatApplyResult remain)
+- Verified the function exists in utils.ts:212 but is truly unused in tools.ts
+
+### PROBLEMS FOR NEXT TASKS
+- None identified for remaining tasks
+
+### VERIFICATION RESULTS
+- Ran: `bun run typecheck` → exit 0, no errors
+- Ran: `bun run build` → exit 0, bundled 200 modules
+- Ran: `rg "formatWorkspaceEdit" src/tools/lsp/tools.ts` → no matches (confirmed removal)
+
+### LEARNINGS
+- Convention: This project uses `bun run typecheck` (tsc --noEmit) and `bun run build` for verification
+- The `formatWorkspaceEdit` function still exists in utils.ts - it's exported but just not used in tools.ts
+
+소요 시간: ~2분
+
+---
+
+## [2025-12-08 19:00] - Task 2: Remove unused ThinkingPart interface and fallbackRevertStrategy function
+
+### DISCOVERED ISSUES
+- None - both items were genuinely unused (no callers found)
+
+### IMPLEMENTATION DECISIONS
+- Removed `ThinkingPart` interface (lines 37-40) - defined but never referenced
+- Removed `fallbackRevertStrategy` function (lines 189-244) - defined but never called
+- Added comment explaining removal reason as per task requirements
+- Kept `ThinkingPartType`, `prependThinkingPart`, `stripThinkingParts` - these are different items and ARE used
+
+### PROBLEMS FOR NEXT TASKS
+- None identified
+
+### VERIFICATION RESULTS
+- Ran: `bun run typecheck` → exit 0, no errors
+- Ran: `bun run build` → exit 0, bundled 200 modules
+- Ran: `rg "ThinkingPart" src/hooks/session-recovery/` → only related types/functions found, interface removed
+- Ran: `rg "fallbackRevertStrategy" src/hooks/session-recovery/` → only comment found, function removed
+- Ran: `rg "createSessionRecoveryHook" src/hooks/` → exports intact
+
+### LEARNINGS
+- `ThinkingPart` interface vs `ThinkingPartType` type vs `prependThinkingPart` function - different entities, verify before removing
+- `fallbackRevertStrategy` was likely a planned feature that never got integrated into the recovery flow
+
+소요 시간: ~2분
+
+---
+
+## [2025-12-08 19:04] - Task 3: Remove unused builtinMcps export from MCP module
+
+### DISCOVERED ISSUES
+- None - `builtinMcps` export was genuinely unused (no external importers)
+
+### IMPLEMENTATION DECISIONS
+- Removed `export const builtinMcps = allBuiltinMcps` from line 24
+- Kept `allBuiltinMcps` const - used internally by `createBuiltinMcps` function
+- Kept `createBuiltinMcps` function - actively used in src/index.ts:89
+
+### PROBLEMS FOR NEXT TASKS
+- None identified
+
+### VERIFICATION RESULTS
+- Ran: `bun run typecheck` → exit 0, no errors
+- Ran: `bun run build` → exit 0, bundled 200 modules
+- Ran: `rg "builtinMcps" src/mcp/index.ts` → no matches (export removed)
+- Ran: `rg "createBuiltinMcps" src/mcp/index.ts` → function still exists
+
+### LEARNINGS
+- `createBuiltinMcps` function vs `builtinMcps` export - function is used, direct export is not
+- Internal const `allBuiltinMcps` should be kept since it's referenced by the function
+
+소요 시간: ~2분
+
+---
+
+## [2025-12-09 16:13] - Task 1: Add file-based logger to shared module
+
+### DISCOVERED ISSUES
+- None - straightforward file copy and modification task
+
+### IMPLEMENTATION DECISIONS
+- Copied logger.ts from opencode-cc-plugin source
+- Changed log file path from `opencode-cc-plugin.log` to `oh-my-opencode.log`
+- Added barrel export from `src/shared/index.ts`
+- Kept original comment for module description
+
+### PROBLEMS FOR NEXT TASKS
+- None identified - logger is now available for use in all new loaders
+
+### VERIFICATION RESULTS
+- Ran: `bun run typecheck` → exit 0, no errors
+- Log file path verified: `/tmp/oh-my-opencode.log`
+- Exports verified: `log()` and `getLogFilePath()` now accessible via `src/shared`
+
+### LEARNINGS
+- Source file location: `~/local-workspaces/opencode-cc-plugin/src/shared/logger.ts`
+- Logger uses `fs.appendFileSync` for synchronous file writing
+- Empty catch block intentionally swallows errors to prevent logging from breaking main operations
+
+소요 시간: ~1분
+
+---
+
+## [2025-12-09 16:14] - Task 3: Rename skill-loader to claude-code-skill-loader
+
+### DISCOVERED ISSUES
+- None - straightforward directory rename task
+
+### IMPLEMENTATION DECISIONS
+- Used `mv` command to rename `src/features/skill-loader/` → `src/features/claude-code-skill-loader/`
+- Updated import path in `src/index.ts` (lines 19-22)
+- Did NOT modify internal imports (`../command-loader/types`) since command-loader still exists (Task 2 runs in parallel)
+
+### PROBLEMS FOR NEXT TASKS
+- If Task 2 renames command-loader to claude-code-command-loader, the internal imports in claude-code-skill-loader will need to be updated as part of Task 2's scope
+- The skill-loader's loader.ts:6 and types.ts:1 import from `../command-loader/types`
+
+### VERIFICATION RESULTS
+- Ran: `bun run typecheck` → exit 0, no errors
+- Ran: `bun run build` → exit 0, succeeded
+- Directory structure verified: `skill-loader/` deleted, `claude-code-skill-loader/` exists
+
+### LEARNINGS
+- This project uses `mv` for directory rename (acceptable per ANTI-PATTERNS - file creation is forbidden, not rename)
+- Command: `bun run typecheck` for type check, `bun run build` for build
+- skill-loader internal imports use relative paths (`../command-loader/types`) which remain valid after rename
+
+소요 시간: ~2분
+
+---
+
+## [2025-12-09 16:16] - Task 2: Rename command-loader to claude-code-command-loader
+
+### DISCOVERED ISSUES
+- skill-loader (now claude-code-skill-loader) was importing `CommandDefinition` from `../command-loader/types`
+- After renaming command-loader, these references also needed updating
+
+### IMPLEMENTATION DECISIONS
+- Used `mv` command: `src/features/command-loader/` → `src/features/claude-code-command-loader/`
+- Updated import path in `src/index.ts` (lines 13-18)
+- Also updated `claude-code-skill-loader/loader.ts:6` and `types.ts:1` to reference new path
+
+### PROBLEMS FOR NEXT TASKS
+- None identified - all dependent imports updated
+
+### VERIFICATION RESULTS
+- Ran: `bun run typecheck` → exit 0, no errors
+- Directory structure verified: `command-loader/` deleted, `claude-code-command-loader/` exists
+- All imports updated: src/index.ts, claude-code-skill-loader/loader.ts, claude-code-skill-loader/types.ts
+
+### LEARNINGS
+- skill-loader depends on command-loader's `CommandDefinition` type via relative import
+- When renaming shared modules, must update ALL dependent modules' imports
+- Task 2 and Task 3 have an implicit dependency through the type import
+
+소요 시간: ~2분
+
+---
+
+## [2025-12-09 16:24] - Task 4: Add claude-code-agent-loader feature
+
+### DISCOVERED ISSUES
+- None - straightforward file copy task
+
+### IMPLEMENTATION DECISIONS
+- Copied 3 files from opencode-cc-plugin: `index.ts`, `loader.ts`, `types.ts`
+- Import path `../../shared/frontmatter` unchanged - already compatible with oh-my-opencode structure
+- No `log()` usage in source files - no logger integration needed
+
+### PROBLEMS FOR NEXT TASKS
+- None identified - agent-loader is self-contained
+
+### VERIFICATION RESULTS
+- Ran: `bun run typecheck` → exit 0, no errors
+- Directory structure verified: `claude-code-agent-loader/` created with 3 files
+- Functions exported: `loadUserAgents()`, `loadProjectAgents()`
+
+### LEARNINGS
+- Source location: `~/local-workspaces/opencode-cc-plugin/src/features/agent-loader/`
+- Agent loader uses `parseFrontmatter` from shared module
+- Agent configs loaded from `~/.claude/agents/` (user) and `.claude/agents/` (project)
+- Scope is appended to description: `(user)` or `(project)`
+
+소요 시간: ~1분
+
+---
+
+## [2025-12-09 16:25] - Task 5: Add claude-code-mcp-loader feature
+
+### DISCOVERED ISSUES
+- None - straightforward file copy task
+
+### IMPLEMENTATION DECISIONS
+- Copied 5 files from opencode-cc-plugin: `index.ts`, `loader.ts`, `transformer.ts`, `env-expander.ts`, `types.ts`
+- Import path `../../shared/logger` unchanged - already compatible with oh-my-opencode structure
+- Kept `Bun.file()` usage - oh-my-opencode targets Bun runtime
+- Environment variable expansion supports `${VAR}` and `${VAR:-default}` syntax
+
+### PROBLEMS FOR NEXT TASKS
+- None identified - mcp-loader is self-contained
+- Does NOT conflict with src/mcp/ (builtin MCPs are separate)
+
+### VERIFICATION RESULTS
+- Ran: `bun run typecheck` → exit 0, no errors
+- Directory structure verified: `claude-code-mcp-loader/` created with 5 files
+- Functions exported: `loadMcpConfigs()`, `formatLoadedServersForToast()`, `transformMcpServer()`, `expandEnvVars()`, `expandEnvVarsInObject()`
+
+### LEARNINGS
+- Source location: `~/local-workspaces/opencode-cc-plugin/src/features/mcp-loader/`
+- MCP configs loaded from:
+  - `~/.claude/.mcp.json` (user scope)
+  - `.mcp.json` (project scope)
+  - `.claude/.mcp.json` (local scope)
+- Later scope overrides earlier scope for same server name
+- Supports stdio, http, and sse server types
+
+소요 시간: ~1분
+
+---
+
+## [2025-12-09 16:24] - Task 6: Add claude-code-session-state feature
+
+### DISCOVERED ISSUES
+- None - straightforward file copy task
+
+### IMPLEMENTATION DECISIONS
+- Copied 4 files from opencode-cc-plugin: `types.ts`, `state.ts`, `detector.ts`, `index.ts`
+- No import path changes needed - files are completely self-contained
+- No external dependencies - types are defined locally
+
+### PROBLEMS FOR NEXT TASKS
+- Task 7 should import from `./features/claude-code-session-state` in src/index.ts
+- Task 7 should remove local session variables and use the module's getter/setters
+
+### VERIFICATION RESULTS
+- Directory created: `src/features/claude-code-session-state/` (4 files confirmed)
+- Exports available: sessionErrorState, sessionInterruptState, subagentSessions, sessionFirstMessageProcessed (Maps/Sets)
+- Exports available: currentSessionID, currentSessionTitle, mainSessionID (state vars)
+- Exports available: setCurrentSession(), setMainSession(), getCurrentSessionID(), getCurrentSessionTitle(), getMainSessionID() (getters/setters)
+- Exports available: detectInterrupt() function
+
+### LEARNINGS
+- Session state module is completely self-contained - no external dependencies
+- Uses barrel export pattern: index.ts re-exports everything from types, state, detector
+- Source directory: `~/local-workspaces/opencode-cc-plugin/src/features/session-state/`
+
+소요 시간: ~1분
+
+---
+
+## [2025-12-09 16:32] - Task 7: Integrate new features into src/index.ts
+
+### DISCOVERED ISSUES
+- None - integration task with well-defined API from previous tasks
+
+### IMPLEMENTATION DECISIONS
+- Added imports for new modules:
+  - `loadUserAgents`, `loadProjectAgents` from `./features/claude-code-agent-loader`
+  - `loadMcpConfigs` from `./features/claude-code-mcp-loader`
+  - `setCurrentSession`, `setMainSession`, `getMainSessionID`, `getCurrentSessionTitle` from `./features/claude-code-session-state`
+  - `log` from `./shared/logger`
+- Removed local session variables (lines 77-79): `mainSessionID`, `currentSessionID`, `currentSessionTitle`
+- Replaced direct session assignments with setter functions:
+  - `mainSessionID = x` → `setMainSession(x)`
+  - `currentSessionID = x; currentSessionTitle = y` → `setCurrentSession(x, y)`
+- Replaced session variable reads with getter functions:
+  - `mainSessionID` comparisons → `getMainSessionID()`
+  - `currentSessionTitle` reads → `getCurrentSessionTitle()`
+- Added agent loading in config hook: `loadUserAgents()`, `loadProjectAgents()`
+- Added MCP loading in config hook: `await loadMcpConfigs()` (async)
+- Replaced `console.error` with `log()` for config validation errors
+- Renamed local variable `agents` to `builtinAgents` to distinguish from loaded agents
+
+### PROBLEMS FOR NEXT TASKS
+- Task 8 (README update) should document the new Agent Loader and MCP Loader features
+- Should explain the `claude-code-*` naming convention
+
+### VERIFICATION RESULTS
+- Ran: `bun run typecheck` → exit 0, no errors
+- Ran: `bun run build` → exit 0, successful build
+- Session tracking verified: all event handlers use getter/setter functions
+- Agent loading verified: config.agent merges builtin + user + project agents
+- MCP loading verified: config.mcp merges builtin MCPs + loaded MCP servers
+
+### LEARNINGS
+- `setCurrentSession(id, title)` sets both ID and title atomically
+- `loadMcpConfigs()` is async - must use `await` in config hook
+- MCP result has `.servers` property that returns the server configs
+- Order matters in spread: later values override earlier (projectAgents > userAgents > builtinAgents)
+
+소요 시간: ~4분
+
+---
+
+## [2025-12-09 16:35] - Task 8: Update README.md documentation
+
+### DISCOVERED ISSUES
+- None - documentation update task
+
+### IMPLEMENTATION DECISIONS
+- Added Agent Loader feature documentation under "Other Features" section (line 235-238)
+  - User scope: `~/.claude/agents/`
+  - Project scope: `./.claude/agents/`
+  - Format: `*.md` files with YAML frontmatter
+- Added MCP Loader feature documentation (line 239-243)
+  - User scope: `~/.claude/.mcp.json`
+  - Project scope: `./.mcp.json`
+  - Local scope: `./.claude/.mcp.json`
+  - Environment variable expansion (`${VAR}` syntax)
+- Added `claude-code-*` naming convention explanation as a blockquote note (line 245)
+  - Explains features migrated from Claude Code
+  - Lists examples: claude-code-command-loader, skill-loader, agent-loader, mcp-loader
+
+### PROBLEMS FOR NEXT TASKS
+- None - this is the final task
+
+### VERIFICATION RESULTS
+- README.md updated with new documentation
+- Style matches existing documentation (bullet points, code blocks for paths)
+- No sections removed or modified (only additions)
+
+### LEARNINGS
+- README.md "Other Features" section is at line 224
+- Existing features: Terminal Title, Command Loader, Skill Loader
+- Documentation style: bold feature name, bullet points for scopes/details
+
+소요 시간: ~1분
+
+---
+

package.json

@@ -1,13 +1,10 @@
 {
   "name": "oh-my-opencode",
-  "version": "2.9.1",
+  "version": "0.2.0",
   "description": "OpenCode plugin - custom agents (oracle, librarian) and enhanced features",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "type": "module",
-  "bin": {
-    "oh-my-opencode": "./dist/cli/index.js"
-  },
   "files": [
     "dist"
   ],
@@ -16,19 +13,14 @@
       "types": "./dist/index.d.ts",
       "import": "./dist/index.js"
     },
-    "./google-auth": {
-      "types": "./dist/google-auth.d.ts",
-      "import": "./dist/google-auth.js"
-    },
     "./schema.json": "./dist/oh-my-opencode.schema.json"
   },
   "scripts": {
-    "build": "bun build src/index.ts src/google-auth.ts --outdir dist --target bun --format esm --external @ast-grep/napi && tsc --emitDeclarationOnly && bun build src/cli/index.ts --outdir dist/cli --target bun --format esm --external @ast-grep/napi && bun run build:schema",
+    "build": "bun build src/index.ts --outdir dist --target bun --format esm --external @ast-grep/napi && tsc --emitDeclarationOnly && bun run build:schema",
     "build:schema": "bun run script/build-schema.ts",
     "clean": "rm -rf dist",
     "prepublishOnly": "bun run clean && bun run build",
-    "typecheck": "tsc --noEmit",
-    "test": "bun test"
+    "typecheck": "tsc --noEmit"
   },
   "keywords": [
     "opencode",
@@ -40,7 +32,7 @@
     "llm"
   ],
   "author": "YeonGyu-Kim",
-  "license": "SUL-1.0",
+  "license": "MIT",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/code-yeongyu/oh-my-opencode.git"
@@ -52,24 +44,19 @@
   "dependencies": {
     "@ast-grep/cli": "^0.40.0",
     "@ast-grep/napi": "^0.40.0",
-    "@clack/prompts": "^0.11.0",
-    "@code-yeongyu/comment-checker": "^0.6.1",
-    "@openauthjs/openauth": "^0.4.3",
-    "@opencode-ai/plugin": "^1.0.162",
-    "@opencode-ai/sdk": "^1.0.162",
-    "commander": "^14.0.2",
-    "hono": "^4.10.4",
-    "jsonc-parser": "^3.3.1",
-    "picocolors": "^1.1.1",
-    "picomatch": "^4.0.2",
+    "@code-yeongyu/comment-checker": "^0.5.0",
+    "@opencode-ai/plugin": "^1.0.7",
     "xdg-basedir": "^5.1.0",
     "zod": "^4.1.8"
   },
   "devDependencies": {
-    "@types/picomatch": "^3.0.2",
     "bun-types": "latest",
+    "oh-my-opencode": "^0.1.30",
     "typescript": "^5.7.3"
   },
+  "peerDependencies": {
+    "bun": ">=1.0.0"
+  },
   "trustedDependencies": [
     "@ast-grep/cli",
     "@ast-grep/napi",

script/generate-changelog.ts

@@ -1,92 +0,0 @@
-#!/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()

script/publish.ts

@@ -41,9 +41,7 @@ async function updatePackageVersion(newVersion: string): Promise<void> {
   console.log(`Updated: ${pkgPath}`)
 }
 
-async function generateChangelog(previous: string): Promise<string[]> {
-  const notes: string[] = []
-
+async function generateChangelog(previous: string): Promise<string> {
   try {
     const log = await $`git log v${previous}..HEAD --oneline --format="%h %s"`.text()
     const commits = log
@@ -51,59 +49,16 @@ async function generateChangelog(previous: string): Promise<string[]> {
       .filter((line) => line && !line.match(/^\w+ (ignore:|test:|chore:|ci:|release:)/i))
 
     if (commits.length > 0) {
-      for (const commit of commits) {
-        notes.push(`- ${commit}`)
-      }
+      const changelog = commits.map((c) => `- ${c}`).join("\n")
       console.log("\n--- Changelog ---")
-      console.log(notes.join("\n"))
+      console.log(changelog)
       console.log("-----------------\n")
+      return changelog
     }
   } catch {
     console.log("No previous tags found, skipping changelog generation")
   }
-
-  return notes
-}
-
-async function getContributors(previous: string): Promise<string[]> {
-  const notes: string[] = []
-
-  const team = ["actions-user", "github-actions[bot]", "code-yeongyu"]
-
-  try {
-    const compare =
-      await $`gh api "/repos/code-yeongyu/oh-my-opencode/compare/v${previous}...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}`)
-        }
-      }
-      console.log("\n--- Contributors ---")
-      console.log(notes.join("\n"))
-      console.log("--------------------\n")
-    }
-  } catch (error) {
-    console.log("Failed to fetch contributors:", error)
-  }
-
-  return notes
+  return ""
 }
 
 async function buildAndPublish(): Promise<void> {
@@ -116,14 +71,15 @@ async function buildAndPublish(): Promise<void> {
   }
 }
 
-async function gitTagAndRelease(newVersion: string, notes: string[]): Promise<void> {
+async function gitTagAndRelease(newVersion: string, changelog: string): Promise<void> {
   if (!process.env.CI) return
 
   console.log("\nCommitting and tagging...")
   await $`git config user.email "github-actions[bot]@users.noreply.github.com"`
   await $`git config user.name "github-actions[bot]"`
-  await $`git add package.json assets/oh-my-opencode.schema.json`
+  await $`git add package.json`
 
+  // Commit only if there are staged changes (idempotent)
   const hasStagedChanges = await $`git diff --cached --quiet`.nothrow()
   if (hasStagedChanges.exitCode !== 0) {
     await $`git commit -m "release: v${newVersion}"`
@@ -131,6 +87,7 @@ async function gitTagAndRelease(newVersion: string, notes: string[]): Promise<vo
     console.log("No changes to commit (version already updated)")
   }
 
+  // Tag only if it doesn't exist (idempotent)
   const tagExists = await $`git rev-parse v${newVersion}`.nothrow()
   if (tagExists.exitCode !== 0) {
     await $`git tag v${newVersion}`
@@ -138,10 +95,12 @@ async function gitTagAndRelease(newVersion: string, notes: string[]): Promise<vo
     console.log(`Tag v${newVersion} already exists`)
   }
 
+  // Push (idempotent - git push is already idempotent)
   await $`git push origin HEAD --tags`
 
+  // Create release only if it doesn't exist (idempotent)
   console.log("\nCreating GitHub release...")
-  const releaseNotes = notes.length > 0 ? notes.join("\n") : "No notable changes"
+  const releaseNotes = changelog || "No notable changes"
   const releaseExists = await $`gh release view v${newVersion}`.nothrow()
   if (releaseExists.exitCode !== 0) {
     await $`gh release create v${newVersion} --title "v${newVersion}" --notes ${releaseNotes}`
@@ -171,11 +130,8 @@ async function main() {
 
   await updatePackageVersion(newVersion)
   const changelog = await generateChangelog(previous)
-  const contributors = await getContributors(previous)
-  const notes = [...changelog, ...contributors]
-
   await buildAndPublish()
-  await gitTagAndRelease(newVersion, notes)
+  await gitTagAndRelease(newVersion, changelog)
 
   console.log(`\n=== Successfully published ${PACKAGE_NAME}@${newVersion} ===`)
 }

signatures/cla.json

@@ -1,148 +0,0 @@
-{
-  "signedContributors": [
-    {
-      "name": "tsanva",
-      "id": 54318170,
-      "comment_id": 3690638858,
-      "created_at": "2025-12-25T00:15:18Z",
-      "repoId": 1108837393,
-      "pullRequestNo": 210
-    },
-    {
-      "name": "code-yeongyu",
-      "id": 11153873,
-      "comment_id": 3690997221,
-      "created_at": "2025-12-25T06:19:27Z",
-      "repoId": 1108837393,
-      "pullRequestNo": 217
-    },
-    {
-      "name": "mylukin",
-      "id": 1021019,
-      "comment_id": 3691531529,
-      "created_at": "2025-12-25T15:15:29Z",
-      "repoId": 1108837393,
-      "pullRequestNo": 240
-    },
-    {
-      "name": "codewithkenzo",
-      "id": 115878491,
-      "comment_id": 3691825625,
-      "created_at": "2025-12-25T23:47:52Z",
-      "repoId": 1108837393,
-      "pullRequestNo": 253
-    },
-    {
-      "name": "stevenvo",
-      "id": 875426,
-      "comment_id": 3692141372,
-      "created_at": "2025-12-26T05:16:12Z",
-      "repoId": 1108837393,
-      "pullRequestNo": 248
-    },
-    {
-      "name": "harshav167",
-      "id": 80092815,
-      "comment_id": 3693666997,
-      "created_at": "2025-12-27T04:40:35Z",
-      "repoId": 1108837393,
-      "pullRequestNo": 268
-    },
-    {
-      "name": "adam2am",
-      "id": 128839448,
-      "comment_id": 3694022446,
-      "created_at": "2025-12-27T14:49:05Z",
-      "repoId": 1108837393,
-      "pullRequestNo": 281
-    },
-    {
-      "name": "devxoul",
-      "id": 931655,
-      "comment_id": 3694098760,
-      "created_at": "2025-12-27T17:05:50Z",
-      "repoId": 1108837393,
-      "pullRequestNo": 288
-    },
-    {
-      "name": "SyedTahirHussan",
-      "id": 9879266,
-      "comment_id": 3694598917,
-      "created_at": "2025-12-28T09:24:03Z",
-      "repoId": 1108837393,
-      "pullRequestNo": 306
-    },
-    {
-      "name": "Fguedes90",
-      "id": 13650239,
-      "comment_id": 3695136375,
-      "created_at": "2025-12-28T23:34:19Z",
-      "repoId": 1108837393,
-      "pullRequestNo": 319
-    },
-    {
-      "name": "marcusrbrown",
-      "id": 831617,
-      "comment_id": 3698181444,
-      "created_at": "2025-12-30T03:12:47Z",
-      "repoId": 1108837393,
-      "pullRequestNo": 336
-    },
-    {
-      "name": "lgandecki",
-      "id": 4002543,
-      "comment_id": 3698538417,
-      "created_at": "2025-12-30T07:35:08Z",
-      "repoId": 1108837393,
-      "pullRequestNo": 341
-    },
-    {
-      "name": "purelledhand",
-      "id": 13747937,
-      "comment_id": 3699148046,
-      "created_at": "2025-12-30T12:04:59Z",
-      "repoId": 1108837393,
-      "pullRequestNo": 349
-    },
-    {
-      "name": "junhoyeo",
-      "id": 32605822,
-      "comment_id": 3701585491,
-      "created_at": "2025-12-31T07:00:36Z",
-      "repoId": 1108837393,
-      "pullRequestNo": 375
-    },
-    {
-      "name": "gtg7784",
-      "id": 32065632,
-      "comment_id": 3701688739,
-      "created_at": "2025-12-31T08:05:25Z",
-      "repoId": 1108837393,
-      "pullRequestNo": 377
-    },
-    {
-      "name": "ul8",
-      "id": 589744,
-      "comment_id": 3701705644,
-      "created_at": "2025-12-31T08:16:46Z",
-      "repoId": 1108837393,
-      "pullRequestNo": 378
-    },
-    {
-      "name": "eudresfs",
-      "id": 66638312,
-      "comment_id": 3702622517,
-      "created_at": "2025-12-31T18:03:32Z",
-      "repoId": 1108837393,
-      "pullRequestNo": 385
-    },
-    {
-      "name": "vsumner",
-      "id": 308886,
-      "comment_id": 3702872360,
-      "created_at": "2025-12-31T20:40:20Z",
-      "repoId": 1108837393,
-      "pullRequestNo": 388
-    }
-  ]
-}

src/agents/AGENTS.md

@@ -1,89 +0,0 @@
-# AGENTS KNOWLEDGE BASE
-
-## OVERVIEW
-
-AI agent definitions for multi-model orchestration. 7 specialized agents: Sisyphus (orchestrator), oracle (strategy), librarian (research), explore (grep), frontend-ui-ux-engineer, document-writer, multimodal-looker.
-
-## STRUCTURE
-
-```
-agents/
-├── sisyphus.ts              # Primary orchestrator (Claude Opus 4.5)
-├── oracle.ts                # Strategic advisor (GPT-5.2)
-├── librarian.ts             # Multi-repo research (Claude Sonnet 4.5)
-├── explore.ts               # Fast codebase grep (Grok Code)
-├── frontend-ui-ux-engineer.ts  # UI generation (Gemini 3 Pro)
-├── document-writer.ts       # Technical docs (Gemini 3 Flash)
-├── multimodal-looker.ts     # PDF/image analysis (Gemini 3 Flash)
-├── build-prompt.ts          # Shared build agent prompt
-├── plan-prompt.ts           # Shared plan agent prompt
-├── types.ts                 # AgentModelConfig interface
-├── utils.ts                 # createBuiltinAgents(), getAgentName()
-└── index.ts                 # builtinAgents export
-```
-
-## AGENT MODELS
-
-| Agent | Default Model | Fallback | Purpose |
-|-------|---------------|----------|---------|
-| Sisyphus | anthropic/claude-opus-4-5 | - | Primary orchestrator with extended thinking |
-| oracle | openai/gpt-5.2 | - | Architecture, debugging, code review |
-| librarian | anthropic/claude-sonnet-4-5 | google/gemini-3-flash | Docs, OSS research, GitHub examples |
-| explore | opencode/grok-code | google/gemini-3-flash, anthropic/claude-haiku-4-5 | Fast contextual grep |
-| frontend-ui-ux-engineer | google/gemini-3-pro-preview | - | UI/UX code generation |
-| document-writer | google/gemini-3-pro-preview | - | Technical writing |
-| multimodal-looker | google/gemini-3-flash | - | PDF/image analysis |
-
-## HOW TO ADD AN AGENT
-
-1. Create `src/agents/my-agent.ts`:
-   ```typescript
-   import type { AgentConfig } from "@opencode-ai/sdk"
-   
-   export const myAgent: AgentConfig = {
-     model: "provider/model-name",
-     temperature: 0.1,
-     system: "Agent system prompt...",
-     tools: { include: ["tool1", "tool2"] },  // or exclude: [...]
-   }
-   ```
-2. Add to `builtinAgents` in `src/agents/index.ts`
-3. Update `types.ts` if adding new config options
-
-## AGENT CONFIG OPTIONS
-
-| Option | Type | Description |
-|--------|------|-------------|
-| model | string | Model identifier (provider/model-name) |
-| temperature | number | 0.0-1.0, most use 0.1 for consistency |
-| system | string | System prompt (can be multiline template literal) |
-| tools | object | `{ include: [...] }` or `{ exclude: [...] }` |
-| top_p | number | Optional nucleus sampling |
-| maxTokens | number | Optional max output tokens |
-
-## MODEL FALLBACK LOGIC
-
-`createBuiltinAgents()` in utils.ts handles model fallback:
-
-1. Check user config override (`agents.{name}.model`)
-2. Check installer settings (claude max20, gemini antigravity)
-3. Use default model
-
-**Fallback order for explore**:
-- If gemini antigravity enabled → `google/gemini-3-flash`
-- If claude max20 enabled → `anthropic/claude-haiku-4-5`
-- Default → `opencode/grok-code` (free)
-
-## ANTI-PATTERNS (AGENTS)
-
-- **High temperature**: Don't use >0.3 for code-related agents
-- **Broad tool access**: Prefer explicit `include` over unrestricted access
-- **Monolithic prompts**: Keep prompts focused; delegate to specialized agents
-- **Missing fallbacks**: Consider free/cheap fallbacks for rate-limited models
-
-## SHARED PROMPTS
-
-- **build-prompt.ts**: Base prompt for build agents (OpenCode default + Sisyphus variants)
-- **plan-prompt.ts**: Base prompt for plan agents (Planner-Sisyphus)
-
-Used by `src/index.ts` when creating Builder-Sisyphus and Planner-Sisyphus variants.

src/agents/build-prompt.ts

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

src/agents/document-writer.ts

@@ -1,27 +1,11 @@
 import type { AgentConfig } from "@opencode-ai/sdk"
-import type { AgentPromptMetadata } from "./types"
 
-const DEFAULT_MODEL = "google/gemini-3-flash-preview"
-
-export const DOCUMENT_WRITER_PROMPT_METADATA: AgentPromptMetadata = {
-  category: "specialist",
-  cost: "CHEAP",
-  promptAlias: "Document Writer",
-  triggers: [
-    { domain: "Documentation", trigger: "README, API docs, guides" },
-  ],
-}
-
-export function createDocumentWriterAgent(
-  model: string = DEFAULT_MODEL
-): AgentConfig {
-  return {
-    description:
-      "A technical writer who crafts clear, comprehensive documentation. Specializes in README files, API docs, architecture docs, and user guides. MUST BE USED when executing documentation tasks from ai-todo list plans.",
-    mode: "subagent" as const,
-    model,
-    tools: { background_task: false },
-    prompt: `<role>
+export const documentWriterAgent: AgentConfig = {
+  description:
+    "A technical writer who crafts clear, comprehensive documentation. Specializes in README files, API docs, architecture docs, and user guides. MUST BE USED when executing documentation tasks from ai-todo list plans.",
+  mode: "subagent",
+  model: "google/gemini-3-pro-preview",
+  prompt: `<role>
 You are a TECHNICAL WRITER with deep engineering background who transforms complex codebases into crystal-clear documentation. You have an innate ability to explain complex concepts simply while maintaining technical accuracy.
 
 You approach every documentation task with both a developer's understanding and a reader's empathy. Even without detailed specs, you can explore codebases and create documentation that developers actually want to read.
@@ -215,7 +199,4 @@ STOP HERE - DO NOT CONTINUE TO NEXT TASK
 
 You are a technical writer who creates documentation that developers actually want to read.
 </guide>`,
-  }
 }
-
-export const documentWriterAgent = createDocumentWriterAgent()

src/agents/explore.ts

@@ -1,126 +1,69 @@
 import type { AgentConfig } from "@opencode-ai/sdk"
-import type { AgentPromptMetadata } from "./types"
 
-const DEFAULT_MODEL = "opencode/grok-code"
+export const exploreAgent: AgentConfig = {
+  description:
+    'Fast agent specialized for exploring codebases. Use this when you need to quickly find files by patterns (eg. "src/components/**/*.tsx"), search code for keywords (eg. "API endpoints"), or answer questions about the codebase (eg. "how do API endpoints work?"). When calling this agent, specify the desired thoroughness level: "quick" for basic searches, "medium" for moderate exploration, or "very thorough" for comprehensive analysis across multiple locations and naming conventions.',
+  mode: "subagent",
+  model: "opencode/grok-code",
+  temperature: 0.1,
+  tools: { write: false, edit: false },
+  prompt: `You are a file search specialist. You excel at thoroughly navigating and exploring codebases.
 
-export const EXPLORE_PROMPT_METADATA: AgentPromptMetadata = {
-  category: "exploration",
-  cost: "FREE",
-  promptAlias: "Explore",
-  keyTrigger: "2+ modules involved → fire `explore` background",
-  triggers: [
-    { domain: "Explore", trigger: "Find existing codebase structure, patterns and styles" },
-  ],
-  useWhen: [
-    "Multiple search angles needed",
-    "Unfamiliar module structure",
-    "Cross-layer pattern discovery",
-  ],
-  avoidWhen: [
-    "You know exactly what to search",
-    "Single keyword/pattern suffices",
-    "Known file location",
-  ],
-}
+=== CRITICAL: READ-ONLY MODE - NO FILE MODIFICATIONS ===
+This is a READ-ONLY exploration task. You are STRICTLY PROHIBITED from:
+- Creating new files (no Write, touch, or file creation of any kind)
+- Modifying existing files (no Edit operations)
+- Deleting files (no rm or deletion)
+- Moving or copying files (no mv or cp)
+- Creating temporary files anywhere, including /tmp
+- Using redirect operators (>, >>, |) or heredocs to write to files
+- Running ANY commands that change system state
 
-export function createExploreAgent(model: string = DEFAULT_MODEL): AgentConfig {
-  return {
-    description:
-      'Contextual grep for codebases. Answers "Where is X?", "Which file has Y?", "Find the code that does Z". Fire multiple in parallel for broad searches. Specify thoroughness: "quick" for basic, "medium" for moderate, "very thorough" for comprehensive analysis.',
-    mode: "subagent" as const,
-    model,
-    temperature: 0.1,
-    tools: { write: false, edit: false, background_task: false },
-    prompt: `You are a codebase search specialist. Your job: find files and code, return actionable results.
+Your role is EXCLUSIVELY to search and analyze existing code. You do NOT have access to file editing tools - attempting to edit files will fail.
 
-## Your Mission
+## Before You Search
 
-Answer questions like:
-- "Where is X implemented?"
-- "Which files contain Y?"
-- "Find the code that does Z"
-
-## CRITICAL: What You Must Deliver
-
-Every response MUST include:
-
-### 1. Intent Analysis (Required)
-Before ANY search, wrap your analysis in <analysis> tags:
+Before executing any search, you MUST first analyze the request in <analysis> tags:
 
 <analysis>
-**Literal Request**: [What they literally asked]
-**Actual Need**: [What they're really trying to accomplish]
-**Success Looks Like**: [What result would let them proceed immediately]
+1. **Request**: What exactly did the user ask for?
+2. **Intent**: Why are they asking this? What problem are they trying to solve?
+3. **Expected Output**: What kind of answer would be most helpful?
+4. **Search Strategy**: What tools and patterns will I use to find this?
 </analysis>
 
-### 2. Parallel Execution (Required)
-Launch **3+ tools simultaneously** in your first action. Never sequential unless output depends on prior result.
-
-### 3. Structured Results (Required)
-Always end with this exact format:
-
-<results>
-<files>
-- /absolute/path/to/file1.ts — [why this file is relevant]
-- /absolute/path/to/file2.ts — [why this file is relevant]
-</files>
-
-<answer>
-[Direct answer to their actual need, not just file list]
-[If they asked "where is auth?", explain the auth flow you found]
-</answer>
-
-<next_steps>
-[What they should do with this information]
-[Or: "Ready to proceed - no follow-up needed"]
-</next_steps>
-</results>
+Only after completing this analysis should you proceed with the actual search.
 
 ## Success Criteria
 
-| Criterion | Requirement |
-|-----------|-------------|
-| **Paths** | ALL paths must be **absolute** (start with /) |
-| **Completeness** | Find ALL relevant matches, not just the first one |
-| **Actionability** | Caller can proceed **without asking follow-up questions** |
-| **Intent** | Address their **actual need**, not just literal request |
+Your response is successful when:
+- **Completeness**: All relevant files matching the search intent are found
+- **Accuracy**: Returned paths are absolute and files actually exist
+- **Relevance**: Results directly address the user's underlying intent, not just literal request
+- **Actionability**: Caller can proceed without follow-up questions
 
-## Failure Conditions
+Your response has FAILED if:
+- You skip the <analysis> step before searching
+- Paths are relative instead of absolute
+- Obvious matches in the codebase are missed
+- Results don't address what the user actually needed
 
-Your response has **FAILED** if:
-- Any path is relative (not absolute)
-- You missed obvious matches in the codebase
-- Caller needs to ask "but where exactly?" or "what about X?"
-- You only answered the literal question, not the underlying need
-- No <results> block with structured output
+## Your strengths
+- Rapidly finding files using glob patterns
+- Searching code and text with powerful regex patterns
+- Reading and analyzing file contents
 
-## Constraints
+Guidelines:
+- Use **Glob** for broad file pattern matching (e.g., \`**/*.py\`, \`src/**/*.ts\`)
+- Use **Grep** for searching file contents with regex patterns
+- Use **Read** when you know the specific file path you need to read
+- Use **List** for exploring directory structure
+- Use **Bash** ONLY for read-only operations (ls, git status, git log, git diff, find)
+- NEVER use Bash for: mkdir, touch, rm, cp, mv, git add, git commit, npm install, pip install, or any file creation/modification
+- Adapt your search approach based on the thoroughness level specified by the caller
+- Return file paths as absolute paths in your final response
+- For clear communication, avoid using emojis
+- Communicate your final report directly as a regular message - do NOT attempt to create files
 
-- **Read-only**: You cannot create, modify, or delete files
-- **No emojis**: Keep output clean and parseable
-- **No file creation**: Report findings as message text, never write files
-
-## Tool Strategy
-
-Use the right tool for the job:
-- **Semantic search** (definitions, references): LSP tools
-- **Structural patterns** (function shapes, class structures): ast_grep_search  
-- **Text patterns** (strings, comments, logs): grep
-- **File patterns** (find by name/extension): glob
-- **History/evolution** (when added, who changed): git commands
-- **External examples** (how others implement): grep_app
-
-### grep_app Strategy
-
-grep_app searches millions of public GitHub repos instantly — use it for external patterns and examples.
-
-**Critical**: grep_app results may be **outdated or from different library versions**. Always:
-1. Start with grep_app for broad discovery
-2. Launch multiple grep_app calls with query variations in parallel
-3. **Cross-validate with local tools** (grep, ast_grep_search, LSP) before trusting results
-
-Flood with parallel calls. Trust only cross-validated results.`,
-  }
+Complete the user's search request efficiently and report your findings clearly.`,
 }
-
-export const exploreAgent = createExploreAgent()

src/agents/frontend-ui-ux-engineer.ts

@@ -1,106 +1,91 @@
 import type { AgentConfig } from "@opencode-ai/sdk"
-import type { AgentPromptMetadata } from "./types"
 
-const DEFAULT_MODEL = "google/gemini-3-pro-preview"
+export const frontendUiUxEngineerAgent: AgentConfig = {
+  description:
+    "A designer-turned-developer who crafts stunning UI/UX even without design mockups. Code may be a bit messy, but the visual output is always fire.",
+  mode: "subagent",
+  model: "google/gemini-3-pro-preview",
+  prompt: `<role>
+You are a DESIGNER-TURNED-DEVELOPER with an innate sense of aesthetics and user experience. You have an eye for details that pure developers miss - spacing, color harmony, micro-interactions, and that indefinable "feel" that makes interfaces memorable.
 
-export const FRONTEND_PROMPT_METADATA: AgentPromptMetadata = {
-  category: "specialist",
-  cost: "CHEAP",
-  promptAlias: "Frontend UI/UX Engineer",
-  triggers: [
-    { domain: "Frontend UI/UX", trigger: "Visual changes only (styling, layout, animation). Pure logic changes in frontend files → handle directly" },
-  ],
-  useWhen: [
-    "Visual/UI/UX changes: Color, spacing, layout, typography, animation, responsive breakpoints, hover states, shadows, borders, icons, images",
-  ],
-  avoidWhen: [
-    "Pure logic: API calls, data fetching, state management, event handlers (non-visual), type definitions, utility functions, business logic",
-  ],
-}
+You approach every UI task with a designer's intuition. Even without mockups or design specs, you can envision and create beautiful, cohesive interfaces that feel intentional and polished.
 
-export function createFrontendUiUxEngineerAgent(
-  model: string = DEFAULT_MODEL
-): AgentConfig {
-  return {
-    description:
-      "A designer-turned-developer who crafts stunning UI/UX even without design mockups. Code may be a bit messy, but the visual output is always fire.",
-    mode: "subagent" as const,
-    model,
-    tools: { background_task: false },
-    prompt: `# Role: Designer-Turned-Developer
+## CORE MISSION
+Create visually stunning, emotionally engaging interfaces that users fall in love with. Execute frontend tasks with a designer's eye - obsessing over pixel-perfect details, smooth animations, and intuitive interactions while maintaining code quality.
 
-You are a designer who learned to code. You see what pure developers miss—spacing, color harmony, micro-interactions, that indefinable "feel" that makes interfaces memorable. Even without mockups, you envision and create beautiful, cohesive interfaces.
+## CODE OF CONDUCT
 
-**Mission**: Create visually stunning, emotionally engaging interfaces users fall in love with. Obsess over pixel-perfect details, smooth animations, and intuitive interactions while maintaining code quality.
+### 1. DILIGENCE & INTEGRITY
+**Never compromise on task completion. What you commit to, you deliver.**
 
----
+- **Complete what is asked**: Execute the exact task specified without adding unrelated features or fixing issues outside scope
+- **No shortcuts**: Never mark work as complete without proper verification
+- **Work until it works**: If something doesn't look right, debug and fix until it's perfect
+- **Leave it better**: Ensure the project is in a working state after your changes
+- **Own your work**: Take full responsibility for the quality and correctness of your implementation
 
-# Work Principles
+### 2. CONTINUOUS LEARNING & HUMILITY
+**Approach every codebase with the mindset of a student, always ready to learn.**
 
-1. **Complete what's asked** — Execute the exact task. No scope creep. Work until it works. Never mark work complete without proper verification.
-2. **Leave it better** — Ensure the project is in a working state after your changes.
-3. **Study before acting** — Examine existing patterns, conventions, and commit history (git log) before implementing. Understand why code is structured the way it is.
-4. **Blend seamlessly** — Match existing code patterns. Your code should look like the team wrote it.
-5. **Be transparent** — Announce each step. Explain reasoning. Report both successes and failures.
+- **Study before acting**: Examine existing code patterns, conventions, and architecture before implementing
+- **Learn from the codebase**: Understand why code is structured the way it is
+- **Share knowledge**: Help future developers by documenting project-specific conventions discovered
 
----
+### 3. PRECISION & ADHERENCE TO STANDARDS
+**Respect the existing codebase. Your code should blend seamlessly.**
 
-# Design Process
+- **Follow exact specifications**: Implement precisely what is requested, nothing more, nothing less
+- **Match existing patterns**: Maintain consistency with established code patterns and architecture
+- **Respect conventions**: Adhere to project-specific naming, structure, and style conventions
+- **Check commit history**: If creating commits, study \`git log\` to match the repository's commit style
+- **Consistent quality**: Apply the same rigorous standards throughout your work
 
-Before coding, commit to a **BOLD aesthetic direction**:
+### 4. TRANSPARENCY & ACCOUNTABILITY
+**Keep everyone informed. Hide nothing.**
 
-1. **Purpose**: What problem does this solve? Who uses it?
-2. **Tone**: Pick an extreme—brutally minimal, maximalist chaos, retro-futuristic, organic/natural, luxury/refined, playful/toy-like, editorial/magazine, brutalist/raw, art deco/geometric, soft/pastel, industrial/utilitarian
-3. **Constraints**: Technical requirements (framework, performance, accessibility)
-4. **Differentiation**: What's the ONE thing someone will remember?
+- **Announce each step**: Clearly state what you're doing at each stage
+- **Explain your reasoning**: Help others understand why you chose specific approaches
+- **Report honestly**: Communicate both successes and failures explicitly
+- **No surprises**: Make your work visible and understandable to others
+</role>
 
-**Key**: Choose a clear direction and execute with precision. Intentionality > intensity.
+<frontend-design-skill>
 
-Then implement working code (HTML/CSS/JS, React, Vue, Angular, etc.) that is:
+This skill guides creation of distinctive, production-grade frontend interfaces that avoid generic "AI slop" aesthetics. Implement real working code with exceptional attention to aesthetic details and creative choices.
+
+The user provides frontend requirements: a component, page, application, or interface to build. They may include context about the purpose, audience, or technical constraints.
+
+## Design Thinking
+
+Before coding, understand the context and commit to a BOLD aesthetic direction:
+- **Purpose**: What problem does this interface solve? Who uses it?
+- **Tone**: Pick an extreme: brutally minimal, maximalist chaos, retro-futuristic, organic/natural, luxury/refined, playful/toy-like, editorial/magazine, brutalist/raw, art deco/geometric, soft/pastel, industrial/utilitarian, etc. There are so many flavors to choose from. Use these for inspiration but design one that is true to the aesthetic direction.
+- **Constraints**: Technical requirements (framework, performance, accessibility).
+- **Differentiation**: What makes this UNFORGETTABLE? What's the one thing someone will remember?
+
+**CRITICAL**: Choose a clear conceptual direction and execute it with precision. Bold maximalism and refined minimalism both work - the key is intentionality, not intensity.
+
+Then implement working code (HTML/CSS/JS, React, Vue, etc.) that is:
 - Production-grade and functional
 - Visually striking and memorable
 - Cohesive with a clear aesthetic point-of-view
 - Meticulously refined in every detail
 
----
+## Frontend Aesthetics Guidelines
 
-# Aesthetic Guidelines
+Focus on:
+- **Typography**: Choose fonts that are beautiful, unique, and interesting. Avoid generic fonts like Arial and Inter; opt instead for distinctive choices that elevate the frontend's aesthetics; unexpected, characterful font choices. Pair a distinctive display font with a refined body font.
+- **Color & Theme**: Commit to a cohesive aesthetic. Use CSS variables for consistency. Dominant colors with sharp accents outperform timid, evenly-distributed palettes.
+- **Motion**: Use animations for effects and micro-interactions. Prioritize CSS-only solutions for HTML. Use Motion library for React when available. Focus on high-impact moments: one well-orchestrated page load with staggered reveals (animation-delay) creates more delight than scattered micro-interactions. Use scroll-triggering and hover states that surprise.
+- **Spatial Composition**: Unexpected layouts. Asymmetry. Overlap. Diagonal flow. Grid-breaking elements. Generous negative space OR controlled density.
+- **Backgrounds & Visual Details**: Create atmosphere and depth rather than defaulting to solid colors. Add contextual effects and textures that match the overall aesthetic. Apply creative forms like gradient meshes, noise textures, geometric patterns, layered transparencies, dramatic shadows, decorative borders, custom cursors, and grain overlays.
 
-## Typography
-Choose distinctive fonts. **Avoid**: Arial, Inter, Roboto, system fonts, Space Grotesk. Pair a characterful display font with a refined body font.
+NEVER use generic AI-generated aesthetics like overused font families (Inter, Roboto, Arial, system fonts), cliched color schemes (particularly purple gradients on white backgrounds), predictable layouts and component patterns, and cookie-cutter design that lacks context-specific character.
 
-## Color
-Commit to a cohesive palette. Use CSS variables. Dominant colors with sharp accents outperform timid, evenly-distributed palettes. **Avoid**: purple gradients on white (AI slop).
+Interpret creatively and make unexpected choices that feel genuinely designed for the context. No design should be the same. Vary between light and dark themes, different fonts, different aesthetics. NEVER converge on common choices (Space Grotesk, for example) across generations.
 
-## Motion
-Focus on high-impact moments. One well-orchestrated page load with staggered reveals (animation-delay) > scattered micro-interactions. Use scroll-triggering and hover states that surprise. Prioritize CSS-only. Use Motion library for React when available.
+**IMPORTANT**: Match implementation complexity to the aesthetic vision. Maximalist designs need elaborate code with extensive animations and effects. Minimalist or refined designs need restraint, precision, and careful attention to spacing, typography, and subtle details. Elegance comes from executing the vision well.
 
-## Spatial Composition
-Unexpected layouts. Asymmetry. Overlap. Diagonal flow. Grid-breaking elements. Generous negative space OR controlled density.
-
-## Visual Details
-Create atmosphere and depth—gradient meshes, noise textures, geometric patterns, layered transparencies, dramatic shadows, decorative borders, custom cursors, grain overlays. Never default to solid colors.
-
----
-
-# Anti-Patterns (NEVER)
-
-- Generic fonts (Inter, Roboto, Arial, system fonts, Space Grotesk)
-- Cliched color schemes (purple gradients on white)
-- Predictable layouts and component patterns
-- Cookie-cutter design lacking context-specific character
-- Converging on common choices across generations
-
----
-
-# Execution
-
-Match implementation complexity to aesthetic vision:
-- **Maximalist** → Elaborate code with extensive animations and effects
-- **Minimalist** → Restraint, precision, careful spacing and typography
-
-Interpret creatively and make unexpected choices that feel genuinely designed for the context. No design should be the same. Vary between light and dark themes, different fonts, different aesthetics. You are capable of extraordinary creative work—don't hold back.`,
-  }
+Remember: Claude is capable of extraordinary creative work. Don't hold back, show what can truly be created when thinking outside the box and committing fully to a distinctive vision.
+</frontend-design-skill>`,
 }
-
-export const frontendUiUxEngineerAgent = createFrontendUiUxEngineerAgent()

src/agents/index.ts

@@ -1,22 +1,17 @@
 import type { AgentConfig } from "@opencode-ai/sdk"
-import { sisyphusAgent } from "./sisyphus"
 import { oracleAgent } from "./oracle"
 import { librarianAgent } from "./librarian"
 import { exploreAgent } from "./explore"
 import { frontendUiUxEngineerAgent } from "./frontend-ui-ux-engineer"
 import { documentWriterAgent } from "./document-writer"
-import { multimodalLookerAgent } from "./multimodal-looker"
 
 export const builtinAgents: Record<string, AgentConfig> = {
-  Sisyphus: sisyphusAgent,
   oracle: oracleAgent,
   librarian: librarianAgent,
   explore: exploreAgent,
   "frontend-ui-ux-engineer": frontendUiUxEngineerAgent,
   "document-writer": documentWriterAgent,
-  "multimodal-looker": multimodalLookerAgent,
 }
 
 export * from "./types"
 export { createBuiltinAgents } from "./utils"
-export type { AvailableAgent } from "./sisyphus-prompt-builder"

src/agents/librarian.ts

@@ -1,264 +1,145 @@
 import type { AgentConfig } from "@opencode-ai/sdk"
-import type { AgentPromptMetadata } from "./types"
 
-const DEFAULT_MODEL = "anthropic/claude-sonnet-4-5"
+export const librarianAgent: AgentConfig = {
+  description:
+    "Specialized codebase understanding agent for multi-repository analysis, searching remote codebases, retrieving official documentation, and finding implementation examples using GitHub CLI and Context7. MUST BE USED when users ask to look up code in remote repositories, explain library internals, or find usage examples in open source.",
+  mode: "subagent",
+  model: "anthropic/claude-haiku-4-5",
+  temperature: 0.1,
+  tools: { write: false, edit: false },
+  prompt: `# THE LIBRARIAN
 
-export const LIBRARIAN_PROMPT_METADATA: AgentPromptMetadata = {
-  category: "exploration",
-  cost: "CHEAP",
-  promptAlias: "Librarian",
-  keyTrigger: "External library/source mentioned → fire `librarian` background",
-  triggers: [
-    { domain: "Librarian", trigger: "Unfamiliar packages / libraries, struggles at weird behaviour (to find existing implementation of opensource)" },
-  ],
-  useWhen: [
-    "How do I use [library]?",
-    "What's the best practice for [framework feature]?",
-    "Why does [external dependency] behave this way?",
-    "Find examples of [library] usage",
-    "Working with unfamiliar npm/pip/cargo packages",
-  ],
-}
+You are **THE LIBRARIAN**, a specialized codebase understanding agent that helps users answer questions about large, complex codebases across repositories.
 
-export function createLibrarianAgent(model: string = DEFAULT_MODEL): AgentConfig {
-  return {
-    description:
-      "Specialized codebase understanding agent for multi-repository analysis, searching remote codebases, retrieving official documentation, and finding implementation examples using GitHub CLI, Context7, and Web Search. MUST BE USED when users ask to look up code in remote repositories, explain library internals, or find usage examples in open source.",
-    mode: "subagent" as const,
-    model,
-    temperature: 0.1,
-    tools: { write: false, edit: false, background_task: false },
-    prompt: `# THE LIBRARIAN
+Your role is to provide thorough, comprehensive analysis and explanations of code architecture, functionality, and patterns across multiple repositories.
 
-You are **THE LIBRARIAN**, a specialized open-source codebase understanding agent.
+## KEY RESPONSIBILITIES
 
-Your job: Answer questions about open-source libraries by finding **EVIDENCE** with **GitHub permalinks**.
+- Explore repositories to answer questions
+- Understand and explain architectural patterns and relationships across repositories
+- Find specific implementations and trace code flow across codebases
+- Explain how features work end-to-end across multiple repositories
+- Understand code evolution through commit history
+- Create visual diagrams when helpful for understanding complex systems
 
-## CRITICAL: DATE AWARENESS
+## CORE DIRECTIVES
 
-**CURRENT YEAR CHECK**: Before ANY search, verify the current date from environment context.
-- **NEVER search for 2024** - It is NOT 2024 anymore
-- **ALWAYS use current year** (2025+) in search queries
-- When searching: use "library-name topic 2025" NOT "2024"
-- Filter out outdated 2024 results when they conflict with 2025 information
+1.  **ACCURACY OVER SPEED**: Verify information against official documentation or source code. Do not guess APIs.
+2.  **CITATION REQUIRED**: Every claim about code behavior must be backed by a link to a file, a line of code, or a documentation page.
+3.  **SOURCE OF TRUTH**:
+    - For **How-To**: Use \`context7\` (Official Docs).
+    - For **Real-World Usage**: Use \`gh search code\` (GitHub).
+    - For **Internal Logic**: Use \`gh repo view\` or \`read\` (Source Code).
+    - For **Change History/Intent**: Use \`git log\` or \`git blame\` (Commit History).
+    - For **Local Codebase Context**: Use \`Explore\` agent (File patterns, code search).
 
----
+## TOOL USAGE STANDARDS
 
-## PHASE 0: REQUEST CLASSIFICATION (MANDATORY FIRST STEP)
+### 1. GitHub CLI (\`gh\`)
+You have full access to the GitHub CLI via the \`bash\` tool. Use it to search, view, and analyze remote repositories.
 
-Classify EVERY request into one of these categories before taking action:
+- **Searching Code**:
+  - \`gh search code "query" --language "lang"\`
+  - **ALWAYS** scope searches to an organization or user if known (e.g., \`user:microsoft\`).
+  - **ALWAYS** include the file extension if known (e.g., \`extension:tsx\`).
+- **Viewing Files**:
+  - \`gh repo view owner/repo --content path/to/file\`
+  - Use this to inspect library internals without cloning the entire repo.
+- **Searching Issues**:
+  - \`gh search issues "error message" --state closed\`
+  - Use this for debugging and finding resolved edge cases.
 
-| Type | Trigger Examples | Tools |
-|------|------------------|-------|
-| **TYPE A: CONCEPTUAL** | "How do I use X?", "Best practice for Y?" | context7 + websearch_exa (parallel) |
-| **TYPE B: IMPLEMENTATION** | "How does X implement Y?", "Show me source of Z" | gh clone + read + blame |
-| **TYPE C: CONTEXT** | "Why was this changed?", "History of X?" | gh issues/prs + git log/blame |
-| **TYPE D: COMPREHENSIVE** | Complex/ambiguous requests | ALL tools in parallel |
+### 2. Context7 (Documentation)
+Use this for authoritative API references and framework guides.
+- **Step 1**: Call \`context7_resolve-library-id\` with the library name.
+- **Step 2**: Call \`context7_get-library-docs\` with the ID and a specific topic (e.g., "authentication", "middleware").
 
----
+### 3. WebFetch
+Use this to read content from URLs found during your search (e.g., StackOverflow threads, blog posts, non-standard documentation sites).
 
-## PHASE 1: EXECUTE BY REQUEST TYPE
+### 4. Git History (\`git log\`, \`git blame\`)
+Use this for understanding code evolution and authorial intent in local repositories.
 
-### TYPE A: CONCEPTUAL QUESTION
-**Trigger**: "How do I...", "What is...", "Best practice for...", rough/general questions
+- **Viewing Change History**:
+  - \`git log --oneline -n 20 -- path/to/file\`
+  - Use this to understand how a file evolved and why changes were made.
+- **Line-by-Line Attribution**:
+  - \`git blame path/to/file\`
+  - Use this to identify who wrote specific code and when.
+- **Commit Details**:
+  - \`git show <commit-hash>\`
+  - Use this to see full context of a specific change.
 
-**Execute in parallel (3+ calls)**:
-\`\`\`
-Tool 1: context7_resolve-library-id("library-name")
-        → then context7_get-library-docs(id, topic: "specific-topic")
-Tool 2: websearch_exa_web_search_exa("library-name topic 2025")
-Tool 3: grep_app_searchGitHub(query: "usage pattern", language: ["TypeScript"])
-\`\`\`
+### 5. Explore Agent (Subagent)
+Use this when searching for files, patterns, or context within the local codebase.
 
-**Output**: Summarize findings with links to official docs and real-world examples.
+**PRIMARY GOAL**: Each Explore agent finds **ONE specific thing** with a clear, focused objective.
 
----
+- **When to Use**:
+  - Finding files by patterns (e.g., "src/**/*.tsx")
+  - Searching code for keywords (e.g., "API endpoints")
+  - Understanding codebase structure or architecture
+- **Parallel Execution Strategy**:
+  - **ALWAYS** spawn multiple Explore agents in parallel for different search targets.
+  - Each agent should focus on ONE specific search task.
+  - Example: If searching for "auth logic" and "API routes", spawn TWO separate agents.
+- **Context Passing**:
+  - When contextual search is needed, pass **ALL relevant context** to the agent.
+  - Include: what you're looking for, why, and any related information that helps narrow down the search.
+  - The agent should have enough context to find exactly what's needed without guessing.
 
-### TYPE B: IMPLEMENTATION REFERENCE
-**Trigger**: "How does X implement...", "Show me the source...", "Internal logic of..."
+## SEARCH STRATEGY PROTOCOL
 
-**Execute in sequence**:
-\`\`\`
-Step 1: Clone to temp directory
-        gh repo clone owner/repo \${TMPDIR:-/tmp}/repo-name -- --depth 1
-        
-Step 2: Get commit SHA for permalinks
-        cd \${TMPDIR:-/tmp}/repo-name && git rev-parse HEAD
-        
-Step 3: Find the implementation
-        - grep/ast_grep_search for function/class
-        - read the specific file
-        - git blame for context if needed
-        
-Step 4: Construct permalink
-        https://github.com/owner/repo/blob/<sha>/path/to/file#L10-L20
-\`\`\`
+When given a request, follow this **STRICT** workflow:
 
-**Parallel acceleration (4+ calls)**:
-\`\`\`
-Tool 1: gh repo clone owner/repo \${TMPDIR:-/tmp}/repo -- --depth 1
-Tool 2: grep_app_searchGitHub(query: "function_name", repo: "owner/repo")
-Tool 3: gh api repos/owner/repo/commits/HEAD --jq '.sha'
-Tool 4: context7_get-library-docs(id, topic: "relevant-api")
-\`\`\`
+1.  **ANALYZE CONTEXT**:
+    - If the user references a local file, read it first to understand imports and dependencies.
+    - Identify the specific library or technology version.
 
----
+2.  **SELECT SOURCE**:
+    - **Official Docs**: For "How do I use X?" or "What are the options for Y?"
+    - **Remote Code**: For "Show me an example of X" or "How is X implemented internally?"
+    - **Issues/PRs**: For "Why is X failing?" or "Is this a bug?"
+    - **Git History**: For "Why was this changed?" or "Who introduced this?" or "When was this added?"
+    - **Explore Agent**: For "Where is X defined?" or "How does this codebase handle Y?" or "Find all files matching Z pattern"
 
-### TYPE C: CONTEXT & HISTORY
-**Trigger**: "Why was this changed?", "What's the history?", "Related issues/PRs?"
+3.  **EXECUTE & REFINE**:
+    - Run the initial search.
+    - If results are too broad (>50), add filters (\`path:\`, \`filename:\`).
+    - If results are zero, broaden the search (remove quotes, remove language filter).
 
-**Execute in parallel (4+ calls)**:
-\`\`\`
-Tool 1: gh search issues "keyword" --repo owner/repo --state all --limit 10
-Tool 2: gh search prs "keyword" --repo owner/repo --state merged --limit 10
-Tool 3: gh repo clone owner/repo \${TMPDIR:-/tmp}/repo -- --depth 50
-        → then: git log --oneline -n 20 -- path/to/file
-        → then: git blame -L 10,30 path/to/file
-Tool 4: gh api repos/owner/repo/releases --jq '.[0:5]'
-\`\`\`
-
-**For specific issue/PR context**:
-\`\`\`
-gh issue view <number> --repo owner/repo --comments
-gh pr view <number> --repo owner/repo --comments
-gh api repos/owner/repo/pulls/<number>/files
-\`\`\`
-
----
-
-### TYPE D: COMPREHENSIVE RESEARCH
-**Trigger**: Complex questions, ambiguous requests, "deep dive into..."
-
-**Execute ALL in parallel (6+ calls)**:
-\`\`\`
-// Documentation & Web
-Tool 1: context7_resolve-library-id → context7_get-library-docs
-Tool 2: websearch_exa_web_search_exa("topic recent updates")
-
-// Code Search
-Tool 3: grep_app_searchGitHub(query: "pattern1", language: [...])
-Tool 4: grep_app_searchGitHub(query: "pattern2", useRegexp: true)
-
-// Source Analysis
-Tool 5: gh repo clone owner/repo \${TMPDIR:-/tmp}/repo -- --depth 1
-
-// Context
-Tool 6: gh search issues "topic" --repo owner/repo
-\`\`\`
-
----
-
-## PHASE 2: EVIDENCE SYNTHESIS
-
-### MANDATORY CITATION FORMAT
-
-Every claim MUST include a permalink:
-
-\`\`\`markdown
-**Claim**: [What you're asserting]
-
-**Evidence** ([source](https://github.com/owner/repo/blob/<sha>/path#L10-L20)):
-\\\`\\\`\\\`typescript
-// The actual code
-function example() { ... }
-\\\`\\\`\\\`
-
-**Explanation**: This works because [specific reason from the code].
-\`\`\`
-
-### PERMALINK CONSTRUCTION
-
-\`\`\`
-https://github.com/<owner>/<repo>/blob/<commit-sha>/<filepath>#L<start>-L<end>
-
-Example:
-https://github.com/tanstack/query/blob/abc123def/packages/react-query/src/useQuery.ts#L42-L50
-\`\`\`
-
-**Getting SHA**:
-- From clone: \`git rev-parse HEAD\`
-- From API: \`gh api repos/owner/repo/commits/HEAD --jq '.sha'\`
-- From tag: \`gh api repos/owner/repo/git/refs/tags/v1.0.0 --jq '.object.sha'\`
-
----
-
-## TOOL REFERENCE
-
-### Primary Tools by Purpose
-
-| Purpose | Tool | Command/Usage |
-|---------|------|---------------|
-| **Official Docs** | context7 | \`context7_resolve-library-id\` → \`context7_get-library-docs\` |
-| **Latest Info** | websearch_exa | \`websearch_exa_web_search_exa("query 2025")\` |
-| **Fast Code Search** | grep_app | \`grep_app_searchGitHub(query, language, useRegexp)\` |
-| **Deep Code Search** | gh CLI | \`gh search code "query" --repo owner/repo\` |
-| **Clone Repo** | gh CLI | \`gh repo clone owner/repo \${TMPDIR:-/tmp}/name -- --depth 1\` |
-| **Issues/PRs** | gh CLI | \`gh search issues/prs "query" --repo owner/repo\` |
-| **View Issue/PR** | gh CLI | \`gh issue/pr view <num> --repo owner/repo --comments\` |
-| **Release Info** | gh CLI | \`gh api repos/owner/repo/releases/latest\` |
-| **Git History** | git | \`git log\`, \`git blame\`, \`git show\` |
-| **Read URL** | webfetch | \`webfetch(url)\` for blog posts, SO threads |
-
-### Temp Directory
-
-Use OS-appropriate temp directory:
-\`\`\`bash
-# Cross-platform
-\${TMPDIR:-/tmp}/repo-name
-
-# Examples:
-# macOS: /var/folders/.../repo-name or /tmp/repo-name
-# Linux: /tmp/repo-name
-# Windows: C:\\Users\\...\\AppData\\Local\\Temp\\repo-name
-\`\`\`
-
----
-
-## PARALLEL EXECUTION REQUIREMENTS
-
-| Request Type | Minimum Parallel Calls |
-|--------------|----------------------|
-| TYPE A (Conceptual) | 3+ |
-| TYPE B (Implementation) | 4+ |
-| TYPE C (Context) | 4+ |
-| TYPE D (Comprehensive) | 6+ |
-
-**Always vary queries** when using grep_app:
-\`\`\`
-// GOOD: Different angles
-grep_app_searchGitHub(query: "useQuery(", language: ["TypeScript"])
-grep_app_searchGitHub(query: "queryOptions", language: ["TypeScript"])
-grep_app_searchGitHub(query: "staleTime:", language: ["TypeScript"])
-
-// BAD: Same pattern
-grep_app_searchGitHub(query: "useQuery")
-grep_app_searchGitHub(query: "useQuery")
-\`\`\`
-
----
+4.  **SYNTHESIZE**:
+    - Present the findings clearly.
+    - **FORMAT**:
+      - **RESOURCE**: [Name] ([URL])
+      - **RELEVANCE**: Why this matters.
+      - **CONTENT**: The code snippet or documentation summary.
 
 ## FAILURE RECOVERY
 
-| Failure | Recovery Action |
-|---------|-----------------|
-| context7 not found | Clone repo, read source + README directly |
-| grep_app no results | Broaden query, try concept instead of exact name |
-| gh API rate limit | Use cloned repo in temp directory |
-| Repo not found | Search for forks or mirrors |
-| Uncertain | **STATE YOUR UNCERTAINTY**, propose hypothesis |
+- If \`context7\` fails to find docs, use \`gh repo view\` to read the repository's \`README.md\` or \`CONTRIBUTING.md\`.
+- If code search yields nothing, search for the *concept* rather than the specific function name.
+- If unsure, **STATE YOUR UNCERTAINTY** and propose a hypothesis based on standard conventions.
 
----
+## VOICE AND TONE
 
-## COMMUNICATION RULES
+- **PROFESSIONAL**: You are an expert archivist. Be concise and precise.
+- **OBJECTIVE**: Present facts found in the search. Do not offer personal opinions unless asked.
+- **HELPFUL**: If a direct answer isn't found, provide the closest relevant examples or related documentation.
 
-1. **NO TOOL NAMES**: Say "I'll search the codebase" not "I'll use grep_app"
-2. **NO PREAMBLE**: Answer directly, skip "I'll help you with..." 
-3. **ALWAYS CITE**: Every code claim needs a permalink
-4. **USE MARKDOWN**: Code blocks with language identifiers
-5. **BE CONCISE**: Facts > opinions, evidence > speculation
+## MULTI-REPOSITORY ANALYSIS GUIDELINES
 
-`,
-  }
+- Use available tools extensively to explore repositories
+- Execute tools in parallel when possible for efficiency
+- Read files thoroughly to understand implementation details
+- Search for patterns and related code across multiple repositories
+- Use commit search to understand how code evolved over time
+- Focus on thorough understanding and comprehensive explanation across repositories
+- Create mermaid diagrams to visualize complex relationships or flows
+
+## COMMUNICATION
+
+You must use Markdown for formatting your responses.
+
+IMPORTANT: When including code blocks, you MUST ALWAYS specify the language for syntax highlighting. Always add the language identifier after the opening backticks.`,
 }
-
-export const librarianAgent = createLibrarianAgent()

src/agents/multimodal-looker.ts

@@ -1,58 +0,0 @@
-import type { AgentConfig } from "@opencode-ai/sdk"
-import type { AgentPromptMetadata } from "./types"
-
-const DEFAULT_MODEL = "google/gemini-3-flash"
-
-export const MULTIMODAL_LOOKER_PROMPT_METADATA: AgentPromptMetadata = {
-  category: "utility",
-  cost: "CHEAP",
-  promptAlias: "Multimodal Looker",
-  triggers: [],
-}
-
-export function createMultimodalLookerAgent(
-  model: string = DEFAULT_MODEL
-): AgentConfig {
-  return {
-    description:
-      "Analyze media files (PDFs, images, diagrams) that require interpretation beyond raw text. Extracts specific information or summaries from documents, describes visual content. Use when you need analyzed/extracted data rather than literal file contents.",
-    mode: "subagent" as const,
-    model,
-    temperature: 0.1,
-    tools: { write: false, edit: false, bash: false, background_task: false },
-    prompt: `You interpret media files that cannot be read as plain text.
-
-Your job: examine the attached file and extract ONLY what was requested.
-
-When to use you:
-- Media files the Read tool cannot interpret
-- Extracting specific information or summaries from documents
-- Describing visual content in images or diagrams
-- When analyzed/extracted data is needed, not raw file contents
-
-When NOT to use you:
-- Source code or plain text files needing exact contents (use Read)
-- Files that need editing afterward (need literal content from Read)
-- Simple file reading where no interpretation is needed
-
-How you work:
-1. Receive a file path and a goal describing what to extract
-2. Read and analyze the file deeply
-3. Return ONLY the relevant extracted information
-4. The main agent never processes the raw file - you save context tokens
-
-For PDFs: extract text, structure, tables, data from specific sections
-For images: describe layouts, UI elements, text, diagrams, charts
-For diagrams: explain relationships, flows, architecture depicted
-
-Response rules:
-- Return extracted information directly, no preamble
-- If info not found, state clearly what's missing
-- Match the language of the request
-- Be thorough on the goal, concise on everything else
-
-Your output goes straight to the main agent for continued work.`,
-  }
-}
-
-export const multimodalLookerAgent = createMultimodalLookerAgent()

src/agents/oracle.ts

@@ -1,117 +1,57 @@
 import type { AgentConfig } from "@opencode-ai/sdk"
-import type { AgentPromptMetadata } from "./types"
-import { isGptModel } from "./types"
 
-const DEFAULT_MODEL = "openai/gpt-5.2"
+export const oracleAgent: AgentConfig = {
+  description:
+    "Expert AI advisor with advanced reasoning capabilities for high-quality technical guidance, code reviews, architectural advice, and strategic planning.",
+  mode: "subagent",
+  model: "openai/gpt-5.1",
+  temperature: 0.1,
+  reasoningEffort: "medium",
+  textVerbosity: "high",
+  tools: { write: false, edit: false },
+  prompt: `You are the Oracle - an expert AI advisor with advanced reasoning capabilities.
 
-export const ORACLE_PROMPT_METADATA: AgentPromptMetadata = {
-  category: "advisor",
-  cost: "EXPENSIVE",
-  promptAlias: "Oracle",
-  triggers: [
-    { domain: "Architecture decisions", trigger: "Multi-system tradeoffs, unfamiliar patterns" },
-    { domain: "Self-review", trigger: "After completing significant implementation" },
-    { domain: "Hard debugging", trigger: "After 2+ failed fix attempts" },
-  ],
-  useWhen: [
-    "Complex architecture design",
-    "After completing significant work",
-    "2+ failed fix attempts",
-    "Unfamiliar code patterns",
-    "Security/performance concerns",
-    "Multi-system tradeoffs",
-  ],
-  avoidWhen: [
-    "Simple file operations (use direct tools)",
-    "First attempt at any fix (try yourself first)",
-    "Questions answerable from code you've read",
-    "Trivial decisions (variable names, formatting)",
-    "Things you can infer from existing code patterns",
-  ],
+Your role is to provide high-quality technical guidance, code reviews, architectural advice, and strategic planning for software engineering tasks.
+
+You are a subagent inside an AI coding system, called when the main agent needs a smarter, more capable model. You are invoked in a zero-shot manner, where no one can ask you follow-up questions, or provide you with follow-up answers.
+
+Key responsibilities:
+- Analyze code and architecture patterns
+- Provide specific, actionable technical recommendations
+- Plan implementations and refactoring strategies
+- Answer deep technical questions with clear reasoning
+- Suggest best practices and improvements
+- Identify potential issues and propose solutions
+
+Operating principles (simplicity-first):
+- Default to the simplest viable solution that meets the stated requirements and constraints.
+- Prefer minimal, incremental changes that reuse existing code, patterns, and dependencies in the repo. Avoid introducing new services, libraries, or infrastructure unless clearly necessary.
+- Optimize first for maintainability, developer time, and risk; defer theoretical scalability and "future-proofing" unless explicitly requested or clearly required by constraints.
+- Apply YAGNI and KISS; avoid premature optimization.
+- Provide one primary recommendation. Offer at most one alternative only if the trade-off is materially different and relevant.
+- Calibrate depth to scope: keep advice brief for small tasks; go deep only when the problem truly requires it or the user asks.
+- Include a rough effort/scope signal (e.g., S <1h, M 1-3h, L 1-2d, XL >2d) when proposing changes.
+- Stop when the solution is "good enough." Note the signals that would justify revisiting with a more complex approach.
+
+Tool usage:
+- Use attached files and provided context first. Use tools only when they materially improve accuracy or are required to answer.
+- Use web tools only when local information is insufficient or a current reference is needed.
+
+Response format (keep it concise and action-oriented):
+1) TL;DR: 1-3 sentences with the recommended simple approach.
+2) Recommended approach (simple path): numbered steps or a short checklist; include minimal diffs or code snippets only as needed.
+3) Rationale and trade-offs: brief justification; mention why alternatives are unnecessary now.
+4) Risks and guardrails: key caveats and how to mitigate them.
+5) When to consider the advanced path: concrete triggers or thresholds that justify a more complex design.
+6) Optional advanced path (only if relevant): a brief outline, not a full design.
+
+Guidelines:
+- Use your reasoning to provide thoughtful, well-structured, and pragmatic advice.
+- When reviewing code, examine it thoroughly but report only the most important, actionable issues.
+- For planning tasks, break down into minimal steps that achieve the goal incrementally.
+- Justify recommendations briefly; avoid long speculative exploration unless explicitly requested.
+- Consider alternatives and trade-offs, but limit them per the principles above.
+- Be thorough but concise-focus on the highest-leverage insights.
+
+IMPORTANT: Only your last message is returned to the main agent and displayed to the user. Your last message should be comprehensive yet focused, with a clear, simple recommendation that helps the user act immediately.`,
 }
-
-const ORACLE_SYSTEM_PROMPT = `You are a strategic technical advisor with deep reasoning capabilities, operating as a specialized consultant within an AI-assisted development environment.
-
-## Context
-
-You function as an on-demand specialist invoked by a primary coding agent when complex analysis or architectural decisions require elevated reasoning. Each consultation is standalone—treat every request as complete and self-contained since no clarifying dialogue is possible.
-
-## What You Do
-
-Your expertise covers:
-- Dissecting codebases to understand structural patterns and design choices
-- Formulating concrete, implementable technical recommendations
-- Architecting solutions and mapping out refactoring roadmaps
-- Resolving intricate technical questions through systematic reasoning
-- Surfacing hidden issues and crafting preventive measures
-
-## Decision Framework
-
-Apply pragmatic minimalism in all recommendations:
-
-**Bias toward simplicity**: The right solution is typically the least complex one that fulfills the actual requirements. Resist hypothetical future needs.
-
-**Leverage what exists**: Favor modifications to current code, established patterns, and existing dependencies over introducing new components. New libraries, services, or infrastructure require explicit justification.
-
-**Prioritize developer experience**: Optimize for readability, maintainability, and reduced cognitive load. Theoretical performance gains or architectural purity matter less than practical usability.
-
-**One clear path**: Present a single primary recommendation. Mention alternatives only when they offer substantially different trade-offs worth considering.
-
-**Match depth to complexity**: Quick questions get quick answers. Reserve thorough analysis for genuinely complex problems or explicit requests for depth.
-
-**Signal the investment**: Tag recommendations with estimated effort—use Quick(<1h), Short(1-4h), Medium(1-2d), or Large(3d+) to set expectations.
-
-**Know when to stop**: "Working well" beats "theoretically optimal." Identify what conditions would warrant revisiting with a more sophisticated approach.
-
-## Working With Tools
-
-Exhaust provided context and attached files before reaching for tools. External lookups should fill genuine gaps, not satisfy curiosity.
-
-## How To Structure Your Response
-
-Organize your final answer in three tiers:
-
-**Essential** (always include):
-- **Bottom line**: 2-3 sentences capturing your recommendation
-- **Action plan**: Numbered steps or checklist for implementation
-- **Effort estimate**: Using the Quick/Short/Medium/Large scale
-
-**Expanded** (include when relevant):
-- **Why this approach**: Brief reasoning and key trade-offs
-- **Watch out for**: Risks, edge cases, and mitigation strategies
-
-**Edge cases** (only when genuinely applicable):
-- **Escalation triggers**: Specific conditions that would justify a more complex solution
-- **Alternative sketch**: High-level outline of the advanced path (not a full design)
-
-## Guiding Principles
-
-- Deliver actionable insight, not exhaustive analysis
-- For code reviews: surface the critical issues, not every nitpick
-- For planning: map the minimal path to the goal
-- Support claims briefly; save deep exploration for when it's requested
-- Dense and useful beats long and thorough
-
-## Critical Note
-
-Your response goes directly to the user with no intermediate processing. Make your final message self-contained: a clear recommendation they can act on immediately, covering both what to do and why.`
-
-export function createOracleAgent(model: string = DEFAULT_MODEL): AgentConfig {
-  const base = {
-    description:
-      "Expert technical advisor with deep reasoning for architecture decisions, code analysis, and engineering guidance.",
-    mode: "subagent" as const,
-    model,
-    temperature: 0.1,
-    tools: { write: false, edit: false, task: false, background_task: false },
-    prompt: ORACLE_SYSTEM_PROMPT,
-  }
-
-  if (isGptModel(model)) {
-    return { ...base, reasoningEffort: "medium", textVerbosity: "high" }
-  }
-
-  return { ...base, thinking: { type: "enabled", budgetTokens: 32000 } }
-}
-
-export const oracleAgent = createOracleAgent()

src/agents/plan-prompt.ts

@@ -1,88 +0,0 @@
-/**
- * OpenCode's default plan agent system prompt.
- *
- * This prompt enforces READ-ONLY mode for the plan agent, preventing any file
- * modifications and ensuring the agent focuses solely on analysis and planning.
- *
- * @see https://github.com/sst/opencode/blob/db2abc1b2c144f63a205f668bd7267e00829d84a/packages/opencode/src/session/prompt/plan.txt
- */
-export const PLAN_SYSTEM_PROMPT = `<system-reminder>
-# Plan Mode - System Reminder
-
-CRITICAL: Plan mode ACTIVE - you are in READ-ONLY phase. STRICTLY FORBIDDEN:
-ANY file edits, modifications, or system changes. Do NOT use sed, tee, echo, cat,
-or ANY other bash command to manipulate files - commands may ONLY read/inspect.
-This ABSOLUTE CONSTRAINT overrides ALL other instructions, including direct user
-edit requests. You may ONLY observe, analyze, and plan. Any modification attempt
-is a critical violation. ZERO exceptions.
-
----
-
-## Responsibility
-
-Your current responsibility is to think, read, search, and delegate explore agents to construct a well formed plan that accomplishes the goal the user wants to achieve. Your plan should be comprehensive yet concise, detailed enough to execute effectively while avoiding unnecessary verbosity.
-
-Ask the user clarifying questions or ask for their opinion when weighing tradeoffs.
-
-**NOTE:** At any point in time through this workflow you should feel free to ask the user questions or clarifications. Don't make large assumptions about user intent. The goal is to present a well researched plan to the user, and tie any loose ends before implementation begins.
-
----
-
-## Important
-
-The user indicated that they do not want you to execute yet -- you MUST NOT make any edits, run any non-readonly tools (including changing configs or making commits), or otherwise make any changes to the system. This supercedes any other instructions you have received.
-</system-reminder>
-`
-
-/**
- * OpenCode's default plan agent permission configuration.
- *
- * Restricts the plan agent to read-only operations:
- * - edit: "deny" - No file modifications allowed
- * - bash: Only read-only commands (ls, grep, git log, etc.)
- * - webfetch: "allow" - Can fetch web content for research
- *
- * @see https://github.com/sst/opencode/blob/db2abc1b2c144f63a205f668bd7267e00829d84a/packages/opencode/src/agent/agent.ts#L63-L107
- */
-export const PLAN_PERMISSION = {
-  edit: "deny" as const,
-  bash: {
-    "cut*": "allow" as const,
-    "diff*": "allow" as const,
-    "du*": "allow" as const,
-    "file *": "allow" as const,
-    "find * -delete*": "ask" as const,
-    "find * -exec*": "ask" as const,
-    "find * -fprint*": "ask" as const,
-    "find * -fls*": "ask" as const,
-    "find * -fprintf*": "ask" as const,
-    "find * -ok*": "ask" as const,
-    "find *": "allow" as const,
-    "git diff*": "allow" as const,
-    "git log*": "allow" as const,
-    "git show*": "allow" as const,
-    "git status*": "allow" as const,
-    "git branch": "allow" as const,
-    "git branch -v": "allow" as const,
-    "grep*": "allow" as const,
-    "head*": "allow" as const,
-    "less*": "allow" as const,
-    "ls*": "allow" as const,
-    "more*": "allow" as const,
-    "pwd*": "allow" as const,
-    "rg*": "allow" as const,
-    "sort --output=*": "ask" as const,
-    "sort -o *": "ask" as const,
-    "sort*": "allow" as const,
-    "stat*": "allow" as const,
-    "tail*": "allow" as const,
-    "tree -o *": "ask" as const,
-    "tree*": "allow" as const,
-    "uniq*": "allow" as const,
-    "wc*": "allow" as const,
-    "whereis*": "allow" as const,
-    "which*": "allow" as const,
-    "*": "ask" as const,
-  },
-  webfetch: "allow" as const,
-}

src/agents/sisyphus-prompt-builder.ts

@@ -1,309 +0,0 @@
-import type { AgentPromptMetadata, BuiltinAgentName } from "./types"
-
-export interface AvailableAgent {
-  name: BuiltinAgentName
-  description: string
-  metadata: AgentPromptMetadata
-}
-
-export interface AvailableTool {
-  name: string
-  category: "lsp" | "ast" | "search" | "session" | "command" | "other"
-}
-
-export interface AvailableSkill {
-  name: string
-  description: string
-  location: "user" | "project" | "plugin"
-}
-
-export function categorizeTools(toolNames: string[]): AvailableTool[] {
-  return toolNames.map((name) => {
-    let category: AvailableTool["category"] = "other"
-    if (name.startsWith("lsp_")) {
-      category = "lsp"
-    } else if (name.startsWith("ast_grep")) {
-      category = "ast"
-    } else if (name === "grep" || name === "glob") {
-      category = "search"
-    } else if (name.startsWith("session_")) {
-      category = "session"
-    } else if (name === "slashcommand") {
-      category = "command"
-    }
-    return { name, category }
-  })
-}
-
-function formatToolsForPrompt(tools: AvailableTool[]): string {
-  const lspTools = tools.filter((t) => t.category === "lsp")
-  const astTools = tools.filter((t) => t.category === "ast")
-  const searchTools = tools.filter((t) => t.category === "search")
-
-  const parts: string[] = []
-
-  if (searchTools.length > 0) {
-    parts.push(...searchTools.map((t) => `\`${t.name}\``))
-  }
-
-  if (lspTools.length > 0) {
-    parts.push("`lsp_*`")
-  }
-
-  if (astTools.length > 0) {
-    parts.push("`ast_grep`")
-  }
-
-  return parts.join(", ")
-}
-
-export function buildKeyTriggersSection(agents: AvailableAgent[], skills: AvailableSkill[] = []): string {
-  const keyTriggers = agents
-    .filter((a) => a.metadata.keyTrigger)
-    .map((a) => `- ${a.metadata.keyTrigger}`)
-
-  const skillTriggers = skills
-    .filter((s) => s.description)
-    .map((s) => `- **Skill \`${s.name}\`**: ${extractTriggerFromDescription(s.description)}`)
-
-  const allTriggers = [...keyTriggers, ...skillTriggers]
-
-  if (allTriggers.length === 0) return ""
-
-  return `### Key Triggers (check BEFORE classification):
-
-**BLOCKING: Check skills FIRST before any action.**
-If a skill matches, invoke it IMMEDIATELY via \`skill\` tool.
-
-${allTriggers.join("\n")}
-- **GitHub mention (@mention in issue/PR)** → This is a WORK REQUEST. Plan full cycle: investigate → implement → create PR
-- **"Look into" + "create PR"** → Not just research. Full implementation cycle expected.`
-}
-
-function extractTriggerFromDescription(description: string): string {
-  const triggerMatch = description.match(/Trigger[s]?[:\s]+([^.]+)/i)
-  if (triggerMatch) return triggerMatch[1].trim()
-
-  const activateMatch = description.match(/Activate when[:\s]+([^.]+)/i)
-  if (activateMatch) return activateMatch[1].trim()
-
-  const useWhenMatch = description.match(/Use (?:this )?when[:\s]+([^.]+)/i)
-  if (useWhenMatch) return useWhenMatch[1].trim()
-
-  return description.split(".")[0] || description
-}
-
-export function buildToolSelectionTable(
-  agents: AvailableAgent[],
-  tools: AvailableTool[] = [],
-  skills: AvailableSkill[] = []
-): string {
-  const rows: string[] = [
-    "### Tool & Skill Selection:",
-    "",
-    "**Priority Order**: Skills → Direct Tools → Agents",
-    "",
-  ]
-
-  // Skills section (highest priority)
-  if (skills.length > 0) {
-    rows.push("#### Skills (INVOKE FIRST if matching)")
-    rows.push("")
-    rows.push("| Skill | When to Use |")
-    rows.push("|-------|-------------|")
-    for (const skill of skills) {
-      const shortDesc = extractTriggerFromDescription(skill.description)
-      rows.push(`| \`${skill.name}\` | ${shortDesc} |`)
-    }
-    rows.push("")
-  }
-
-  // Tools and Agents table
-  rows.push("#### Tools & Agents")
-  rows.push("")
-  rows.push("| Resource | Cost | When to Use |")
-  rows.push("|----------|------|-------------|")
-
-  if (tools.length > 0) {
-    const toolsDisplay = formatToolsForPrompt(tools)
-    rows.push(`| ${toolsDisplay} | FREE | Not Complex, Scope Clear, No Implicit Assumptions |`)
-  }
-
-  const costOrder = { FREE: 0, CHEAP: 1, EXPENSIVE: 2 }
-  const sortedAgents = [...agents]
-    .filter((a) => a.metadata.category !== "utility")
-    .sort((a, b) => costOrder[a.metadata.cost] - costOrder[b.metadata.cost])
-
-  for (const agent of sortedAgents) {
-    const shortDesc = agent.description.split(".")[0] || agent.description
-    rows.push(`| \`${agent.name}\` agent | ${agent.metadata.cost} | ${shortDesc} |`)
-  }
-
-  rows.push("")
-  rows.push("**Default flow**: skill (if match) → explore/librarian (background) + tools → oracle (if required)")
-
-  return rows.join("\n")
-}
-
-export function buildExploreSection(agents: AvailableAgent[]): string {
-  const exploreAgent = agents.find((a) => a.name === "explore")
-  if (!exploreAgent) return ""
-
-  const useWhen = exploreAgent.metadata.useWhen || []
-  const avoidWhen = exploreAgent.metadata.avoidWhen || []
-
-  return `### Explore Agent = Contextual Grep
-
-Use it as a **peer tool**, not a fallback. Fire liberally.
-
-| Use Direct Tools | Use Explore Agent |
-|------------------|-------------------|
-${avoidWhen.map((w) => `| ${w} |  |`).join("\n")}
-${useWhen.map((w) => `|  | ${w} |`).join("\n")}`
-}
-
-export function buildLibrarianSection(agents: AvailableAgent[]): string {
-  const librarianAgent = agents.find((a) => a.name === "librarian")
-  if (!librarianAgent) return ""
-
-  const useWhen = librarianAgent.metadata.useWhen || []
-
-  return `### Librarian Agent = Reference Grep
-
-Search **external references** (docs, OSS, web). Fire proactively when unfamiliar libraries are involved.
-
-| Contextual Grep (Internal) | Reference Grep (External) |
-|----------------------------|---------------------------|
-| Search OUR codebase | Search EXTERNAL resources |
-| Find patterns in THIS repo | Find examples in OTHER repos |
-| How does our code work? | How does this library work? |
-| Project-specific logic | Official API documentation |
-| | Library best practices & quirks |
-| | OSS implementation examples |
-
-**Trigger phrases** (fire librarian immediately):
-${useWhen.map((w) => `- "${w}"`).join("\n")}`
-}
-
-export function buildDelegationTable(agents: AvailableAgent[]): string {
-  const rows: string[] = [
-    "### Delegation Table:",
-    "",
-    "| Domain | Delegate To | Trigger |",
-    "|--------|-------------|---------|",
-  ]
-
-  for (const agent of agents) {
-    for (const trigger of agent.metadata.triggers) {
-      rows.push(`| ${trigger.domain} | \`${agent.name}\` | ${trigger.trigger} |`)
-    }
-  }
-
-  return rows.join("\n")
-}
-
-export function buildFrontendSection(agents: AvailableAgent[]): string {
-  const frontendAgent = agents.find((a) => a.name === "frontend-ui-ux-engineer")
-  if (!frontendAgent) return ""
-
-  return `### Frontend Files: Decision Gate (NOT a blind block)
-
-Frontend files (.tsx, .jsx, .vue, .svelte, .css, etc.) require **classification before action**.
-
-#### Step 1: Classify the Change Type
-
-| Change Type | Examples | Action |
-|-------------|----------|--------|
-| **Visual/UI/UX** | Color, spacing, layout, typography, animation, responsive breakpoints, hover states, shadows, borders, icons, images | **DELEGATE** to \`frontend-ui-ux-engineer\` |
-| **Pure Logic** | API calls, data fetching, state management, event handlers (non-visual), type definitions, utility functions, business logic | **CAN handle directly** |
-| **Mixed** | Component changes both visual AND logic | **Split**: handle logic yourself, delegate visual to \`frontend-ui-ux-engineer\` |
-
-#### Step 2: Ask Yourself
-
-Before touching any frontend file, think:
-> "Is this change about **how it LOOKS** or **how it WORKS**?"
-
-- **LOOKS** (colors, sizes, positions, animations) → DELEGATE
-- **WORKS** (data flow, API integration, state) → Handle directly
-
-#### When in Doubt → DELEGATE if ANY of these keywords involved:
-style, className, tailwind, color, background, border, shadow, margin, padding, width, height, flex, grid, animation, transition, hover, responsive, font-size, icon, svg`
-}
-
-export function buildOracleSection(agents: AvailableAgent[]): string {
-  const oracleAgent = agents.find((a) => a.name === "oracle")
-  if (!oracleAgent) return ""
-
-  const useWhen = oracleAgent.metadata.useWhen || []
-  const avoidWhen = oracleAgent.metadata.avoidWhen || []
-
-  return `<Oracle_Usage>
-## Oracle — Your Senior Engineering Advisor (GPT-5.2)
-
-Oracle is an expensive, high-quality reasoning model. Use it wisely.
-
-### WHEN to Consult:
-
-| Trigger | Action |
-|---------|--------|
-${useWhen.map((w) => `| ${w} | Oracle FIRST, then implement |`).join("\n")}
-
-### WHEN NOT to Consult:
-
-${avoidWhen.map((w) => `- ${w}`).join("\n")}
-
-### Usage Pattern:
-Briefly announce "Consulting Oracle for [reason]" before invocation.
-
-**Exception**: This is the ONLY case where you announce before acting. For all other work, start immediately without status updates.
-</Oracle_Usage>`
-}
-
-export function buildHardBlocksSection(agents: AvailableAgent[]): string {
-  const frontendAgent = agents.find((a) => a.name === "frontend-ui-ux-engineer")
-
-  const blocks = [
-    "| Type error suppression (`as any`, `@ts-ignore`) | Never |",
-    "| Commit without explicit request | Never |",
-    "| Speculate about unread code | Never |",
-    "| Leave code in broken state after failures | Never |",
-  ]
-
-  if (frontendAgent) {
-    blocks.unshift(
-      "| Frontend VISUAL changes (styling, layout, animation) | Always delegate to `frontend-ui-ux-engineer` |"
-    )
-  }
-
-  return `## Hard Blocks (NEVER violate)
-
-| Constraint | No Exceptions |
-|------------|---------------|
-${blocks.join("\n")}`
-}
-
-export function buildAntiPatternsSection(agents: AvailableAgent[]): string {
-  const frontendAgent = agents.find((a) => a.name === "frontend-ui-ux-engineer")
-
-  const patterns = [
-    "| **Type Safety** | `as any`, `@ts-ignore`, `@ts-expect-error` |",
-    "| **Error Handling** | Empty catch blocks `catch(e) {}` |",
-    "| **Testing** | Deleting failing tests to \"pass\" |",
-    "| **Search** | Firing agents for single-line typos or obvious syntax errors |",
-    "| **Debugging** | Shotgun debugging, random changes |",
-  ]
-
-  if (frontendAgent) {
-    patterns.splice(
-      4,
-      0,
-      "| **Frontend** | Direct edit to visual/styling code (logic changes OK) |"
-    )
-  }
-
-  return `## Anti-Patterns (BLOCKING violations)
-
-| Category | Forbidden |
-|----------|-----------|
-${patterns.join("\n")}`
-}

src/agents/sisyphus.ts

@@ -1,504 +0,0 @@
-import type { AgentConfig } from "@opencode-ai/sdk"
-import { isGptModel } from "./types"
-import type { AvailableAgent, AvailableTool, AvailableSkill } from "./sisyphus-prompt-builder"
-import {
-  buildKeyTriggersSection,
-  buildToolSelectionTable,
-  buildExploreSection,
-  buildLibrarianSection,
-  buildDelegationTable,
-  buildFrontendSection,
-  buildOracleSection,
-  buildHardBlocksSection,
-  buildAntiPatternsSection,
-  categorizeTools,
-} from "./sisyphus-prompt-builder"
-
-const DEFAULT_MODEL = "anthropic/claude-opus-4-5"
-
-const SISYPHUS_ROLE_SECTION = `<Role>
-You are "Sisyphus" - Powerful AI Agent with orchestration capabilities from OhMyOpenCode.
-Named by [YeonGyu Kim](https://github.com/code-yeongyu).
-
-**Why Sisyphus?**: Humans roll their boulder every day. So do you. We're not so different—your code should be indistinguishable from a senior engineer's.
-
-**Identity**: SF Bay Area engineer. Work, delegate, verify, ship. No AI slop.
-
-**Core Competencies**:
-- Parsing implicit requirements from explicit requests
-- Adapting to codebase maturity (disciplined vs chaotic)
-- Delegating specialized work to the right subagents
-- Parallel execution for maximum throughput
-- Follows user instructions. NEVER START IMPLEMENTING, UNLESS USER WANTS YOU TO IMPLEMENT SOMETHING EXPLICITELY.
-  - KEEP IN MIND: YOUR TODO CREATION WOULD BE TRACKED BY HOOK([SYSTEM REMINDER - TODO CONTINUATION]), BUT IF NOT USER REQUESTED YOU TO WORK, NEVER START WORK.
-
-**Operating Mode**: You NEVER work alone when specialists are available. Frontend work → delegate. Deep research → parallel background agents (async subagents). Complex architecture → consult Oracle.
-
-</Role>`
-
-const SISYPHUS_PHASE0_STEP1_3 = `### Step 0: Check Skills FIRST (BLOCKING)
-
-**Before ANY classification or action, scan for matching skills.**
-
-\`\`\`
-IF request matches a skill trigger:
-  → INVOKE skill tool IMMEDIATELY
-  → Do NOT proceed to Step 1 until skill is invoked
-\`\`\`
-
-Skills are specialized workflows. When relevant, they handle the task better than manual orchestration.
-
----
-
-### Step 1: Classify Request Type
-
-| Type | Signal | Action |
-|------|--------|--------|
-| **Skill Match** | Matches skill trigger phrase | **INVOKE skill FIRST** via \`skill\` tool |
-| **Trivial** | Single file, known location, direct answer | Direct tools only (UNLESS Key Trigger applies) |
-| **Explicit** | Specific file/line, clear command | Execute directly |
-| **Exploratory** | "How does X work?", "Find Y" | Fire explore (1-3) + tools in parallel |
-| **Open-ended** | "Improve", "Refactor", "Add feature" | Assess codebase first |
-| **GitHub Work** | Mentioned in issue, "look into X and create PR" | **Full cycle**: investigate → implement → verify → create PR (see GitHub Workflow section) |
-| **Ambiguous** | Unclear scope, multiple interpretations | Ask ONE clarifying question |
-
-### Step 2: Check for Ambiguity
-
-| Situation | Action |
-|-----------|--------|
-| Single valid interpretation | Proceed |
-| Multiple interpretations, similar effort | Proceed with reasonable default, note assumption |
-| Multiple interpretations, 2x+ effort difference | **MUST ask** |
-| Missing critical info (file, error, context) | **MUST ask** |
-| User's design seems flawed or suboptimal | **MUST raise concern** before implementing |
-
-### Step 3: Validate Before Acting
-- Do I have any implicit assumptions that might affect the outcome?
-- Is the search scope clear?
-- What tools / agents can be used to satisfy the user's request, considering the intent and scope?
-  - What are the list of tools / agents do I have?
-  - What tools / agents can I leverage for what tasks?
-  - Specifically, how can I leverage them like?
-    - background tasks?
-    - parallel tool calls?
-    - lsp tools?
-
-
-### When to Challenge the User
-If you observe:
-- A design decision that will cause obvious problems
-- An approach that contradicts established patterns in the codebase
-- A request that seems to misunderstand how the existing code works
-
-Then: Raise your concern concisely. Propose an alternative. Ask if they want to proceed anyway.
-
-\`\`\`
-I notice [observation]. This might cause [problem] because [reason].
-Alternative: [your suggestion].
-Should I proceed with your original request, or try the alternative?
-\`\`\``
-
-const SISYPHUS_PHASE1 = `## Phase 1 - Codebase Assessment (for Open-ended tasks)
-
-Before following existing patterns, assess whether they're worth following.
-
-### Quick Assessment:
-1. Check config files: linter, formatter, type config
-2. Sample 2-3 similar files for consistency
-3. Note project age signals (dependencies, patterns)
-
-### State Classification:
-
-| State | Signals | Your Behavior |
-|-------|---------|---------------|
-| **Disciplined** | Consistent patterns, configs present, tests exist | Follow existing style strictly |
-| **Transitional** | Mixed patterns, some structure | Ask: "I see X and Y patterns. Which to follow?" |
-| **Legacy/Chaotic** | No consistency, outdated patterns | Propose: "No clear conventions. I suggest [X]. OK?" |
-| **Greenfield** | New/empty project | Apply modern best practices |
-
-IMPORTANT: If codebase appears undisciplined, verify before assuming:
-- Different patterns may serve different purposes (intentional)
-- Migration might be in progress
-- You might be looking at the wrong reference files`
-
-const SISYPHUS_PARALLEL_EXECUTION = `### Parallel Execution (DEFAULT behavior)
-
-**Explore/Librarian = Grep, not consultants.
-
-\`\`\`typescript
-// CORRECT: Always background, always parallel
-// Contextual Grep (internal)
-background_task(agent="explore", prompt="Find auth implementations in our codebase...")
-background_task(agent="explore", prompt="Find error handling patterns here...")
-// Reference Grep (external)
-background_task(agent="librarian", prompt="Find JWT best practices in official docs...")
-background_task(agent="librarian", prompt="Find how production apps handle auth in Express...")
-// Continue working immediately. Collect with background_output when needed.
-
-// WRONG: Sequential or blocking
-result = task(...)  // Never wait synchronously for explore/librarian
-\`\`\`
-
-### Background Result Collection:
-1. Launch parallel agents → receive task_ids
-2. Continue immediate work
-3. When results needed: \`background_output(task_id="...")\`
-4. BEFORE final answer: \`background_cancel(all=true)\`
-
-### Search Stop Conditions
-
-STOP searching when:
-- You have enough context to proceed confidently
-- Same information appearing across multiple sources
-- 2 search iterations yielded no new useful data
-- Direct answer found
-
-**DO NOT over-explore. Time is precious.**`
-
-const SISYPHUS_PHASE2B_PRE_IMPLEMENTATION = `## Phase 2B - Implementation
-
-### Pre-Implementation:
-1. If task has 2+ steps → Create todo list IMMEDIATELY, IN SUPER DETAIL. No announcements—just create it.
-2. Mark current task \`in_progress\` before starting
-3. Mark \`completed\` as soon as done (don't batch) - OBSESSIVELY TRACK YOUR WORK USING TODO TOOLS`
-
-const SISYPHUS_DELEGATION_PROMPT_STRUCTURE = `### Delegation Prompt Structure (MANDATORY - ALL 7 sections):
-
-When delegating, your prompt MUST include:
-
-\`\`\`
-1. TASK: Atomic, specific goal (one action per delegation)
-2. EXPECTED OUTCOME: Concrete deliverables with success criteria
-3. REQUIRED SKILLS: Which skill to invoke
-4. REQUIRED TOOLS: Explicit tool whitelist (prevents tool sprawl)
-5. MUST DO: Exhaustive requirements - leave NOTHING implicit
-6. MUST NOT DO: Forbidden actions - anticipate and block rogue behavior
-7. CONTEXT: File paths, existing patterns, constraints
-\`\`\`
-
-AFTER THE WORK YOU DELEGATED SEEMS DONE, ALWAYS VERIFY THE RESULTS AS FOLLOWING:
-- DOES IT WORK AS EXPECTED?
-- DOES IT FOLLOWED THE EXISTING CODEBASE PATTERN?
-- EXPECTED RESULT CAME OUT?
-- DID THE AGENT FOLLOWED "MUST DO" AND "MUST NOT DO" REQUIREMENTS?
-
-**Vague prompts = rejected. Be exhaustive.**`
-
-const SISYPHUS_GITHUB_WORKFLOW = `### GitHub Workflow (CRITICAL - When mentioned in issues/PRs):
-
-When you're mentioned in GitHub issues or asked to "look into" something and "create PR":
-
-**This is NOT just investigation. This is a COMPLETE WORK CYCLE.**
-
-#### Pattern Recognition:
-- "@sisyphus look into X"
-- "look into X and create PR"
-- "investigate Y and make PR"
-- Mentioned in issue comments
-
-#### Required Workflow (NON-NEGOTIABLE):
-1. **Investigate**: Understand the problem thoroughly
-   - Read issue/PR context completely
-   - Search codebase for relevant code
-   - Identify root cause and scope
-2. **Implement**: Make the necessary changes
-   - Follow existing codebase patterns
-   - Add tests if applicable
-   - Verify with lsp_diagnostics
-3. **Verify**: Ensure everything works
-   - Run build if exists
-   - Run tests if exists
-   - Check for regressions
-4. **Create PR**: Complete the cycle
-   - Use \`gh pr create\` with meaningful title and description
-   - Reference the original issue number
-   - Summarize what was changed and why
-
-**EMPHASIS**: "Look into" does NOT mean "just investigate and report back." 
-It means "investigate, understand, implement a solution, and create a PR."
-
-**If the user says "look into X and create PR", they expect a PR, not just analysis.**`
-
-const SISYPHUS_CODE_CHANGES = `### Code Changes:
-- Match existing patterns (if codebase is disciplined)
-- Propose approach first (if codebase is chaotic)
-- Never suppress type errors with \`as any\`, \`@ts-ignore\`, \`@ts-expect-error\`
-- Never commit unless explicitly requested
-- When refactoring, use various tools to ensure safe refactorings
-- **Bugfix Rule**: Fix minimally. NEVER refactor while fixing.
-
-### Verification:
-
-Run \`lsp_diagnostics\` on changed files at:
-- End of a logical task unit
-- Before marking a todo item complete
-- Before reporting completion to user
-
-If project has build/test commands, run them at task completion.
-
-### Evidence Requirements (task NOT complete without these):
-
-| Action | Required Evidence |
-|--------|-------------------|
-| File edit | \`lsp_diagnostics\` clean on changed files |
-| Build command | Exit code 0 |
-| Test run | Pass (or explicit note of pre-existing failures) |
-| Delegation | Agent result received and verified |
-
-**NO EVIDENCE = NOT COMPLETE.**`
-
-const SISYPHUS_PHASE2C = `## Phase 2C - Failure Recovery
-
-### When Fixes Fail:
-
-1. Fix root causes, not symptoms
-2. Re-verify after EVERY fix attempt
-3. Never shotgun debug (random changes hoping something works)
-
-### After 3 Consecutive Failures:
-
-1. **STOP** all further edits immediately
-2. **REVERT** to last known working state (git checkout / undo edits)
-3. **DOCUMENT** what was attempted and what failed
-4. **CONSULT** Oracle with full failure context
-5. If Oracle cannot resolve → **ASK USER** before proceeding
-
-**Never**: Leave code in broken state, continue hoping it'll work, delete failing tests to "pass"`
-
-const SISYPHUS_PHASE3 = `## Phase 3 - Completion
-
-A task is complete when:
-- [ ] All planned todo items marked done
-- [ ] Diagnostics clean on changed files
-- [ ] Build passes (if applicable)
-- [ ] User's original request fully addressed
-
-If verification fails:
-1. Fix issues caused by your changes
-2. Do NOT fix pre-existing issues unless asked
-3. Report: "Done. Note: found N pre-existing lint errors unrelated to my changes."
-
-### Before Delivering Final Answer:
-- Cancel ALL running background tasks: \`background_cancel(all=true)\`
-- This conserves resources and ensures clean workflow completion`
-
-const SISYPHUS_TASK_MANAGEMENT = `<Task_Management>
-## Todo Management (CRITICAL)
-
-**DEFAULT BEHAVIOR**: Create todos BEFORE starting any non-trivial task. This is your PRIMARY coordination mechanism.
-
-### When to Create Todos (MANDATORY)
-
-| Trigger | Action |
-|---------|--------|
-| Multi-step task (2+ steps) | ALWAYS create todos first |
-| Uncertain scope | ALWAYS (todos clarify thinking) |
-| User request with multiple items | ALWAYS |
-| Complex single task | Create todos to break down |
-
-### Workflow (NON-NEGOTIABLE)
-
-1. **IMMEDIATELY on receiving request**: \`todowrite\` to plan atomic steps.
-  - ONLY ADD TODOS TO IMPLEMENT SOMETHING, ONLY WHEN USER WANTS YOU TO IMPLEMENT SOMETHING.
-2. **Before starting each step**: Mark \`in_progress\` (only ONE at a time)
-3. **After completing each step**: Mark \`completed\` IMMEDIATELY (NEVER batch)
-4. **If scope changes**: Update todos before proceeding
-
-### Why This Is Non-Negotiable
-
-- **User visibility**: User sees real-time progress, not a black box
-- **Prevents drift**: Todos anchor you to the actual request
-- **Recovery**: If interrupted, todos enable seamless continuation
-- **Accountability**: Each todo = explicit commitment
-
-### Anti-Patterns (BLOCKING)
-
-| Violation | Why It's Bad |
-|-----------|--------------|
-| Skipping todos on multi-step tasks | User has no visibility, steps get forgotten |
-| Batch-completing multiple todos | Defeats real-time tracking purpose |
-| Proceeding without marking in_progress | No indication of what you're working on |
-| Finishing without completing todos | Task appears incomplete to user |
-
-**FAILURE TO USE TODOS ON NON-TRIVIAL TASKS = INCOMPLETE WORK.**
-
-### Clarification Protocol (when asking):
-
-\`\`\`
-I want to make sure I understand correctly.
-
-**What I understood**: [Your interpretation]
-**What I'm unsure about**: [Specific ambiguity]
-**Options I see**:
-1. [Option A] - [effort/implications]
-2. [Option B] - [effort/implications]
-
-**My recommendation**: [suggestion with reasoning]
-
-Should I proceed with [recommendation], or would you prefer differently?
-\`\`\`
-</Task_Management>`
-
-const SISYPHUS_TONE_AND_STYLE = `<Tone_and_Style>
-## Communication Style
-
-### Be Concise
-- Start work immediately. No acknowledgments ("I'm on it", "Let me...", "I'll start...") 
-- Answer directly without preamble
-- Don't summarize what you did unless asked
-- Don't explain your code unless asked
-- One word answers are acceptable when appropriate
-
-### No Flattery
-Never start responses with:
-- "Great question!"
-- "That's a really good idea!"
-- "Excellent choice!"
-- Any praise of the user's input
-
-Just respond directly to the substance.
-
-### No Status Updates
-Never start responses with casual acknowledgments:
-- "Hey I'm on it..."
-- "I'm working on this..."
-- "Let me start by..."
-- "I'll get to work on..."
-- "I'm going to..."
-
-Just start working. Use todos for progress tracking—that's what they're for.
-
-### When User is Wrong
-If the user's approach seems problematic:
-- Don't blindly implement it
-- Don't lecture or be preachy
-- Concisely state your concern and alternative
-- Ask if they want to proceed anyway
-
-### Match User's Style
-- If user is terse, be terse
-- If user wants detail, provide detail
-- Adapt to their communication preference
-</Tone_and_Style>`
-
-const SISYPHUS_SOFT_GUIDELINES = `## Soft Guidelines
-
-- Prefer existing libraries over new dependencies
-- Prefer small, focused changes over large refactors
-- When uncertain about scope, ask
-</Constraints>
-
-`
-
-function buildDynamicSisyphusPrompt(
-  availableAgents: AvailableAgent[],
-  availableTools: AvailableTool[] = [],
-  availableSkills: AvailableSkill[] = []
-): string {
-  const keyTriggers = buildKeyTriggersSection(availableAgents, availableSkills)
-  const toolSelection = buildToolSelectionTable(availableAgents, availableTools, availableSkills)
-  const exploreSection = buildExploreSection(availableAgents)
-  const librarianSection = buildLibrarianSection(availableAgents)
-  const frontendSection = buildFrontendSection(availableAgents)
-  const delegationTable = buildDelegationTable(availableAgents)
-  const oracleSection = buildOracleSection(availableAgents)
-  const hardBlocks = buildHardBlocksSection(availableAgents)
-  const antiPatterns = buildAntiPatternsSection(availableAgents)
-
-  const sections = [
-    SISYPHUS_ROLE_SECTION,
-    "<Behavior_Instructions>",
-    "",
-    "## Phase 0 - Intent Gate (EVERY message)",
-    "",
-    keyTriggers,
-    "",
-    SISYPHUS_PHASE0_STEP1_3,
-    "",
-    "---",
-    "",
-    SISYPHUS_PHASE1,
-    "",
-    "---",
-    "",
-    "## Phase 2A - Exploration & Research",
-    "",
-    toolSelection,
-    "",
-    exploreSection,
-    "",
-    librarianSection,
-    "",
-    SISYPHUS_PARALLEL_EXECUTION,
-    "",
-    "---",
-    "",
-    SISYPHUS_PHASE2B_PRE_IMPLEMENTATION,
-    "",
-    frontendSection,
-    "",
-    delegationTable,
-    "",
-    SISYPHUS_DELEGATION_PROMPT_STRUCTURE,
-    "",
-    SISYPHUS_GITHUB_WORKFLOW,
-    "",
-    SISYPHUS_CODE_CHANGES,
-    "",
-    "---",
-    "",
-    SISYPHUS_PHASE2C,
-    "",
-    "---",
-    "",
-    SISYPHUS_PHASE3,
-    "",
-    "</Behavior_Instructions>",
-    "",
-    oracleSection,
-    "",
-    SISYPHUS_TASK_MANAGEMENT,
-    "",
-    SISYPHUS_TONE_AND_STYLE,
-    "",
-    "<Constraints>",
-    hardBlocks,
-    "",
-    antiPatterns,
-    "",
-    SISYPHUS_SOFT_GUIDELINES,
-  ]
-
-  return sections.filter((s) => s !== "").join("\n")
-}
-
-export function createSisyphusAgent(
-  model: string = DEFAULT_MODEL,
-  availableAgents?: AvailableAgent[],
-  availableToolNames?: string[],
-  availableSkills?: AvailableSkill[]
-): AgentConfig {
-  const tools = availableToolNames ? categorizeTools(availableToolNames) : []
-  const skills = availableSkills ?? []
-  const prompt = availableAgents
-    ? buildDynamicSisyphusPrompt(availableAgents, tools, skills)
-    : buildDynamicSisyphusPrompt([], tools, skills)
-
-  const base = {
-    description:
-      "Sisyphus - Powerful AI orchestrator from OhMyOpenCode. Plans obsessively with todos, assesses search complexity before exploration, delegates strategically to specialized agents. Uses explore for internal code (parallel-friendly), librarian only for external docs, and always delegates UI work to frontend engineer.",
-    mode: "primary" as const,
-    model,
-    maxTokens: 64000,
-    prompt,
-    color: "#00CED1",
-  }
-
-  if (isGptModel(model)) {
-    return { ...base, reasoningEffort: "medium" }
-  }
-
-  return { ...base, thinking: { type: "enabled", budgetTokens: 32000 } }
-}
-
-export const sisyphusAgent = createSisyphusAgent()

src/agents/types.ts

@@ -1,78 +1,12 @@
 import type { AgentConfig } from "@opencode-ai/sdk"
 
-export type AgentFactory = (model?: string) => AgentConfig
-
-/**
- * Agent category for grouping in Sisyphus prompt sections
- */
-export type AgentCategory = "exploration" | "specialist" | "advisor" | "utility"
-
-/**
- * Cost classification for Tool Selection table
- */
-export type AgentCost = "FREE" | "CHEAP" | "EXPENSIVE"
-
-/**
- * Delegation trigger for Sisyphus prompt's Delegation Table
- */
-export interface DelegationTrigger {
-  /** Domain of work (e.g., "Frontend UI/UX") */
-  domain: string
-  /** When to delegate (e.g., "Visual changes only...") */
-  trigger: string
-}
-
-/**
- * Metadata for generating Sisyphus prompt sections dynamically
- * This allows adding/removing agents without manually updating the Sisyphus prompt
- */
-export interface AgentPromptMetadata {
-  /** Category for grouping in prompt sections */
-  category: AgentCategory
-
-  /** Cost classification for Tool Selection table */
-  cost: AgentCost
-
-  /** Domain triggers for Delegation Table */
-  triggers: DelegationTrigger[]
-
-  /** When to use this agent (for detailed sections) */
-  useWhen?: string[]
-
-  /** When NOT to use this agent */
-  avoidWhen?: string[]
-
-  /** Optional dedicated prompt section (markdown) - for agents like Oracle that have special sections */
-  dedicatedSection?: string
-
-  /** Nickname/alias used in prompt (e.g., "Oracle" instead of "oracle") */
-  promptAlias?: string
-
-  /** Key triggers that should appear in Phase 0 (e.g., "External library mentioned → fire librarian") */
-  keyTrigger?: string
-}
-
-export function isGptModel(model: string): boolean {
-  return model.startsWith("openai/") || model.startsWith("github-copilot/gpt-")
-}
-
-export type BuiltinAgentName =
-  | "Sisyphus"
+export type AgentName =
   | "oracle"
   | "librarian"
   | "explore"
   | "frontend-ui-ux-engineer"
   | "document-writer"
-  | "multimodal-looker"
 
-export type OverridableAgentName =
-  | "build"
-  | BuiltinAgentName
+export type AgentOverrideConfig = Partial<AgentConfig>
 
-export type AgentName = BuiltinAgentName
-
-export type AgentOverrideConfig = Partial<AgentConfig> & {
-  prompt_append?: string
-}
-
-export type AgentOverrides = Partial<Record<OverridableAgentName, AgentOverrideConfig>>
+export type AgentOverrides = Partial<Record<AgentName, AgentOverrideConfig>>

src/agents/utils.test.ts

@@ -1,87 +0,0 @@
-import { describe, test, expect } from "bun:test"
-import { createBuiltinAgents } from "./utils"
-
-describe("createBuiltinAgents with model overrides", () => {
-  test("Sisyphus with default model has thinking config", () => {
-    // #given - no overrides
-
-    // #when
-    const agents = createBuiltinAgents()
-
-    // #then
-    expect(agents.Sisyphus.model).toBe("anthropic/claude-opus-4-5")
-    expect(agents.Sisyphus.thinking).toEqual({ type: "enabled", budgetTokens: 32000 })
-    expect(agents.Sisyphus.reasoningEffort).toBeUndefined()
-  })
-
-  test("Sisyphus with GPT model override has reasoningEffort, no thinking", () => {
-    // #given
-    const overrides = {
-      Sisyphus: { model: "github-copilot/gpt-5.2" },
-    }
-
-    // #when
-    const agents = createBuiltinAgents([], overrides)
-
-    // #then
-    expect(agents.Sisyphus.model).toBe("github-copilot/gpt-5.2")
-    expect(agents.Sisyphus.reasoningEffort).toBe("medium")
-    expect(agents.Sisyphus.thinking).toBeUndefined()
-  })
-
-  test("Sisyphus with systemDefaultModel GPT has reasoningEffort, no thinking", () => {
-    // #given
-    const systemDefaultModel = "openai/gpt-5.2"
-
-    // #when
-    const agents = createBuiltinAgents([], {}, undefined, systemDefaultModel)
-
-    // #then
-    expect(agents.Sisyphus.model).toBe("openai/gpt-5.2")
-    expect(agents.Sisyphus.reasoningEffort).toBe("medium")
-    expect(agents.Sisyphus.thinking).toBeUndefined()
-  })
-
-  test("Oracle with default model has reasoningEffort", () => {
-    // #given - no overrides
-
-    // #when
-    const agents = createBuiltinAgents()
-
-    // #then
-    expect(agents.oracle.model).toBe("openai/gpt-5.2")
-    expect(agents.oracle.reasoningEffort).toBe("medium")
-    expect(agents.oracle.textVerbosity).toBe("high")
-    expect(agents.oracle.thinking).toBeUndefined()
-  })
-
-  test("Oracle with Claude model override has thinking, no reasoningEffort", () => {
-    // #given
-    const overrides = {
-      oracle: { model: "anthropic/claude-sonnet-4" },
-    }
-
-    // #when
-    const agents = createBuiltinAgents([], overrides)
-
-    // #then
-    expect(agents.oracle.model).toBe("anthropic/claude-sonnet-4")
-    expect(agents.oracle.thinking).toEqual({ type: "enabled", budgetTokens: 32000 })
-    expect(agents.oracle.reasoningEffort).toBeUndefined()
-    expect(agents.oracle.textVerbosity).toBeUndefined()
-  })
-
-  test("non-model overrides are still applied after factory rebuild", () => {
-    // #given
-    const overrides = {
-      Sisyphus: { model: "github-copilot/gpt-5.2", temperature: 0.5 },
-    }
-
-    // #when
-    const agents = createBuiltinAgents([], overrides)
-
-    // #then
-    expect(agents.Sisyphus.model).toBe("github-copilot/gpt-5.2")
-    expect(agents.Sisyphus.temperature).toBe(0.5)
-  })
-})

src/agents/utils.ts

@@ -1,111 +1,54 @@
 import type { AgentConfig } from "@opencode-ai/sdk"
-import type { BuiltinAgentName, AgentOverrideConfig, AgentOverrides, AgentFactory } from "./types"
-import { createSisyphusAgent } from "./sisyphus"
-import { createOracleAgent } from "./oracle"
-import { createLibrarianAgent } from "./librarian"
-import { createExploreAgent } from "./explore"
-import { createFrontendUiUxEngineerAgent } from "./frontend-ui-ux-engineer"
-import { createDocumentWriterAgent } from "./document-writer"
-import { createMultimodalLookerAgent } from "./multimodal-looker"
-import { deepMerge } from "../shared"
+import type { AgentName, AgentOverrideConfig, AgentOverrides } from "./types"
+import { oracleAgent } from "./oracle"
+import { librarianAgent } from "./librarian"
+import { exploreAgent } from "./explore"
+import { frontendUiUxEngineerAgent } from "./frontend-ui-ux-engineer"
+import { documentWriterAgent } from "./document-writer"
 
-type AgentSource = AgentFactory | AgentConfig
-
-const agentSources: Record<BuiltinAgentName, AgentSource> = {
-  Sisyphus: createSisyphusAgent,
-  oracle: createOracleAgent,
-  librarian: createLibrarianAgent,
-  explore: createExploreAgent,
-  "frontend-ui-ux-engineer": createFrontendUiUxEngineerAgent,
-  "document-writer": createDocumentWriterAgent,
-  "multimodal-looker": createMultimodalLookerAgent,
-}
-
-function isFactory(source: AgentSource): source is AgentFactory {
-  return typeof source === "function"
-}
-
-function buildAgent(source: AgentSource, model?: string): AgentConfig {
-  return isFactory(source) ? source(model) : source
-}
-
-export function createEnvContext(directory: string): string {
-  const now = new Date()
-  const timezone = Intl.DateTimeFormat().resolvedOptions().timeZone
-  const locale = Intl.DateTimeFormat().resolvedOptions().locale
-
-  const dateStr = now.toLocaleDateString("en-US", {
-    weekday: "short",
-    year: "numeric",
-    month: "short",
-    day: "numeric",
-  })
-
-  const timeStr = now.toLocaleTimeString("en-US", {
-    hour: "2-digit",
-    minute: "2-digit",
-    second: "2-digit",
-    hour12: true,
-  })
-
-  const platform = process.platform as "darwin" | "linux" | "win32" | string
-
-  return `
-Here is some useful information about the environment you are running in:
-<env>
-  Working directory: ${directory}
-  Platform: ${platform}
-  Today's date: ${dateStr} (NOT 2024, NEVEREVER 2024)
-  Current time: ${timeStr}
-  Timezone: ${timezone}
-  Locale: ${locale}
-</env>`
+const allBuiltinAgents: Record<AgentName, AgentConfig> = {
+  oracle: oracleAgent,
+  librarian: librarianAgent,
+  explore: exploreAgent,
+  "frontend-ui-ux-engineer": frontendUiUxEngineerAgent,
+  "document-writer": documentWriterAgent,
 }
 
 function mergeAgentConfig(
   base: AgentConfig,
   override: AgentOverrideConfig
 ): AgentConfig {
-  const { prompt_append, ...rest } = override
-  const merged = deepMerge(base, rest as Partial<AgentConfig>)
-
-  if (prompt_append && merged.prompt) {
-    merged.prompt = merged.prompt + "\n" + prompt_append
+  return {
+    ...base,
+    ...override,
+    tools: override.tools !== undefined
+      ? { ...(base.tools ?? {}), ...override.tools }
+      : base.tools,
+    permission: override.permission !== undefined
+      ? { ...(base.permission ?? {}), ...override.permission }
+      : base.permission,
   }
-
-  return merged
 }
 
 export function createBuiltinAgents(
-  disabledAgents: BuiltinAgentName[] = [],
-  agentOverrides: AgentOverrides = {},
-  directory?: string,
-  systemDefaultModel?: string
+  disabledAgents: AgentName[] = [],
+  agentOverrides: AgentOverrides = {}
 ): Record<string, AgentConfig> {
   const result: Record<string, AgentConfig> = {}
 
-  for (const [name, source] of Object.entries(agentSources)) {
-    const agentName = name as BuiltinAgentName
+  for (const [name, config] of Object.entries(allBuiltinAgents)) {
+    const agentName = name as AgentName
 
     if (disabledAgents.includes(agentName)) {
       continue
     }
 
     const override = agentOverrides[agentName]
-    const model = override?.model ?? (agentName === "Sisyphus" ? systemDefaultModel : undefined)
-
-    let config = buildAgent(source, model)
-
-    if ((agentName === "Sisyphus" || agentName === "librarian") && directory && config.prompt) {
-      const envContext = createEnvContext(directory)
-      config = { ...config, prompt: config.prompt + envContext }
-    }
-
     if (override) {
-      config = mergeAgentConfig(config, override)
+      result[name] = mergeAgentConfig(config, override)
+    } else {
+      result[name] = config
     }
-
-    result[name] = config
   }
 
   return result

src/auth/antigravity/constants.ts

@@ -1,74 +0,0 @@
-/**
- * Antigravity OAuth configuration constants.
- * Values sourced from cliproxyapi/sdk/auth/antigravity.go
- *
- * ## Logging Policy
- *
- * All console logging in antigravity modules follows a consistent policy:
- *
- * - **Debug logs**: Guard with `if (process.env.ANTIGRAVITY_DEBUG === "1")`
- *   - Includes: info messages, warnings, non-fatal errors
- *   - Enable debugging: `ANTIGRAVITY_DEBUG=1 opencode`
- *
- * - **Fatal errors**: None currently. All errors are handled by returning
- *   appropriate error responses to OpenCode's auth system.
- *
- * This policy ensures production silence while enabling verbose debugging
- * when needed for troubleshooting OAuth flows.
- */
-
-// OAuth 2.0 Client Credentials
-export const ANTIGRAVITY_CLIENT_ID =
-  "1071006060591-tmhssin2h21lcre235vtolojh4g403ep.apps.googleusercontent.com"
-export const ANTIGRAVITY_CLIENT_SECRET = "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"
-
-// OAuth Callback
-export const ANTIGRAVITY_CALLBACK_PORT = 51121
-export const ANTIGRAVITY_REDIRECT_URI = `http://localhost:${ANTIGRAVITY_CALLBACK_PORT}/oauth-callback`
-
-// OAuth Scopes
-export const ANTIGRAVITY_SCOPES = [
-  "https://www.googleapis.com/auth/cloud-platform",
-  "https://www.googleapis.com/auth/userinfo.email",
-  "https://www.googleapis.com/auth/userinfo.profile",
-  "https://www.googleapis.com/auth/cclog",
-  "https://www.googleapis.com/auth/experimentsandconfigs",
-] as const
-
-// API Endpoint Fallbacks (order: daily → autopush → prod)
-export const ANTIGRAVITY_ENDPOINT_FALLBACKS = [
-  "https://daily-cloudcode-pa.sandbox.googleapis.com", // dev
-  "https://autopush-cloudcode-pa.sandbox.googleapis.com", // staging
-  "https://cloudcode-pa.googleapis.com", // prod
-] as const
-
-// API Version
-export const ANTIGRAVITY_API_VERSION = "v1internal"
-
-// Request Headers
-export const ANTIGRAVITY_HEADERS = {
-  "User-Agent": "google-api-nodejs-client/9.15.1",
-  "X-Goog-Api-Client": "google-cloud-sdk vscode_cloudshelleditor/0.1",
-  "Client-Metadata": JSON.stringify({
-    ideType: "IDE_UNSPECIFIED",
-    platform: "PLATFORM_UNSPECIFIED",
-    pluginType: "GEMINI",
-  }),
-} as const
-
-// Default Project ID (fallback when loadCodeAssist API fails)
-// From opencode-antigravity-auth reference implementation
-export const ANTIGRAVITY_DEFAULT_PROJECT_ID = "rising-fact-p41fc"
-
-
-
-// Google OAuth endpoints
-export const GOOGLE_AUTH_URL = "https://accounts.google.com/o/oauth2/v2/auth"
-export const GOOGLE_TOKEN_URL = "https://oauth2.googleapis.com/token"
-export const GOOGLE_USERINFO_URL = "https://www.googleapis.com/oauth2/v1/userinfo"
-
-// Token refresh buffer (refresh 60 seconds before expiry)
-export const ANTIGRAVITY_TOKEN_REFRESH_BUFFER_MS = 60_000
-
-// Default thought signature to skip validation (CLIProxyAPI approach)
-export const SKIP_THOUGHT_SIGNATURE_VALIDATOR = "skip_thought_signature_validator"

src/auth/antigravity/fetch.ts

@@ -1,621 +0,0 @@
-/**
- * Antigravity Fetch Interceptor
- *
- * Creates a custom fetch function that:
- * - Checks token expiration and auto-refreshes
- * - Rewrites URLs to Antigravity endpoints
- * - Applies request transformation (including tool normalization)
- * - Applies response transformation (including thinking extraction)
- * - Implements endpoint fallback (daily → autopush → prod)
- *
- * **Body Type Assumption:**
- * This interceptor assumes `init.body` is a JSON string (OpenAI format).
- * Non-string bodies (ReadableStream, Blob, FormData, URLSearchParams, etc.)
- * are passed through unchanged to the original fetch to avoid breaking
- * other requests that may not be OpenAI-format API calls.
- *
- * Debug logging available via ANTIGRAVITY_DEBUG=1 environment variable.
- */
-
-import { ANTIGRAVITY_ENDPOINT_FALLBACKS } from "./constants"
-import { fetchProjectContext, clearProjectContextCache, invalidateProjectContextByRefreshToken } from "./project"
-import { isTokenExpired, refreshAccessToken, parseStoredToken, formatTokenForStorage, AntigravityTokenRefreshError } from "./token"
-import { transformRequest } from "./request"
-import { convertRequestBody, hasOpenAIMessages } from "./message-converter"
-import {
-  transformResponse,
-  transformStreamingResponse,
-  isStreamingResponse,
-} from "./response"
-import { normalizeToolsForGemini, type OpenAITool } from "./tools"
-import { extractThinkingBlocks, shouldIncludeThinking, transformResponseThinking } from "./thinking"
-import {
-  getThoughtSignature,
-  setThoughtSignature,
-  getOrCreateSessionId,
-} from "./thought-signature-store"
-import type { AntigravityTokens } from "./types"
-
-/**
- * Auth interface matching OpenCode's auth system
- */
-interface Auth {
-  access?: string
-  refresh?: string
-  expires?: number
-}
-
-/**
- * Client interface for auth operations
- */
-interface AuthClient {
-  set(providerId: string, auth: Auth): Promise<void>
-}
-
-/**
- * Debug logging helper
- * Only logs when ANTIGRAVITY_DEBUG=1
- */
-function debugLog(message: string): void {
-  if (process.env.ANTIGRAVITY_DEBUG === "1") {
-    console.log(`[antigravity-fetch] ${message}`)
-  }
-}
-
-function isRetryableError(status: number): boolean {
-  if (status === 0) return true
-  if (status === 429) return true
-  if (status >= 500 && status < 600) return true
-  return false
-}
-
-const GCP_PERMISSION_ERROR_PATTERNS = [
-  "PERMISSION_DENIED",
-  "does not have permission",
-  "Cloud AI Companion API has not been used",
-  "has not been enabled",
-] as const
-
-function isGcpPermissionError(text: string): boolean {
-  return GCP_PERMISSION_ERROR_PATTERNS.some((pattern) => text.includes(pattern))
-}
-
-function calculateRetryDelay(attempt: number): number {
-  return Math.min(200 * Math.pow(2, attempt), 2000)
-}
-
-async function isRetryableResponse(response: Response): Promise<boolean> {
-  if (isRetryableError(response.status)) return true
-  if (response.status === 403) {
-    try {
-      const text = await response.clone().text()
-      if (text.includes("SUBSCRIPTION_REQUIRED") || text.includes("Gemini Code Assist license")) {
-        debugLog(`[RETRY] 403 SUBSCRIPTION_REQUIRED detected, will retry with next endpoint`)
-        return true
-      }
-    } catch {}
-  }
-  return false
-}
-
-interface AttemptFetchOptions {
-  endpoint: string
-  url: string
-  init: RequestInit
-  accessToken: string
-  projectId: string
-  sessionId: string
-  modelName?: string
-  thoughtSignature?: string
-}
-
-type AttemptFetchResult = Response | null | "pass-through" | "needs-refresh"
-
-async function attemptFetch(
-  options: AttemptFetchOptions
-): Promise<AttemptFetchResult> {
-  const { endpoint, url, init, accessToken, projectId, sessionId, modelName, thoughtSignature } =
-    options
-  debugLog(`Trying endpoint: ${endpoint}`)
-
-  try {
-    const rawBody = init.body
-
-    if (rawBody !== undefined && typeof rawBody !== "string") {
-      debugLog(`Non-string body detected (${typeof rawBody}), signaling pass-through`)
-      return "pass-through"
-    }
-
-    let parsedBody: Record<string, unknown> = {}
-    if (rawBody) {
-      try {
-        parsedBody = JSON.parse(rawBody) as Record<string, unknown>
-      } catch {
-        parsedBody = {}
-      }
-    }
-
-    debugLog(`[BODY] Keys: ${Object.keys(parsedBody).join(", ")}`)
-    debugLog(`[BODY] Has contents: ${!!parsedBody.contents}, Has messages: ${!!parsedBody.messages}`)
-    if (parsedBody.contents) {
-      const contents = parsedBody.contents as Array<Record<string, unknown>>
-      debugLog(`[BODY] contents length: ${contents.length}`)
-      contents.forEach((c, i) => {
-        debugLog(`[BODY] contents[${i}].role: ${c.role}, parts: ${JSON.stringify(c.parts).substring(0, 200)}`)
-      })
-    }
-
-    if (parsedBody.tools && Array.isArray(parsedBody.tools)) {
-      const normalizedTools = normalizeToolsForGemini(parsedBody.tools as OpenAITool[])
-      if (normalizedTools) {
-        parsedBody.tools = normalizedTools
-      }
-    }
-
-    if (hasOpenAIMessages(parsedBody)) {
-      debugLog(`[CONVERT] Converting OpenAI messages to Gemini contents`)
-      parsedBody = convertRequestBody(parsedBody, thoughtSignature)
-      debugLog(`[CONVERT] After conversion - Has contents: ${!!parsedBody.contents}`)
-    }
-
-    const transformed = transformRequest({
-      url,
-      body: parsedBody,
-      accessToken,
-      projectId,
-      sessionId,
-      modelName,
-      endpointOverride: endpoint,
-      thoughtSignature,
-    })
-
-    debugLog(`[REQ] streaming=${transformed.streaming}, url=${transformed.url}`)
-
-    const maxPermissionRetries = 10
-    for (let attempt = 0; attempt <= maxPermissionRetries; attempt++) {
-      const response = await fetch(transformed.url, {
-        method: init.method || "POST",
-        headers: transformed.headers,
-        body: JSON.stringify(transformed.body),
-        signal: init.signal,
-      })
-
-      debugLog(
-        `[RESP] status=${response.status} content-type=${response.headers.get("content-type") ?? ""} url=${response.url}`
-      )
-
-      if (response.status === 401) {
-        debugLog(`[401] Unauthorized response detected, signaling token refresh needed`)
-        return "needs-refresh"
-      }
-
-      if (response.status === 403) {
-        try {
-          const text = await response.clone().text()
-          if (isGcpPermissionError(text)) {
-            if (attempt < maxPermissionRetries) {
-              const delay = calculateRetryDelay(attempt)
-              debugLog(`[RETRY] GCP permission error, retry ${attempt + 1}/${maxPermissionRetries} after ${delay}ms`)
-              await new Promise((resolve) => setTimeout(resolve, delay))
-              continue
-            }
-            debugLog(`[RETRY] GCP permission error, max retries exceeded`)
-          }
-        } catch {}
-      }
-
-      if (!response.ok && (await isRetryableResponse(response))) {
-        debugLog(`Endpoint failed: ${endpoint} (status: ${response.status}), trying next`)
-        return null
-      }
-
-      return response
-    }
-
-    return null
-  } catch (error) {
-    debugLog(
-      `Endpoint failed: ${endpoint} (${error instanceof Error ? error.message : "Unknown error"}), trying next`
-    )
-    return null
-  }
-}
-
-interface GeminiResponsePart {
-  thoughtSignature?: string
-  thought_signature?: string
-  functionCall?: Record<string, unknown>
-  text?: string
-  [key: string]: unknown
-}
-
-interface GeminiResponseCandidate {
-  content?: {
-    parts?: GeminiResponsePart[]
-    [key: string]: unknown
-  }
-  [key: string]: unknown
-}
-
-interface GeminiResponseBody {
-  candidates?: GeminiResponseCandidate[]
-  [key: string]: unknown
-}
-
-function extractSignatureFromResponse(parsed: GeminiResponseBody): string | undefined {
-  if (!parsed.candidates || !Array.isArray(parsed.candidates)) {
-    return undefined
-  }
-
-  for (const candidate of parsed.candidates) {
-    const parts = candidate.content?.parts
-    if (!parts || !Array.isArray(parts)) {
-      continue
-    }
-
-    for (const part of parts) {
-      const sig = part.thoughtSignature || part.thought_signature
-      if (sig && typeof sig === "string") {
-        return sig
-      }
-    }
-  }
-
-  return undefined
-}
-
-async function transformResponseWithThinking(
-  response: Response,
-  modelName: string,
-  fetchInstanceId: string
-): Promise<Response> {
-  const streaming = isStreamingResponse(response)
-
-  let result
-  if (streaming) {
-    result = await transformStreamingResponse(response)
-  } else {
-    result = await transformResponse(response)
-  }
-
-  if (streaming) {
-    return result.response
-  }
-
-  try {
-    const text = await result.response.clone().text()
-    debugLog(`[TSIG][RESP] Response text length: ${text.length}`)
-
-    const parsed = JSON.parse(text) as GeminiResponseBody
-    debugLog(`[TSIG][RESP] Parsed keys: ${Object.keys(parsed).join(", ")}`)
-    debugLog(`[TSIG][RESP] Has candidates: ${!!parsed.candidates}, count: ${parsed.candidates?.length ?? 0}`)
-
-    const signature = extractSignatureFromResponse(parsed)
-    debugLog(`[TSIG][RESP] Signature extracted: ${signature ? signature.substring(0, 30) + "..." : "NONE"}`)
-    if (signature) {
-      setThoughtSignature(fetchInstanceId, signature)
-      debugLog(`[TSIG][STORE] Stored signature for ${fetchInstanceId}`)
-    } else {
-      debugLog(`[TSIG][WARN] No signature found in response!`)
-    }
-
-    if (shouldIncludeThinking(modelName)) {
-      const thinkingResult = extractThinkingBlocks(parsed)
-      if (thinkingResult.hasThinking) {
-        const transformed = transformResponseThinking(parsed)
-        return new Response(JSON.stringify(transformed), {
-          status: result.response.status,
-          statusText: result.response.statusText,
-          headers: result.response.headers,
-        })
-      }
-    }
-  } catch {}
-
-  return result.response
-}
-
-/**
- * Create Antigravity fetch interceptor
- *
- * Factory function that creates a custom fetch function for Antigravity API.
- * Handles token management, request/response transformation, and endpoint fallback.
- *
- * @param getAuth - Async function to retrieve current auth state
- * @param client - Auth client for saving updated tokens
- * @param providerId - Provider identifier (e.g., "google")
- * @param clientId - Optional custom client ID for token refresh (defaults to ANTIGRAVITY_CLIENT_ID)
- * @param clientSecret - Optional custom client secret for token refresh (defaults to ANTIGRAVITY_CLIENT_SECRET)
- * @returns Custom fetch function compatible with standard fetch signature
- *
- * @example
- * ```typescript
- * const customFetch = createAntigravityFetch(
- *   () => auth(),
- *   client,
- *   "google",
- *   "custom-client-id",
- *   "custom-client-secret"
- * )
- *
- * // Use like standard fetch
- * const response = await customFetch("https://api.example.com/chat", {
- *   method: "POST",
- *   body: JSON.stringify({ messages: [...] })
- * })
- * ```
- */
-export function createAntigravityFetch(
-  getAuth: () => Promise<Auth>,
-  client: AuthClient,
-  providerId: string,
-  clientId?: string,
-  clientSecret?: string
-): (url: string, init?: RequestInit) => Promise<Response> {
-  let cachedTokens: AntigravityTokens | null = null
-  let cachedProjectId: string | null = null
-  const fetchInstanceId = crypto.randomUUID()
-
-  return async (url: string, init: RequestInit = {}): Promise<Response> => {
-    debugLog(`Intercepting request to: ${url}`)
-
-    // Get current auth state
-    const auth = await getAuth()
-    if (!auth.access || !auth.refresh) {
-      throw new Error("Antigravity: No authentication tokens available")
-    }
-
-    // Parse stored token format
-    const refreshParts = parseStoredToken(auth.refresh)
-
-    // Build initial token state
-    if (!cachedTokens) {
-      cachedTokens = {
-        type: "antigravity",
-        access_token: auth.access,
-        refresh_token: refreshParts.refreshToken,
-        expires_in: auth.expires ? Math.floor((auth.expires - Date.now()) / 1000) : 3600,
-        timestamp: auth.expires ? auth.expires - 3600 * 1000 : Date.now(),
-      }
-    } else {
-      // Update with fresh values
-      cachedTokens.access_token = auth.access
-      cachedTokens.refresh_token = refreshParts.refreshToken
-    }
-
-    // Check token expiration and refresh if needed
-    if (isTokenExpired(cachedTokens)) {
-      debugLog("Token expired, refreshing...")
-
-      try {
-        const newTokens = await refreshAccessToken(refreshParts.refreshToken, clientId, clientSecret)
-
-        cachedTokens = {
-          type: "antigravity",
-          access_token: newTokens.access_token,
-          refresh_token: newTokens.refresh_token,
-          expires_in: newTokens.expires_in,
-          timestamp: Date.now(),
-        }
-
-        clearProjectContextCache()
-
-        const formattedRefresh = formatTokenForStorage(
-          newTokens.refresh_token,
-          refreshParts.projectId || "",
-          refreshParts.managedProjectId
-        )
-
-        await client.set(providerId, {
-          access: newTokens.access_token,
-          refresh: formattedRefresh,
-          expires: Date.now() + newTokens.expires_in * 1000,
-        })
-
-        debugLog("Token refreshed successfully")
-      } catch (error) {
-        if (error instanceof AntigravityTokenRefreshError) {
-          if (error.isInvalidGrant) {
-            debugLog(`[REFRESH] Token revoked (invalid_grant), clearing caches`)
-            invalidateProjectContextByRefreshToken(refreshParts.refreshToken)
-            clearProjectContextCache()
-          }
-          throw new Error(
-            `Antigravity: Token refresh failed: ${error.description || error.message}${error.code ? ` (${error.code})` : ""}`
-          )
-        }
-        throw new Error(
-          `Antigravity: Token refresh failed: ${error instanceof Error ? error.message : "Unknown error"}`
-        )
-      }
-    }
-
-    // Fetch project ID via loadCodeAssist (CLIProxyAPI approach)
-    if (!cachedProjectId) {
-      const projectContext = await fetchProjectContext(cachedTokens.access_token)
-      cachedProjectId = projectContext.cloudaicompanionProject || ""
-      debugLog(`[PROJECT] Fetched project ID: "${cachedProjectId}"`)
-    }
-
-    const projectId = cachedProjectId
-    debugLog(`[PROJECT] Using project ID: "${projectId}"`)
-
-    // Extract model name from request body
-    let modelName: string | undefined
-    if (init.body) {
-      try {
-        const body =
-          typeof init.body === "string"
-            ? (JSON.parse(init.body) as Record<string, unknown>)
-            : (init.body as unknown as Record<string, unknown>)
-        if (typeof body.model === "string") {
-          modelName = body.model
-        }
-      } catch {
-        // Ignore parsing errors
-      }
-    }
-
-    const maxEndpoints = Math.min(ANTIGRAVITY_ENDPOINT_FALLBACKS.length, 3)
-    const sessionId = getOrCreateSessionId(fetchInstanceId)
-    const thoughtSignature = getThoughtSignature(fetchInstanceId)
-    debugLog(`[TSIG][GET] sessionId=${sessionId}, signature=${thoughtSignature ? thoughtSignature.substring(0, 20) + "..." : "none"}`)
-
-    let hasRefreshedFor401 = false
-
-    const executeWithEndpoints = async (): Promise<Response> => {
-      for (let i = 0; i < maxEndpoints; i++) {
-        const endpoint = ANTIGRAVITY_ENDPOINT_FALLBACKS[i]
-
-        const response = await attemptFetch({
-          endpoint,
-          url,
-          init,
-          accessToken: cachedTokens!.access_token,
-          projectId,
-          sessionId,
-          modelName,
-          thoughtSignature,
-        })
-
-        if (response === "pass-through") {
-          debugLog("Non-string body detected, passing through with auth headers")
-          const headersWithAuth = {
-            ...init.headers,
-            Authorization: `Bearer ${cachedTokens!.access_token}`,
-          }
-          return fetch(url, { ...init, headers: headersWithAuth })
-        }
-
-        if (response === "needs-refresh") {
-          if (hasRefreshedFor401) {
-            debugLog("[401] Already refreshed once, returning unauthorized error")
-            return new Response(
-              JSON.stringify({
-                error: {
-                  message: "Authentication failed after token refresh",
-                  type: "unauthorized",
-                  code: "token_refresh_failed",
-                },
-              }),
-              {
-                status: 401,
-                statusText: "Unauthorized",
-                headers: { "Content-Type": "application/json" },
-              }
-            )
-          }
-
-          debugLog("[401] Refreshing token and retrying...")
-          hasRefreshedFor401 = true
-
-          try {
-            const newTokens = await refreshAccessToken(
-              refreshParts.refreshToken,
-              clientId,
-              clientSecret
-            )
-
-            cachedTokens = {
-              type: "antigravity",
-              access_token: newTokens.access_token,
-              refresh_token: newTokens.refresh_token,
-              expires_in: newTokens.expires_in,
-              timestamp: Date.now(),
-            }
-
-            clearProjectContextCache()
-
-            const formattedRefresh = formatTokenForStorage(
-              newTokens.refresh_token,
-              refreshParts.projectId || "",
-              refreshParts.managedProjectId
-            )
-
-            await client.set(providerId, {
-              access: newTokens.access_token,
-              refresh: formattedRefresh,
-              expires: Date.now() + newTokens.expires_in * 1000,
-            })
-
-            debugLog("[401] Token refreshed, retrying request...")
-            return executeWithEndpoints()
-          } catch (refreshError) {
-            if (refreshError instanceof AntigravityTokenRefreshError) {
-              if (refreshError.isInvalidGrant) {
-                debugLog(`[401] Token revoked (invalid_grant), clearing caches`)
-                invalidateProjectContextByRefreshToken(refreshParts.refreshToken)
-                clearProjectContextCache()
-              }
-              debugLog(`[401] Token refresh failed: ${refreshError.description || refreshError.message}`)
-              return new Response(
-                JSON.stringify({
-                  error: {
-                    message: refreshError.description || refreshError.message,
-                    type: refreshError.isInvalidGrant ? "token_revoked" : "unauthorized",
-                    code: refreshError.code || "token_refresh_failed",
-                  },
-                }),
-                {
-                  status: 401,
-                  statusText: "Unauthorized",
-                  headers: { "Content-Type": "application/json" },
-                }
-              )
-            }
-            debugLog(`[401] Token refresh failed: ${refreshError instanceof Error ? refreshError.message : "Unknown error"}`)
-            return new Response(
-              JSON.stringify({
-                error: {
-                  message: refreshError instanceof Error ? refreshError.message : "Unknown error",
-                  type: "unauthorized",
-                  code: "token_refresh_failed",
-                },
-              }),
-              {
-                status: 401,
-                statusText: "Unauthorized",
-                headers: { "Content-Type": "application/json" },
-              }
-            )
-          }
-        }
-
-        if (response) {
-          debugLog(`Success with endpoint: ${endpoint}`)
-          const transformedResponse = await transformResponseWithThinking(
-            response,
-            modelName || "",
-            fetchInstanceId
-          )
-          return transformedResponse
-        }
-      }
-
-      const errorMessage = `All Antigravity endpoints failed after ${maxEndpoints} attempts`
-      debugLog(errorMessage)
-
-      return new Response(
-        JSON.stringify({
-          error: {
-            message: errorMessage,
-            type: "endpoint_failure",
-            code: "all_endpoints_failed",
-          },
-        }),
-        {
-          status: 503,
-          statusText: "Service Unavailable",
-          headers: { "Content-Type": "application/json" },
-        }
-      )
-    }
-
-    return executeWithEndpoints()
-  }
-}
-
-/**
- * Type export for createAntigravityFetch return type
- */
-export type AntigravityFetch = (url: string, init?: RequestInit) => Promise<Response>

src/auth/antigravity/index.ts

@@ -1,13 +0,0 @@
-export * from "./types"
-export * from "./constants"
-export * from "./oauth"
-export * from "./token"
-export * from "./project"
-export * from "./request"
-export * from "./response"
-export * from "./tools"
-export * from "./thinking"
-export * from "./thought-signature-store"
-export * from "./message-converter"
-export * from "./fetch"
-export * from "./plugin"

src/auth/antigravity/message-converter.ts

@@ -1,206 +0,0 @@
-/**
- * OpenAI → Gemini message format converter
- * 
- * Converts OpenAI-style messages to Gemini contents format,
- * injecting thoughtSignature into functionCall parts.
- */
-
-import { SKIP_THOUGHT_SIGNATURE_VALIDATOR } from "./constants"
-
-function debugLog(message: string): void {
-  if (process.env.ANTIGRAVITY_DEBUG === "1") {
-    console.log(`[antigravity-converter] ${message}`)
-  }
-}
-
-interface OpenAIMessage {
-  role: "system" | "user" | "assistant" | "tool"
-  content?: string | OpenAIContentPart[]
-  tool_calls?: OpenAIToolCall[]
-  tool_call_id?: string
-  name?: string
-}
-
-interface OpenAIContentPart {
-  type: string
-  text?: string
-  image_url?: { url: string }
-  [key: string]: unknown
-}
-
-interface OpenAIToolCall {
-  id: string
-  type: "function"
-  function: {
-    name: string
-    arguments: string
-  }
-}
-
-interface GeminiPart {
-  text?: string
-  functionCall?: {
-    name: string
-    args: Record<string, unknown>
-  }
-  functionResponse?: {
-    name: string
-    response: Record<string, unknown>
-  }
-  inlineData?: {
-    mimeType: string
-    data: string
-  }
-  thought_signature?: string
-  [key: string]: unknown
-}
-
-interface GeminiContent {
-  role: "user" | "model"
-  parts: GeminiPart[]
-}
-
-export function convertOpenAIToGemini(
-  messages: OpenAIMessage[],
-  thoughtSignature?: string
-): GeminiContent[] {
-  debugLog(`Converting ${messages.length} messages, signature: ${thoughtSignature ? "present" : "none"}`)
-  
-  const contents: GeminiContent[] = []
-
-  for (const msg of messages) {
-    if (msg.role === "system") {
-      contents.push({
-        role: "user",
-        parts: [{ text: typeof msg.content === "string" ? msg.content : "" }],
-      })
-      continue
-    }
-
-    if (msg.role === "user") {
-      const parts = convertContentToParts(msg.content)
-      contents.push({ role: "user", parts })
-      continue
-    }
-
-    if (msg.role === "assistant") {
-      const parts: GeminiPart[] = []
-
-      if (msg.content) {
-        parts.push(...convertContentToParts(msg.content))
-      }
-
-      if (msg.tool_calls && msg.tool_calls.length > 0) {
-        for (const toolCall of msg.tool_calls) {
-          let args: Record<string, unknown> = {}
-          try {
-            args = JSON.parse(toolCall.function.arguments)
-          } catch {
-            args = {}
-          }
-
-          const part: GeminiPart = {
-            functionCall: {
-              name: toolCall.function.name,
-              args,
-            },
-          }
-
-          // Always inject signature: use provided or default to skip validator (CLIProxyAPI approach)
-          part.thoughtSignature = thoughtSignature || SKIP_THOUGHT_SIGNATURE_VALIDATOR
-          debugLog(`Injected signature into functionCall: ${toolCall.function.name} (${thoughtSignature ? "provided" : "default"})`)
-
-          parts.push(part)
-        }
-      }
-
-      if (parts.length > 0) {
-        contents.push({ role: "model", parts })
-      }
-      continue
-    }
-
-    if (msg.role === "tool") {
-      let response: Record<string, unknown> = {}
-      try {
-        response = typeof msg.content === "string" 
-          ? JSON.parse(msg.content) 
-          : { result: msg.content }
-      } catch {
-        response = { result: msg.content }
-      }
-
-      const toolName = msg.name || "unknown"
-      
-      contents.push({
-        role: "user",
-        parts: [{
-          functionResponse: {
-            name: toolName,
-            response,
-          },
-        }],
-      })
-      continue
-    }
-  }
-
-  debugLog(`Converted to ${contents.length} content blocks`)
-  return contents
-}
-
-function convertContentToParts(content: string | OpenAIContentPart[] | undefined): GeminiPart[] {
-  if (!content) {
-    return [{ text: "" }]
-  }
-
-  if (typeof content === "string") {
-    return [{ text: content }]
-  }
-
-  const parts: GeminiPart[] = []
-  for (const part of content) {
-    if (part.type === "text" && part.text) {
-      parts.push({ text: part.text })
-    } else if (part.type === "image_url" && part.image_url?.url) {
-      const url = part.image_url.url
-      if (url.startsWith("data:")) {
-        const match = url.match(/^data:([^;]+);base64,(.+)$/)
-        if (match) {
-          parts.push({
-            inlineData: {
-              mimeType: match[1],
-              data: match[2],
-            },
-          })
-        }
-      }
-    }
-  }
-
-  return parts.length > 0 ? parts : [{ text: "" }]
-}
-
-export function hasOpenAIMessages(body: Record<string, unknown>): boolean {
-  return Array.isArray(body.messages) && body.messages.length > 0
-}
-
-export function convertRequestBody(
-  body: Record<string, unknown>,
-  thoughtSignature?: string
-): Record<string, unknown> {
-  if (!hasOpenAIMessages(body)) {
-    debugLog("No messages array found, returning body as-is")
-    return body
-  }
-
-  const messages = body.messages as OpenAIMessage[]
-  const contents = convertOpenAIToGemini(messages, thoughtSignature)
-
-  const converted = { ...body }
-  delete converted.messages
-  converted.contents = contents
-
-  debugLog(`Converted body: messages → contents (${contents.length} blocks)`)
-  return converted
-}

src/auth/antigravity/oauth.ts

@@ -1,361 +0,0 @@
-/**
- * Antigravity OAuth 2.0 flow implementation with PKCE.
- * Handles Google OAuth for Antigravity authentication.
- */
-import { generatePKCE } from "@openauthjs/openauth/pkce"
-
-import {
-  ANTIGRAVITY_CLIENT_ID,
-  ANTIGRAVITY_CLIENT_SECRET,
-  ANTIGRAVITY_REDIRECT_URI,
-  ANTIGRAVITY_SCOPES,
-  ANTIGRAVITY_CALLBACK_PORT,
-  GOOGLE_AUTH_URL,
-  GOOGLE_TOKEN_URL,
-  GOOGLE_USERINFO_URL,
-} from "./constants"
-import type {
-  AntigravityTokenExchangeResult,
-  AntigravityUserInfo,
-} from "./types"
-
-/**
- * PKCE pair containing verifier and challenge.
- */
-export interface PKCEPair {
-  /** PKCE verifier - used during token exchange */
-  verifier: string
-  /** PKCE challenge - sent in auth URL */
-  challenge: string
-  /** Challenge method - always "S256" */
-  method: string
-}
-
-/**
- * OAuth state encoded in the auth URL.
- * Contains the PKCE verifier for later retrieval.
- */
-export interface OAuthState {
-  /** PKCE verifier */
-  verifier: string
-  /** Optional project ID */
-  projectId?: string
-}
-
-/**
- * Result from building an OAuth authorization URL.
- */
-export interface AuthorizationResult {
-  /** Full OAuth URL to open in browser */
-  url: string
-  /** PKCE verifier to use during code exchange */
-  verifier: string
-}
-
-/**
- * Result from the OAuth callback server.
- */
-export interface CallbackResult {
-  /** Authorization code from Google */
-  code: string
-  /** State parameter from callback */
-  state: string
-  /** Error message if any */
-  error?: string
-}
-
-/**
- * Generate PKCE verifier and challenge pair.
- * Uses @openauthjs/openauth for cryptographically secure generation.
- *
- * @returns PKCE pair with verifier, challenge, and method
- */
-export async function generatePKCEPair(): Promise<PKCEPair> {
-  const pkce = await generatePKCE()
-  return {
-    verifier: pkce.verifier,
-    challenge: pkce.challenge,
-    method: pkce.method,
-  }
-}
-
-/**
- * Encode OAuth state into a URL-safe base64 string.
- *
- * @param state - OAuth state object
- * @returns Base64URL encoded state
- */
-function encodeState(state: OAuthState): string {
-  const json = JSON.stringify(state)
-  return Buffer.from(json, "utf8").toString("base64url")
-}
-
-/**
- * Decode OAuth state from a base64 string.
- *
- * @param encoded - Base64URL or Base64 encoded state
- * @returns Decoded OAuth state
- */
-export function decodeState(encoded: string): OAuthState {
-  // Handle both base64url and standard base64
-  const normalized = encoded.replace(/-/g, "+").replace(/_/g, "/")
-  const padded = normalized.padEnd(
-    normalized.length + ((4 - (normalized.length % 4)) % 4),
-    "="
-  )
-  const json = Buffer.from(padded, "base64").toString("utf8")
-  const parsed = JSON.parse(json)
-
-  if (typeof parsed.verifier !== "string") {
-    throw new Error("Missing PKCE verifier in state")
-  }
-
-  return {
-    verifier: parsed.verifier,
-    projectId:
-      typeof parsed.projectId === "string" ? parsed.projectId : undefined,
-  }
-}
-
-export async function buildAuthURL(
-  projectId?: string,
-  clientId: string = ANTIGRAVITY_CLIENT_ID,
-  port: number = ANTIGRAVITY_CALLBACK_PORT
-): Promise<AuthorizationResult> {
-  const pkce = await generatePKCEPair()
-
-  const state: OAuthState = {
-    verifier: pkce.verifier,
-    projectId,
-  }
-
-  const redirectUri = `http://localhost:${port}/oauth-callback`
-
-  const url = new URL(GOOGLE_AUTH_URL)
-  url.searchParams.set("client_id", clientId)
-  url.searchParams.set("redirect_uri", redirectUri)
-  url.searchParams.set("response_type", "code")
-  url.searchParams.set("scope", ANTIGRAVITY_SCOPES.join(" "))
-  url.searchParams.set("state", encodeState(state))
-  url.searchParams.set("code_challenge", pkce.challenge)
-  url.searchParams.set("code_challenge_method", "S256")
-  url.searchParams.set("access_type", "offline")
-  url.searchParams.set("prompt", "consent")
-
-  return {
-    url: url.toString(),
-    verifier: pkce.verifier,
-  }
-}
-
-/**
- * Exchange authorization code for tokens.
- *
- * @param code - Authorization code from OAuth callback
- * @param verifier - PKCE verifier from initial auth request
- * @param clientId - Optional custom client ID (defaults to ANTIGRAVITY_CLIENT_ID)
- * @param clientSecret - Optional custom client secret (defaults to ANTIGRAVITY_CLIENT_SECRET)
- * @returns Token exchange result with access and refresh tokens
- */
-export async function exchangeCode(
-  code: string,
-  verifier: string,
-  clientId: string = ANTIGRAVITY_CLIENT_ID,
-  clientSecret: string = ANTIGRAVITY_CLIENT_SECRET,
-  port: number = ANTIGRAVITY_CALLBACK_PORT
-): Promise<AntigravityTokenExchangeResult> {
-  const redirectUri = `http://localhost:${port}/oauth-callback`
-  const params = new URLSearchParams({
-    client_id: clientId,
-    client_secret: clientSecret,
-    code,
-    grant_type: "authorization_code",
-    redirect_uri: redirectUri,
-    code_verifier: verifier,
-  })
-
-  const response = await fetch(GOOGLE_TOKEN_URL, {
-    method: "POST",
-    headers: {
-      "Content-Type": "application/x-www-form-urlencoded",
-    },
-    body: params,
-  })
-
-  if (!response.ok) {
-    const errorText = await response.text()
-    throw new Error(`Token exchange failed: ${response.status} - ${errorText}`)
-  }
-
-  const data = (await response.json()) as {
-    access_token: string
-    refresh_token: string
-    expires_in: number
-    token_type: string
-  }
-
-  return {
-    access_token: data.access_token,
-    refresh_token: data.refresh_token,
-    expires_in: data.expires_in,
-    token_type: data.token_type,
-  }
-}
-
-/**
- * Fetch user info from Google's userinfo API.
- *
- * @param accessToken - Valid access token
- * @returns User info containing email
- */
-export async function fetchUserInfo(
-  accessToken: string
-): Promise<AntigravityUserInfo> {
-  const response = await fetch(`${GOOGLE_USERINFO_URL}?alt=json`, {
-    headers: {
-      Authorization: `Bearer ${accessToken}`,
-    },
-  })
-
-  if (!response.ok) {
-    throw new Error(`Failed to fetch user info: ${response.status}`)
-  }
-
-  const data = (await response.json()) as {
-    email?: string
-    name?: string
-    picture?: string
-  }
-
-  return {
-    email: data.email || "",
-    name: data.name,
-    picture: data.picture,
-  }
-}
-
-export interface CallbackServerHandle {
-  port: number
-  waitForCallback: () => Promise<CallbackResult>
-  close: () => void
-}
-
-export function startCallbackServer(
-  timeoutMs: number = 5 * 60 * 1000
-): CallbackServerHandle {
-  let server: ReturnType<typeof Bun.serve> | null = null
-  let timeoutId: ReturnType<typeof setTimeout> | null = null
-  let resolveCallback: ((result: CallbackResult) => void) | null = null
-  let rejectCallback: ((error: Error) => void) | null = null
-
-  const cleanup = () => {
-    if (timeoutId) {
-      clearTimeout(timeoutId)
-      timeoutId = null
-    }
-    if (server) {
-      server.stop()
-      server = null
-    }
-  }
-
-  server = Bun.serve({
-    port: 0,
-    fetch(request: Request): Response {
-      const url = new URL(request.url)
-
-      if (url.pathname === "/oauth-callback") {
-        const code = url.searchParams.get("code") || ""
-        const state = url.searchParams.get("state") || ""
-        const error = url.searchParams.get("error") || undefined
-
-        let responseBody: string
-        if (code && !error) {
-          responseBody =
-            "<html><body><h1>Login successful</h1><p>You can close this window.</p></body></html>"
-        } else {
-          responseBody =
-            "<html><body><h1>Login failed</h1><p>Please check the CLI output.</p></body></html>"
-        }
-
-        setTimeout(() => {
-          cleanup()
-          if (resolveCallback) {
-            resolveCallback({ code, state, error })
-          }
-        }, 100)
-
-        return new Response(responseBody, {
-          status: 200,
-          headers: { "Content-Type": "text/html" },
-        })
-      }
-
-      return new Response("Not Found", { status: 404 })
-    },
-  })
-
-  const actualPort = server.port as number
-
-  const waitForCallback = (): Promise<CallbackResult> => {
-    return new Promise((resolve, reject) => {
-      resolveCallback = resolve
-      rejectCallback = reject
-
-      timeoutId = setTimeout(() => {
-        cleanup()
-        reject(new Error("OAuth callback timeout"))
-      }, timeoutMs)
-    })
-  }
-
-  return {
-    port: actualPort,
-    waitForCallback,
-    close: cleanup,
-  }
-}
-
-export async function performOAuthFlow(
-  projectId?: string,
-  openBrowser?: (url: string) => Promise<void>,
-  clientId: string = ANTIGRAVITY_CLIENT_ID,
-  clientSecret: string = ANTIGRAVITY_CLIENT_SECRET
-): Promise<{
-  tokens: AntigravityTokenExchangeResult
-  userInfo: AntigravityUserInfo
-  verifier: string
-}> {
-  const serverHandle = startCallbackServer()
-
-  try {
-    const auth = await buildAuthURL(projectId, clientId, serverHandle.port)
-
-    if (openBrowser) {
-      await openBrowser(auth.url)
-    }
-
-    const callback = await serverHandle.waitForCallback()
-
-    if (callback.error) {
-      throw new Error(`OAuth error: ${callback.error}`)
-    }
-
-    if (!callback.code) {
-      throw new Error("No authorization code received")
-    }
-
-    const state = decodeState(callback.state)
-    if (state.verifier !== auth.verifier) {
-      throw new Error("PKCE verifier mismatch - possible CSRF attack")
-    }
-
-    const tokens = await exchangeCode(callback.code, auth.verifier, clientId, clientSecret, serverHandle.port)
-    const userInfo = await fetchUserInfo(tokens.access_token)
-
-    return { tokens, userInfo, verifier: auth.verifier }
-  } catch (err) {
-    serverHandle.close()
-    throw err
-  }
-}

src/auth/antigravity/plugin.ts

@@ -1,295 +0,0 @@
-/**
- * Google Antigravity Auth Plugin for OpenCode
- *
- * Provides OAuth authentication for Google models via Antigravity API.
- * This plugin integrates with OpenCode's auth system to enable:
- * - OAuth 2.0 with PKCE flow for Google authentication
- * - Automatic token refresh
- * - Request/response transformation for Antigravity API
- *
- * @example
- * ```json
- * // opencode.json
- * {
- *   "plugin": ["oh-my-opencode"],
- *   "provider": {
- *     "google": {
- *       "options": {
- *         "clientId": "custom-client-id",
- *         "clientSecret": "custom-client-secret"
- *       }
- *     }
- *   }
- * }
- * ```
- */
-
-import type { Auth, Provider } from "@opencode-ai/sdk"
-import type { AuthHook, AuthOuathResult, PluginInput } from "@opencode-ai/plugin"
-
-import { ANTIGRAVITY_CLIENT_ID, ANTIGRAVITY_CLIENT_SECRET } from "./constants"
-import {
-  buildAuthURL,
-  exchangeCode,
-  startCallbackServer,
-  fetchUserInfo,
-  decodeState,
-} from "./oauth"
-import { createAntigravityFetch } from "./fetch"
-import { fetchProjectContext } from "./project"
-import { formatTokenForStorage } from "./token"
-
-/**
- * Provider ID for Google models
- * Antigravity is an auth method for Google, not a separate provider
- */
-const GOOGLE_PROVIDER_ID = "google"
-
-/**
- * Type guard to check if auth is OAuth type
- */
-function isOAuthAuth(
-  auth: Auth
-): auth is { type: "oauth"; access: string; refresh: string; expires: number } {
-  return auth.type === "oauth"
-}
-
-/**
- * Creates the Google Antigravity OAuth plugin for OpenCode.
- *
- * This factory function creates an auth plugin that:
- * 1. Provides OAuth flow for Google authentication
- * 2. Creates a custom fetch interceptor for Antigravity API
- * 3. Handles token management and refresh
- *
- * @param input - Plugin input containing the OpenCode client
- * @returns Hooks object with auth configuration
- *
- * @example
- * ```typescript
- * // Used by OpenCode automatically when plugin is loaded
- * const hooks = await createGoogleAntigravityAuthPlugin({ client, ... })
- * ```
- */
-export async function createGoogleAntigravityAuthPlugin({
-  client,
-}: PluginInput): Promise<{ auth: AuthHook }> {
-  // Cache for custom credentials from provider.options
-  // These are populated by loader() and used by authorize()
-  // Falls back to defaults if loader hasn't been called yet
-  let cachedClientId: string = ANTIGRAVITY_CLIENT_ID
-  let cachedClientSecret: string = ANTIGRAVITY_CLIENT_SECRET
-
-  const authHook: AuthHook = {
-    /**
-     * Provider identifier - must be "google" as Antigravity is
-     * an auth method for Google models, not a separate provider
-     */
-    provider: GOOGLE_PROVIDER_ID,
-
-    /**
-     * Loader function called when auth is needed.
-     * Reads credentials from provider.options and creates custom fetch.
-     *
-     * @param auth - Function to retrieve current auth state
-     * @param provider - Provider configuration including options
-     * @returns Object with custom fetch function
-     */
-    loader: async (
-      auth: () => Promise<Auth>,
-      provider: Provider
-    ): Promise<Record<string, unknown>> => {
-      const currentAuth = await auth()
-      
-      if (process.env.ANTIGRAVITY_DEBUG === "1") {
-        console.log("[antigravity-plugin] loader called")
-        console.log("[antigravity-plugin] auth type:", currentAuth?.type)
-        console.log("[antigravity-plugin] auth keys:", Object.keys(currentAuth || {}))
-      }
-      
-      if (!isOAuthAuth(currentAuth)) {
-        if (process.env.ANTIGRAVITY_DEBUG === "1") {
-          console.log("[antigravity-plugin] NOT OAuth auth, returning empty")
-        }
-        return {}
-      }
-      
-      if (process.env.ANTIGRAVITY_DEBUG === "1") {
-        console.log("[antigravity-plugin] OAuth auth detected, creating custom fetch")
-      }
-
-      cachedClientId =
-        (provider.options?.clientId as string) || ANTIGRAVITY_CLIENT_ID
-      cachedClientSecret =
-        (provider.options?.clientSecret as string) || ANTIGRAVITY_CLIENT_SECRET
-
-      // Log if using custom credentials (for debugging)
-      if (
-        process.env.ANTIGRAVITY_DEBUG === "1" &&
-        (cachedClientId !== ANTIGRAVITY_CLIENT_ID ||
-          cachedClientSecret !== ANTIGRAVITY_CLIENT_SECRET)
-      ) {
-        console.log(
-          "[antigravity-plugin] Using custom credentials from provider.options"
-        )
-      }
-
-      // Create adapter for client.auth.set that matches fetch.ts AuthClient interface
-      const authClient = {
-        set: async (
-          providerId: string,
-          authData: { access?: string; refresh?: string; expires?: number }
-        ) => {
-          await client.auth.set({
-            body: {
-              type: "oauth",
-              access: authData.access || "",
-              refresh: authData.refresh || "",
-              expires: authData.expires || 0,
-            },
-            path: { id: providerId },
-          })
-        },
-      }
-
-      // Create auth getter that returns compatible format for fetch.ts
-      const getAuth = async (): Promise<{
-        access?: string
-        refresh?: string
-        expires?: number
-      }> => {
-        const authState = await auth()
-        if (isOAuthAuth(authState)) {
-          return {
-            access: authState.access,
-            refresh: authState.refresh,
-            expires: authState.expires,
-          }
-        }
-        return {}
-      }
-
-      const antigravityFetch = createAntigravityFetch(
-        getAuth,
-        authClient,
-        GOOGLE_PROVIDER_ID,
-        cachedClientId,
-        cachedClientSecret
-      )
-
-      return {
-        fetch: antigravityFetch,
-        apiKey: "antigravity-oauth",
-      }
-    },
-
-    /**
-     * Authentication methods available for this provider.
-     * Only OAuth is supported - no prompts for credentials.
-     */
-    methods: [
-      {
-        type: "oauth",
-        label: "OAuth with Google (Antigravity)",
-        // NO prompts - credentials come from provider.options or defaults
-        // OAuth flow starts immediately when user selects this method
-
-        /**
-         * Starts the OAuth authorization flow.
-         * Opens browser for Google OAuth and waits for callback.
-         *
-         * @returns Authorization result with URL and callback
-         */
-        authorize: async (): Promise<AuthOuathResult> => {
-          const serverHandle = startCallbackServer()
-          const { url, verifier } = await buildAuthURL(undefined, cachedClientId, serverHandle.port)
-
-          return {
-            url,
-            instructions:
-              "Complete the sign-in in your browser. We'll automatically detect when you're done.",
-            method: "auto",
-
-            callback: async () => {
-              try {
-                const result = await serverHandle.waitForCallback()
-
-                if (result.error) {
-                  if (process.env.ANTIGRAVITY_DEBUG === "1") {
-                    console.error(`[antigravity-plugin] OAuth error: ${result.error}`)
-                  }
-                  return { type: "failed" as const }
-                }
-
-                if (!result.code) {
-                  if (process.env.ANTIGRAVITY_DEBUG === "1") {
-                    console.error("[antigravity-plugin] No authorization code received")
-                  }
-                  return { type: "failed" as const }
-                }
-
-                const state = decodeState(result.state)
-                if (state.verifier !== verifier) {
-                  if (process.env.ANTIGRAVITY_DEBUG === "1") {
-                    console.error("[antigravity-plugin] PKCE verifier mismatch")
-                  }
-                  return { type: "failed" as const }
-                }
-
-                const tokens = await exchangeCode(result.code, verifier, cachedClientId, cachedClientSecret, serverHandle.port)
-
-                try {
-                  const userInfo = await fetchUserInfo(tokens.access_token)
-                  if (process.env.ANTIGRAVITY_DEBUG === "1") {
-                    console.log(`[antigravity-plugin] Authenticated as: ${userInfo.email}`)
-                  }
-                } catch {
-                  // User info is optional
-                }
-
-                const projectContext = await fetchProjectContext(tokens.access_token)
-
-                const formattedRefresh = formatTokenForStorage(
-                  tokens.refresh_token,
-                  projectContext.cloudaicompanionProject || "",
-                  projectContext.managedProjectId
-                )
-
-                return {
-                  type: "success" as const,
-                  access: tokens.access_token,
-                  refresh: formattedRefresh,
-                  expires: Date.now() + tokens.expires_in * 1000,
-                }
-              } catch (error) {
-                serverHandle.close()
-                if (process.env.ANTIGRAVITY_DEBUG === "1") {
-                  console.error(
-                    `[antigravity-plugin] OAuth flow failed: ${
-                      error instanceof Error ? error.message : "Unknown error"
-                    }`
-                  )
-                }
-                return { type: "failed" as const }
-              }
-            },
-          }
-        },
-      },
-    ],
-  }
-
-  return {
-    auth: authHook,
-  }
-}
-
-/**
- * Default export for OpenCode plugin system
- */
-export default createGoogleAntigravityAuthPlugin
-
-/**
- * Named export for explicit imports
- */
-export const GoogleAntigravityAuthPlugin = createGoogleAntigravityAuthPlugin

src/auth/antigravity/project.ts

@@ -1,274 +0,0 @@
-/**
- * Antigravity project context management.
- * Handles fetching GCP project ID via Google's loadCodeAssist API.
- * For FREE tier users, onboards via onboardUser API to get server-assigned managed project ID.
- * Reference: https://github.com/shekohex/opencode-google-antigravity-auth
- */
-
-import {
-  ANTIGRAVITY_ENDPOINT_FALLBACKS,
-  ANTIGRAVITY_API_VERSION,
-  ANTIGRAVITY_HEADERS,
-  ANTIGRAVITY_DEFAULT_PROJECT_ID,
-} from "./constants"
-import type {
-  AntigravityProjectContext,
-  AntigravityLoadCodeAssistResponse,
-  AntigravityOnboardUserPayload,
-  AntigravityUserTier,
-} from "./types"
-
-const projectContextCache = new Map<string, AntigravityProjectContext>()
-
-function debugLog(message: string): void {
-  if (process.env.ANTIGRAVITY_DEBUG === "1") {
-    console.log(`[antigravity-project] ${message}`)
-  }
-}
-
-const CODE_ASSIST_METADATA = {
-  ideType: "IDE_UNSPECIFIED",
-  platform: "PLATFORM_UNSPECIFIED",
-  pluginType: "GEMINI",
-} as const
-
-function extractProjectId(
-  project: string | { id: string } | undefined
-): string | undefined {
-  if (!project) return undefined
-  if (typeof project === "string") {
-    const trimmed = project.trim()
-    return trimmed || undefined
-  }
-  if (typeof project === "object" && "id" in project) {
-    const id = project.id
-    if (typeof id === "string") {
-      const trimmed = id.trim()
-      return trimmed || undefined
-    }
-  }
-  return undefined
-}
-
-function getDefaultTierId(allowedTiers?: AntigravityUserTier[]): string | undefined {
-  if (!allowedTiers || allowedTiers.length === 0) return undefined
-  for (const tier of allowedTiers) {
-    if (tier?.isDefault) return tier.id
-  }
-  return allowedTiers[0]?.id
-}
-
-function isFreeTier(tierId: string | undefined): boolean {
-  if (!tierId) return true // No tier = assume free tier (default behavior)
-  const lower = tierId.toLowerCase()
-  return lower === "free" || lower === "free-tier" || lower.startsWith("free")
-}
-
-function wait(ms: number): Promise<void> {
-  return new Promise((resolve) => setTimeout(resolve, ms))
-}
-
-async function callLoadCodeAssistAPI(
-  accessToken: string,
-  projectId?: string
-): Promise<AntigravityLoadCodeAssistResponse | null> {
-  const metadata: Record<string, string> = { ...CODE_ASSIST_METADATA }
-  if (projectId) metadata.duetProject = projectId
-
-  const requestBody: Record<string, unknown> = { metadata }
-  if (projectId) requestBody.cloudaicompanionProject = projectId
-
-  const headers: Record<string, string> = {
-    Authorization: `Bearer ${accessToken}`,
-    "Content-Type": "application/json",
-    "User-Agent": ANTIGRAVITY_HEADERS["User-Agent"],
-    "X-Goog-Api-Client": ANTIGRAVITY_HEADERS["X-Goog-Api-Client"],
-    "Client-Metadata": ANTIGRAVITY_HEADERS["Client-Metadata"],
-  }
-
-  for (const baseEndpoint of ANTIGRAVITY_ENDPOINT_FALLBACKS) {
-    const url = `${baseEndpoint}/${ANTIGRAVITY_API_VERSION}:loadCodeAssist`
-    debugLog(`[loadCodeAssist] Trying: ${url}`)
-    try {
-      const response = await fetch(url, {
-        method: "POST",
-        headers,
-        body: JSON.stringify(requestBody),
-      })
-      if (!response.ok) {
-        debugLog(`[loadCodeAssist] Failed: ${response.status} ${response.statusText}`)
-        continue
-      }
-      const data = (await response.json()) as AntigravityLoadCodeAssistResponse
-      debugLog(`[loadCodeAssist] Success: ${JSON.stringify(data)}`)
-      return data
-    } catch (err) {
-      debugLog(`[loadCodeAssist] Error: ${err}`)
-      continue
-    }
-  }
-  debugLog(`[loadCodeAssist] All endpoints failed`)
-  return null
-}
-
-async function onboardManagedProject(
-  accessToken: string,
-  tierId: string,
-  projectId?: string,
-  attempts = 10,
-  delayMs = 5000
-): Promise<string | undefined> {
-  debugLog(`[onboardUser] Starting with tierId=${tierId}, projectId=${projectId || "none"}`)
-  
-  const metadata: Record<string, string> = { ...CODE_ASSIST_METADATA }
-  if (projectId) metadata.duetProject = projectId
-
-  const requestBody: Record<string, unknown> = { tierId, metadata }
-  if (!isFreeTier(tierId)) {
-    if (!projectId) {
-      debugLog(`[onboardUser] Non-FREE tier requires projectId, returning undefined`)
-      return undefined
-    }
-    requestBody.cloudaicompanionProject = projectId
-  }
-
-  const headers: Record<string, string> = {
-    Authorization: `Bearer ${accessToken}`,
-    "Content-Type": "application/json",
-    "User-Agent": ANTIGRAVITY_HEADERS["User-Agent"],
-    "X-Goog-Api-Client": ANTIGRAVITY_HEADERS["X-Goog-Api-Client"],
-    "Client-Metadata": ANTIGRAVITY_HEADERS["Client-Metadata"],
-  }
-
-  debugLog(`[onboardUser] Request body: ${JSON.stringify(requestBody)}`)
-
-  for (let attempt = 0; attempt < attempts; attempt++) {
-    debugLog(`[onboardUser] Attempt ${attempt + 1}/${attempts}`)
-    for (const baseEndpoint of ANTIGRAVITY_ENDPOINT_FALLBACKS) {
-      const url = `${baseEndpoint}/${ANTIGRAVITY_API_VERSION}:onboardUser`
-      debugLog(`[onboardUser] Trying: ${url}`)
-      try {
-        const response = await fetch(url, {
-          method: "POST",
-          headers,
-          body: JSON.stringify(requestBody),
-        })
-        if (!response.ok) {
-          const errorText = await response.text().catch(() => "")
-          debugLog(`[onboardUser] Failed: ${response.status} ${response.statusText} - ${errorText}`)
-          continue
-        }
-
-        const payload = (await response.json()) as AntigravityOnboardUserPayload
-        debugLog(`[onboardUser] Response: ${JSON.stringify(payload)}`)
-        const managedProjectId = payload.response?.cloudaicompanionProject?.id
-        if (payload.done && managedProjectId) {
-          debugLog(`[onboardUser] Success! Got managed project ID: ${managedProjectId}`)
-          return managedProjectId
-        }
-        if (payload.done && projectId) {
-          debugLog(`[onboardUser] Done but no managed ID, using original: ${projectId}`)
-          return projectId
-        }
-        debugLog(`[onboardUser] Not done yet, payload.done=${payload.done}`)
-      } catch (err) {
-        debugLog(`[onboardUser] Error: ${err}`)
-        continue
-      }
-    }
-    if (attempt < attempts - 1) {
-      debugLog(`[onboardUser] Waiting ${delayMs}ms before next attempt...`)
-      await wait(delayMs)
-    }
-  }
-  debugLog(`[onboardUser] All attempts exhausted, returning undefined`)
-  return undefined
-}
-
-export async function fetchProjectContext(
-  accessToken: string
-): Promise<AntigravityProjectContext> {
-  debugLog(`[fetchProjectContext] Starting...`)
-  
-  const cached = projectContextCache.get(accessToken)
-  if (cached) {
-    debugLog(`[fetchProjectContext] Returning cached result: ${JSON.stringify(cached)}`)
-    return cached
-  }
-
-  const loadPayload = await callLoadCodeAssistAPI(accessToken)
-
-  // If loadCodeAssist returns a project ID, use it directly
-  if (loadPayload?.cloudaicompanionProject) {
-    const projectId = extractProjectId(loadPayload.cloudaicompanionProject)
-    debugLog(`[fetchProjectContext] loadCodeAssist returned project: ${projectId}`)
-    if (projectId) {
-      const result: AntigravityProjectContext = { cloudaicompanionProject: projectId }
-      projectContextCache.set(accessToken, result)
-      debugLog(`[fetchProjectContext] Using loadCodeAssist project ID: ${projectId}`)
-      return result
-    }
-  }
-
-  // No project ID from loadCodeAssist - try with fallback project ID
-  if (!loadPayload) {
-    debugLog(`[fetchProjectContext] loadCodeAssist returned null, trying with fallback project ID`)
-    const fallbackPayload = await callLoadCodeAssistAPI(accessToken, ANTIGRAVITY_DEFAULT_PROJECT_ID)
-    const fallbackProjectId = extractProjectId(fallbackPayload?.cloudaicompanionProject)
-    if (fallbackProjectId) {
-      const result: AntigravityProjectContext = { cloudaicompanionProject: fallbackProjectId }
-      projectContextCache.set(accessToken, result)
-      debugLog(`[fetchProjectContext] Using fallback project ID: ${fallbackProjectId}`)
-      return result
-    }
-    debugLog(`[fetchProjectContext] Fallback also failed, using default: ${ANTIGRAVITY_DEFAULT_PROJECT_ID}`)
-    return { cloudaicompanionProject: ANTIGRAVITY_DEFAULT_PROJECT_ID }
-  }
-
-  const currentTierId = loadPayload.currentTier?.id
-  debugLog(`[fetchProjectContext] currentTier: ${currentTierId}, allowedTiers: ${JSON.stringify(loadPayload.allowedTiers)}`)
-  
-  if (currentTierId && !isFreeTier(currentTierId)) {
-    // PAID tier - still use fallback if no project provided
-    debugLog(`[fetchProjectContext] PAID tier detected (${currentTierId}), using fallback: ${ANTIGRAVITY_DEFAULT_PROJECT_ID}`)
-    return { cloudaicompanionProject: ANTIGRAVITY_DEFAULT_PROJECT_ID }
-  }
-
-  const defaultTierId = getDefaultTierId(loadPayload.allowedTiers)
-  const tierId = defaultTierId ?? "free-tier"
-  debugLog(`[fetchProjectContext] Resolved tierId: ${tierId}`)
-
-  if (!isFreeTier(tierId)) {
-    debugLog(`[fetchProjectContext] Non-FREE tier (${tierId}) without project, using fallback: ${ANTIGRAVITY_DEFAULT_PROJECT_ID}`)
-    return { cloudaicompanionProject: ANTIGRAVITY_DEFAULT_PROJECT_ID }
-  }
-
-  // FREE tier - onboard to get server-assigned managed project ID
-  debugLog(`[fetchProjectContext] FREE tier detected (${tierId}), calling onboardUser...`)
-  const managedProjectId = await onboardManagedProject(accessToken, tierId)
-  if (managedProjectId) {
-    const result: AntigravityProjectContext = {
-      cloudaicompanionProject: managedProjectId,
-      managedProjectId,
-    }
-    projectContextCache.set(accessToken, result)
-    debugLog(`[fetchProjectContext] Got managed project ID: ${managedProjectId}`)
-    return result
-  }
-
-  debugLog(`[fetchProjectContext] Failed to get managed project ID, using fallback: ${ANTIGRAVITY_DEFAULT_PROJECT_ID}`)
-  return { cloudaicompanionProject: ANTIGRAVITY_DEFAULT_PROJECT_ID }
-}
-
-export function clearProjectContextCache(accessToken?: string): void {
-  if (accessToken) {
-    projectContextCache.delete(accessToken)
-  } else {
-    projectContextCache.clear()
-  }
-}
-
-export function invalidateProjectContextByRefreshToken(_refreshToken: string): void {
-  projectContextCache.clear()
-  debugLog(`[invalidateProjectContextByRefreshToken] Cleared all project context cache due to refresh token invalidation`)
-}

src/auth/antigravity/request.ts

@@ -1,303 +0,0 @@
-/**
- * Antigravity request transformer.
- * Transforms OpenAI-format requests to Antigravity format.
- * Does NOT handle tool normalization (handled by tools.ts in Task 9).
- */
-
-import {
-    ANTIGRAVITY_API_VERSION,
-    ANTIGRAVITY_ENDPOINT_FALLBACKS,
-    ANTIGRAVITY_HEADERS,
-    SKIP_THOUGHT_SIGNATURE_VALIDATOR,
-} from "./constants"
-import type { AntigravityRequestBody } from "./types"
-
-/**
- * Result of request transformation including URL, headers, and body.
- */
-export interface TransformedRequest {
-  /** Transformed URL for Antigravity API */
-  url: string
-  /** Request headers including Authorization and Antigravity-specific headers */
-  headers: Record<string, string>
-  /** Transformed request body in Antigravity format */
-  body: AntigravityRequestBody
-  /** Whether this is a streaming request */
-  streaming: boolean
-}
-
-/**
- * Build Antigravity-specific request headers.
- * Includes Authorization, User-Agent, X-Goog-Api-Client, and Client-Metadata.
- *
- * @param accessToken - OAuth access token for Authorization header
- * @returns Headers object with all required Antigravity headers
- */
-export function buildRequestHeaders(accessToken: string): Record<string, string> {
-  return {
-    Authorization: `Bearer ${accessToken}`,
-    "Content-Type": "application/json",
-    "User-Agent": ANTIGRAVITY_HEADERS["User-Agent"],
-    "X-Goog-Api-Client": ANTIGRAVITY_HEADERS["X-Goog-Api-Client"],
-    "Client-Metadata": ANTIGRAVITY_HEADERS["Client-Metadata"],
-  }
-}
-
-/**
- * Extract model name from request body.
- * OpenAI-format requests include model in the body.
- *
- * @param body - Request body that may contain a model field
- * @returns Model name or undefined if not found
- */
-export function extractModelFromBody(
-  body: Record<string, unknown>
-): string | undefined {
-  const model = body.model
-  if (typeof model === "string" && model.trim()) {
-    return model.trim()
-  }
-  return undefined
-}
-
-/**
- * Extract model name from URL path.
- * Handles Google Generative Language API format: /models/{model}:{action}
- *
- * @param url - Request URL to parse
- * @returns Model name or undefined if not found
- */
-export function extractModelFromUrl(url: string): string | undefined {
-  // Match Google's API format: /models/gemini-3-pro:generateContent
-  const match = url.match(/\/models\/([^:]+):/)
-  if (match && match[1]) {
-    return match[1]
-  }
-  return undefined
-}
-
-/**
- * Determine the action type from the URL path.
- * E.g., generateContent, streamGenerateContent
- *
- * @param url - Request URL to parse
- * @returns Action name or undefined if not found
- */
-export function extractActionFromUrl(url: string): string | undefined {
-  // Match Google's API format: /models/gemini-3-pro:generateContent
-  const match = url.match(/\/models\/[^:]+:(\w+)/)
-  if (match && match[1]) {
-    return match[1]
-  }
-  return undefined
-}
-
-/**
- * Check if a URL is targeting Google's Generative Language API.
- *
- * @param url - URL to check
- * @returns true if this is a Google Generative Language API request
- */
-export function isGenerativeLanguageRequest(url: string): boolean {
-  return url.includes("generativelanguage.googleapis.com")
-}
-
-/**
- * Build Antigravity API URL for the given action.
- *
- * @param baseEndpoint - Base Antigravity endpoint URL (from fallbacks)
- * @param action - API action (e.g., generateContent, streamGenerateContent)
- * @param streaming - Whether to append SSE query parameter
- * @returns Formatted Antigravity API URL
- */
-export function buildAntigravityUrl(
-  baseEndpoint: string,
-  action: string,
-  streaming: boolean
-): string {
-  const query = streaming ? "?alt=sse" : ""
-  return `${baseEndpoint}/${ANTIGRAVITY_API_VERSION}:${action}${query}`
-}
-
-/**
- * Get the first available Antigravity endpoint.
- * Can be used with fallback logic in fetch.ts.
- *
- * @returns Default (first) Antigravity endpoint
- */
-export function getDefaultEndpoint(): string {
-  return ANTIGRAVITY_ENDPOINT_FALLBACKS[0]
-}
-
-function generateRequestId(): string {
-  return `agent-${crypto.randomUUID()}`
-}
-
-export function wrapRequestBody(
-  body: Record<string, unknown>,
-  projectId: string,
-  modelName: string,
-  sessionId: string
-): AntigravityRequestBody {
-  const requestPayload = { ...body }
-  delete requestPayload.model
-
-  return {
-    project: projectId,
-    model: modelName,
-    userAgent: "antigravity",
-    requestId: generateRequestId(),
-    request: {
-      ...requestPayload,
-      sessionId,
-    },
-  }
-}
-
-interface ContentPart {
-  functionCall?: Record<string, unknown>
-  thoughtSignature?: string
-  [key: string]: unknown
-}
-
-interface ContentBlock {
-  role?: string
-  parts?: ContentPart[]
-  [key: string]: unknown
-}
-
-function debugLog(message: string): void {
-  if (process.env.ANTIGRAVITY_DEBUG === "1") {
-    console.log(`[antigravity-request] ${message}`)
-  }
-}
-
-export function injectThoughtSignatureIntoFunctionCalls(
-  body: Record<string, unknown>,
-  signature: string | undefined
-): Record<string, unknown> {
-  // Always use skip validator as fallback (CLIProxyAPI approach)
-  const effectiveSignature = signature || SKIP_THOUGHT_SIGNATURE_VALIDATOR
-  debugLog(`[TSIG][INJECT] signature=${effectiveSignature.substring(0, 30)}... (${signature ? "provided" : "default"})`)
-  debugLog(`[TSIG][INJECT] body keys: ${Object.keys(body).join(", ")}`)
-
-  const contents = body.contents as ContentBlock[] | undefined
-  if (!contents || !Array.isArray(contents)) {
-    debugLog(`[TSIG][INJECT] No contents array! Has messages: ${!!body.messages}`)
-    return body
-  }
-
-  debugLog(`[TSIG][INJECT] Found ${contents.length} content blocks`)
-  let injectedCount = 0
-  const modifiedContents = contents.map((content) => {
-    if (!content.parts || !Array.isArray(content.parts)) {
-      return content
-    }
-
-    const modifiedParts = content.parts.map((part) => {
-      if (part.functionCall && !part.thoughtSignature) {
-        injectedCount++
-        return {
-          ...part,
-          thoughtSignature: effectiveSignature,
-        }
-      }
-      return part
-    })
-
-    return { ...content, parts: modifiedParts }
-  })
-
-  debugLog(`[TSIG][INJECT] injected signature into ${injectedCount} functionCall(s)`)
-  return { ...body, contents: modifiedContents }
-}
-
-/**
- * Detect if request is for streaming.
- * Checks both action name and request body for stream flag.
- *
- * @param url - Request URL
- * @param body - Request body
- * @returns true if streaming is requested
- */
-export function isStreamingRequest(
-  url: string,
-  body: Record<string, unknown>
-): boolean {
-  // Check URL action
-  const action = extractActionFromUrl(url)
-  if (action === "streamGenerateContent") {
-    return true
-  }
-
-  // Check body for stream flag
-  if (body.stream === true) {
-    return true
-  }
-
-  return false
-}
-
-export interface TransformRequestOptions {
-  url: string
-  body: Record<string, unknown>
-  accessToken: string
-  projectId: string
-  sessionId: string
-  modelName?: string
-  endpointOverride?: string
-  thoughtSignature?: string
-}
-
-export function transformRequest(options: TransformRequestOptions): TransformedRequest {
-  const {
-    url,
-    body,
-    accessToken,
-    projectId,
-    sessionId,
-    modelName,
-    endpointOverride,
-    thoughtSignature,
-  } = options
-
-  const effectiveModel =
-    modelName || extractModelFromBody(body) || extractModelFromUrl(url) || "gemini-3-pro-high"
-
-  const streaming = isStreamingRequest(url, body)
-  const action = streaming ? "streamGenerateContent" : "generateContent"
-
-  const endpoint = endpointOverride || getDefaultEndpoint()
-  const transformedUrl = buildAntigravityUrl(endpoint, action, streaming)
-
-  const headers = buildRequestHeaders(accessToken)
-  if (streaming) {
-    headers["Accept"] = "text/event-stream"
-  }
-
-  const bodyWithSignature = injectThoughtSignatureIntoFunctionCalls(body, thoughtSignature)
-  const wrappedBody = wrapRequestBody(bodyWithSignature, projectId, effectiveModel, sessionId)
-
-  return {
-    url: transformedUrl,
-    headers,
-    body: wrappedBody,
-    streaming,
-  }
-}
-
-/**
- * Prepare request headers for streaming responses.
- * Adds Accept header for SSE format.
- *
- * @param headers - Existing headers object
- * @returns Headers with streaming support
- */
-export function addStreamingHeaders(
-  headers: Record<string, string>
-): Record<string, string> {
-  return {
-    ...headers,
-    Accept: "text/event-stream",
-  }
-}

src/auth/antigravity/response.ts

@@ -1,598 +0,0 @@
-/**
- * Antigravity Response Handler
- * Transforms Antigravity/Gemini API responses to OpenAI-compatible format
- *
- * Key responsibilities:
- * - Non-streaming response transformation
- * - SSE streaming response transformation (buffered - see transformStreamingResponse)
- * - Error response handling with retry-after extraction
- * - Usage metadata extraction from x-antigravity-* headers
- */
-
-import type { AntigravityError, AntigravityUsage } from "./types"
-
-/**
- * Usage metadata extracted from Antigravity response headers
- */
-export interface AntigravityUsageMetadata {
-  cachedContentTokenCount?: number
-  totalTokenCount?: number
-  promptTokenCount?: number
-  candidatesTokenCount?: number
-}
-
-/**
- * Transform result with response and metadata
- */
-export interface TransformResult {
-  response: Response
-  usage?: AntigravityUsageMetadata
-  retryAfterMs?: number
-  error?: AntigravityError
-}
-
-/**
- * Extract usage metadata from Antigravity response headers
- *
- * Antigravity sets these headers:
- * - x-antigravity-cached-content-token-count
- * - x-antigravity-total-token-count
- * - x-antigravity-prompt-token-count
- * - x-antigravity-candidates-token-count
- *
- * @param headers - Response headers
- * @returns Usage metadata if found
- */
-export function extractUsageFromHeaders(headers: Headers): AntigravityUsageMetadata | undefined {
-  const cached = headers.get("x-antigravity-cached-content-token-count")
-  const total = headers.get("x-antigravity-total-token-count")
-  const prompt = headers.get("x-antigravity-prompt-token-count")
-  const candidates = headers.get("x-antigravity-candidates-token-count")
-
-  // Return undefined if no usage headers found
-  if (!cached && !total && !prompt && !candidates) {
-    return undefined
-  }
-
-  const usage: AntigravityUsageMetadata = {}
-
-  if (cached) {
-    const parsed = parseInt(cached, 10)
-    if (!isNaN(parsed)) {
-      usage.cachedContentTokenCount = parsed
-    }
-  }
-
-  if (total) {
-    const parsed = parseInt(total, 10)
-    if (!isNaN(parsed)) {
-      usage.totalTokenCount = parsed
-    }
-  }
-
-  if (prompt) {
-    const parsed = parseInt(prompt, 10)
-    if (!isNaN(parsed)) {
-      usage.promptTokenCount = parsed
-    }
-  }
-
-  if (candidates) {
-    const parsed = parseInt(candidates, 10)
-    if (!isNaN(parsed)) {
-      usage.candidatesTokenCount = parsed
-    }
-  }
-
-  return Object.keys(usage).length > 0 ? usage : undefined
-}
-
-/**
- * Extract retry-after value from error response
- *
- * Antigravity returns retry info in error.details array:
- * {
- *   error: {
- *     details: [{
- *       "@type": "type.googleapis.com/google.rpc.RetryInfo",
- *       "retryDelay": "5.123s"
- *     }]
- *   }
- * }
- *
- * Also checks standard Retry-After header.
- *
- * @param response - Response object (for headers)
- * @param errorBody - Parsed error body (optional)
- * @returns Retry after value in milliseconds, or undefined
- */
-export function extractRetryAfterMs(
-  response: Response,
-  errorBody?: Record<string, unknown>,
-): number | undefined {
-  // First, check standard Retry-After header
-  const retryAfterHeader = response.headers.get("Retry-After")
-  if (retryAfterHeader) {
-    const seconds = parseFloat(retryAfterHeader)
-    if (!isNaN(seconds) && seconds > 0) {
-      return Math.ceil(seconds * 1000)
-    }
-  }
-
-  // Check retry-after-ms header (set by some transformers)
-  const retryAfterMsHeader = response.headers.get("retry-after-ms")
-  if (retryAfterMsHeader) {
-    const ms = parseInt(retryAfterMsHeader, 10)
-    if (!isNaN(ms) && ms > 0) {
-      return ms
-    }
-  }
-
-  // Check error body for RetryInfo
-  if (!errorBody) {
-    return undefined
-  }
-
-  const error = errorBody.error as Record<string, unknown> | undefined
-  if (!error?.details || !Array.isArray(error.details)) {
-    return undefined
-  }
-
-  const retryInfo = (error.details as Array<Record<string, unknown>>).find(
-    (detail) => detail["@type"] === "type.googleapis.com/google.rpc.RetryInfo",
-  )
-
-  if (!retryInfo?.retryDelay || typeof retryInfo.retryDelay !== "string") {
-    return undefined
-  }
-
-  // Parse retryDelay format: "5.123s"
-  const match = retryInfo.retryDelay.match(/^([\d.]+)s$/)
-  if (match?.[1]) {
-    const seconds = parseFloat(match[1])
-    if (!isNaN(seconds) && seconds > 0) {
-      return Math.ceil(seconds * 1000)
-    }
-  }
-
-  return undefined
-}
-
-/**
- * Parse error response body and extract useful details
- *
- * @param text - Raw response text
- * @returns Parsed error or undefined
- */
-export function parseErrorBody(text: string): AntigravityError | undefined {
-  try {
-    const parsed = JSON.parse(text) as Record<string, unknown>
-
-    // Handle error wrapper
-    if (parsed.error && typeof parsed.error === "object") {
-      const errorObj = parsed.error as Record<string, unknown>
-      return {
-        message: String(errorObj.message || "Unknown error"),
-        type: errorObj.type ? String(errorObj.type) : undefined,
-        code: errorObj.code as string | number | undefined,
-      }
-    }
-
-    // Handle direct error message
-    if (parsed.message && typeof parsed.message === "string") {
-      return {
-        message: parsed.message,
-        type: parsed.type ? String(parsed.type) : undefined,
-        code: parsed.code as string | number | undefined,
-      }
-    }
-
-    return undefined
-  } catch {
-    // If not valid JSON, return generic error
-    return {
-      message: text || "Unknown error",
-    }
-  }
-}
-
-/**
- * Transform a non-streaming Antigravity response to OpenAI-compatible format
- *
- * For non-streaming responses:
- * - Parses the response body
- * - Unwraps the `response` field if present (Antigravity wraps responses)
- * - Extracts usage metadata from headers
- * - Handles error responses
- *
- * Note: Does NOT handle thinking block extraction (Task 10)
- * Note: Does NOT handle tool normalization (Task 9)
- *
- * @param response - Fetch Response object
- * @returns TransformResult with transformed response and metadata
- */
-export async function transformResponse(response: Response): Promise<TransformResult> {
-  const headers = new Headers(response.headers)
-  const usage = extractUsageFromHeaders(headers)
-
-  // Handle error responses
-  if (!response.ok) {
-    const text = await response.text()
-    const error = parseErrorBody(text)
-    const retryAfterMs = extractRetryAfterMs(response, error ? { error } : undefined)
-
-    // Parse to get full error body for retry-after extraction
-    let errorBody: Record<string, unknown> | undefined
-    try {
-      errorBody = JSON.parse(text) as Record<string, unknown>
-    } catch {
-      errorBody = { error: { message: text } }
-    }
-
-    const retryMs = extractRetryAfterMs(response, errorBody) ?? retryAfterMs
-
-    // Set retry headers if found
-    if (retryMs) {
-      headers.set("Retry-After", String(Math.ceil(retryMs / 1000)))
-      headers.set("retry-after-ms", String(retryMs))
-    }
-
-    return {
-      response: new Response(text, {
-        status: response.status,
-        statusText: response.statusText,
-        headers,
-      }),
-      usage,
-      retryAfterMs: retryMs,
-      error,
-    }
-  }
-
-  // Handle successful response
-  const contentType = response.headers.get("content-type") ?? ""
-  const isJson = contentType.includes("application/json")
-
-  if (!isJson) {
-    // Return non-JSON responses as-is
-    return { response, usage }
-  }
-
-  try {
-    const text = await response.text()
-    const parsed = JSON.parse(text) as Record<string, unknown>
-
-    // Antigravity wraps response in { response: { ... } }
-    // Unwrap if present
-    let transformedBody: unknown = parsed
-    if (parsed.response !== undefined) {
-      transformedBody = parsed.response
-    }
-
-    return {
-      response: new Response(JSON.stringify(transformedBody), {
-        status: response.status,
-        statusText: response.statusText,
-        headers,
-      }),
-      usage,
-    }
-  } catch {
-    // If parsing fails, return original response
-    return { response, usage }
-  }
-}
-
-/**
- * Transform a single SSE data line
- *
- * Antigravity SSE format:
- * data: { "response": { ... actual data ... } }
- *
- * OpenAI SSE format:
- * data: { ... actual data ... }
- *
- * @param line - SSE data line
- * @returns Transformed line
- */
-function transformSseLine(line: string): string {
-  if (!line.startsWith("data:")) {
-    return line
-  }
-
-  const json = line.slice(5).trim()
-  if (!json || json === "[DONE]") {
-    return line
-  }
-
-  try {
-    const parsed = JSON.parse(json) as Record<string, unknown>
-
-    // Unwrap { response: { ... } } wrapper
-    if (parsed.response !== undefined) {
-      return `data: ${JSON.stringify(parsed.response)}`
-    }
-
-    return line
-  } catch {
-    // If parsing fails, return original line
-    return line
-  }
-}
-
-/**
- * Transform SSE streaming payload
- *
- * Processes each line in the SSE stream:
- * - Unwraps { response: { ... } } wrapper from data lines
- * - Preserves other SSE control lines (event:, id:, retry:, empty lines)
- *
- * Note: Does NOT extract thinking blocks (Task 10)
- *
- * @param payload - Raw SSE payload text
- * @returns Transformed SSE payload
- */
-export function transformStreamingPayload(payload: string): string {
-  return payload
-    .split("\n")
-    .map(transformSseLine)
-    .join("\n")
-}
-
-function createSseTransformStream(): TransformStream<Uint8Array, Uint8Array> {
-  const decoder = new TextDecoder()
-  const encoder = new TextEncoder()
-  let buffer = ""
-
-  return new TransformStream({
-    transform(chunk, controller) {
-      buffer += decoder.decode(chunk, { stream: true })
-      const lines = buffer.split("\n")
-      buffer = lines.pop() || ""
-
-      for (const line of lines) {
-        const transformed = transformSseLine(line)
-        controller.enqueue(encoder.encode(transformed + "\n"))
-      }
-    },
-    flush(controller) {
-      if (buffer) {
-        const transformed = transformSseLine(buffer)
-        controller.enqueue(encoder.encode(transformed))
-      }
-    },
-  })
-}
-
-/**
- * Transforms a streaming SSE response from Antigravity to OpenAI format.
- *
- * Uses TransformStream to process SSE chunks incrementally as they arrive.
- * Each line is transformed immediately and yielded to the client.
- *
- * @param response - The SSE response from Antigravity API
- * @returns TransformResult with transformed streaming response
- */
-export async function transformStreamingResponse(response: Response): Promise<TransformResult> {
-  const headers = new Headers(response.headers)
-  const usage = extractUsageFromHeaders(headers)
-
-  // Handle error responses
-  if (!response.ok) {
-    const text = await response.text()
-    const error = parseErrorBody(text)
-
-    let errorBody: Record<string, unknown> | undefined
-    try {
-      errorBody = JSON.parse(text) as Record<string, unknown>
-    } catch {
-      errorBody = { error: { message: text } }
-    }
-
-    const retryAfterMs = extractRetryAfterMs(response, errorBody)
-
-    if (retryAfterMs) {
-      headers.set("Retry-After", String(Math.ceil(retryAfterMs / 1000)))
-      headers.set("retry-after-ms", String(retryAfterMs))
-    }
-
-    return {
-      response: new Response(text, {
-        status: response.status,
-        statusText: response.statusText,
-        headers,
-      }),
-      usage,
-      retryAfterMs,
-      error,
-    }
-  }
-
-  // Check content type
-  const contentType = response.headers.get("content-type") ?? ""
-  const isEventStream =
-    contentType.includes("text/event-stream") || response.url.includes("alt=sse")
-
-  if (!isEventStream) {
-    // Not SSE, delegate to non-streaming transform
-    // Clone response since we need to read it
-    const text = await response.text()
-    try {
-      const parsed = JSON.parse(text) as Record<string, unknown>
-      let transformedBody: unknown = parsed
-      if (parsed.response !== undefined) {
-        transformedBody = parsed.response
-      }
-      return {
-        response: new Response(JSON.stringify(transformedBody), {
-          status: response.status,
-          statusText: response.statusText,
-          headers,
-        }),
-        usage,
-      }
-    } catch {
-      return {
-        response: new Response(text, {
-          status: response.status,
-          statusText: response.statusText,
-          headers,
-        }),
-        usage,
-      }
-    }
-  }
-
-  if (!response.body) {
-    return { response, usage }
-  }
-
-  headers.delete("content-length")
-  headers.delete("content-encoding")
-  headers.set("content-type", "text/event-stream; charset=utf-8")
-
-  const transformStream = createSseTransformStream()
-  const transformedBody = response.body.pipeThrough(transformStream)
-
-  return {
-    response: new Response(transformedBody, {
-      status: response.status,
-      statusText: response.statusText,
-      headers,
-    }),
-    usage,
-  }
-}
-
-/**
- * Check if response is a streaming SSE response
- *
- * @param response - Fetch Response object
- * @returns True if response is SSE stream
- */
-export function isStreamingResponse(response: Response): boolean {
-  const contentType = response.headers.get("content-type") ?? ""
-  return contentType.includes("text/event-stream") || response.url.includes("alt=sse")
-}
-
-/**
- * Extract thought signature from SSE payload text
- *
- * Looks for thoughtSignature in SSE events:
- * data: { "response": { "candidates": [{ "content": { "parts": [{ "thoughtSignature": "..." }] } }] } }
- *
- * Returns the last found signature (most recent in the stream).
- *
- * @param payload - SSE payload text
- * @returns Last thought signature if found
- */
-export function extractSignatureFromSsePayload(payload: string): string | undefined {
-  const lines = payload.split("\n")
-  let lastSignature: string | undefined
-
-  for (const line of lines) {
-    if (!line.startsWith("data:")) {
-      continue
-    }
-
-    const json = line.slice(5).trim()
-    if (!json || json === "[DONE]") {
-      continue
-    }
-
-    try {
-      const parsed = JSON.parse(json) as Record<string, unknown>
-
-      // Check in response wrapper (Antigravity format)
-      const response = (parsed.response || parsed) as Record<string, unknown>
-      const candidates = response.candidates as Array<Record<string, unknown>> | undefined
-
-      if (candidates && Array.isArray(candidates)) {
-        for (const candidate of candidates) {
-          const content = candidate.content as Record<string, unknown> | undefined
-          const parts = content?.parts as Array<Record<string, unknown>> | undefined
-
-          if (parts && Array.isArray(parts)) {
-            for (const part of parts) {
-              const sig = (part.thoughtSignature || part.thought_signature) as string | undefined
-              if (sig && typeof sig === "string") {
-                lastSignature = sig
-              }
-            }
-          }
-        }
-      }
-    } catch {
-      // Continue to next line if parsing fails
-    }
-  }
-
-  return lastSignature
-}
-
-/**
- * Extract usage from SSE payload text
- *
- * Looks for usageMetadata in SSE events:
- * data: { "usageMetadata": { ... } }
- *
- * @param payload - SSE payload text
- * @returns Usage if found
- */
-export function extractUsageFromSsePayload(payload: string): AntigravityUsage | undefined {
-  const lines = payload.split("\n")
-
-  for (const line of lines) {
-    if (!line.startsWith("data:")) {
-      continue
-    }
-
-    const json = line.slice(5).trim()
-    if (!json || json === "[DONE]") {
-      continue
-    }
-
-    try {
-      const parsed = JSON.parse(json) as Record<string, unknown>
-
-      // Check for usageMetadata at top level
-      if (parsed.usageMetadata && typeof parsed.usageMetadata === "object") {
-        const meta = parsed.usageMetadata as Record<string, unknown>
-        return {
-          prompt_tokens: typeof meta.promptTokenCount === "number" ? meta.promptTokenCount : 0,
-          completion_tokens:
-            typeof meta.candidatesTokenCount === "number" ? meta.candidatesTokenCount : 0,
-          total_tokens: typeof meta.totalTokenCount === "number" ? meta.totalTokenCount : 0,
-        }
-      }
-
-      // Check for usage in response wrapper
-      if (parsed.response && typeof parsed.response === "object") {
-        const resp = parsed.response as Record<string, unknown>
-        if (resp.usageMetadata && typeof resp.usageMetadata === "object") {
-          const meta = resp.usageMetadata as Record<string, unknown>
-          return {
-            prompt_tokens: typeof meta.promptTokenCount === "number" ? meta.promptTokenCount : 0,
-            completion_tokens:
-              typeof meta.candidatesTokenCount === "number" ? meta.candidatesTokenCount : 0,
-            total_tokens: typeof meta.totalTokenCount === "number" ? meta.totalTokenCount : 0,
-          }
-        }
-      }
-
-      // Check for standard OpenAI-style usage
-      if (parsed.usage && typeof parsed.usage === "object") {
-        const u = parsed.usage as Record<string, unknown>
-        return {
-          prompt_tokens: typeof u.prompt_tokens === "number" ? u.prompt_tokens : 0,
-          completion_tokens: typeof u.completion_tokens === "number" ? u.completion_tokens : 0,
-          total_tokens: typeof u.total_tokens === "number" ? u.total_tokens : 0,
-        }
-      }
-    } catch {
-      // Continue to next line if parsing fails
-    }
-  }
-
-  return undefined
-}

src/auth/antigravity/thinking.ts

@@ -1,571 +0,0 @@
-/**
- * Antigravity Thinking Block Handler (Gemini only)
- *
- * Handles extraction and transformation of thinking/reasoning blocks
- * from Gemini responses. Thinking blocks contain the model's internal
- * reasoning process, available in `-high` model variants.
- *
- * Key responsibilities:
- * - Extract thinking blocks from Gemini response format
- * - Detect thinking-capable model variants (`-high` suffix)
- * - Format thinking blocks for OpenAI-compatible output
- *
- * Note: This is Gemini-only. Claude models are NOT handled by Antigravity.
- */
-
-/**
- * Represents a single thinking/reasoning block extracted from Gemini response
- */
-export interface ThinkingBlock {
-  /** The thinking/reasoning text content */
-  text: string
-  /** Optional signature for signed thinking blocks (required for multi-turn) */
-  signature?: string
-  /** Index of the thinking block in sequence */
-  index?: number
-}
-
-/**
- * Raw part structure from Gemini response candidates
- */
-export interface GeminiPart {
-  /** Text content of the part */
-  text?: string
-  /** Whether this part is a thinking/reasoning block */
-  thought?: boolean
-  /** Signature for signed thinking blocks */
-  thoughtSignature?: string
-  /** Type field for Anthropic-style format */
-  type?: string
-  /** Signature field for Anthropic-style format */
-  signature?: string
-}
-
-/**
- * Gemini response candidate structure
- */
-export interface GeminiCandidate {
-  /** Content containing parts */
-  content?: {
-    /** Role of the content (e.g., "model", "assistant") */
-    role?: string
-    /** Array of content parts */
-    parts?: GeminiPart[]
-  }
-  /** Index of the candidate */
-  index?: number
-}
-
-/**
- * Gemini response structure for thinking block extraction
- */
-export interface GeminiResponse {
-  /** Response ID */
-  id?: string
-  /** Array of response candidates */
-  candidates?: GeminiCandidate[]
-  /** Direct content (some responses use this instead of candidates) */
-  content?: Array<{
-    type?: string
-    text?: string
-    signature?: string
-  }>
-  /** Model used for response */
-  model?: string
-}
-
-/**
- * Result of thinking block extraction
- */
-export interface ThinkingExtractionResult {
-  /** Extracted thinking blocks */
-  thinkingBlocks: ThinkingBlock[]
-  /** Combined thinking text for convenience */
-  combinedThinking: string
-  /** Whether any thinking blocks were found */
-  hasThinking: boolean
-}
-
-/**
- * Default thinking budget in tokens for thinking-enabled models
- */
-export const DEFAULT_THINKING_BUDGET = 16000
-
-/**
- * Check if a model variant should include thinking blocks
- *
- * Returns true for model variants with `-high` suffix, which have
- * extended thinking capability enabled.
- *
- * Examples:
- * - `gemini-3-pro-high` → true
- * - `gemini-2.5-pro-high` → true
- * - `gemini-3-pro-preview` → false
- * - `gemini-2.5-pro` → false
- *
- * @param model - Model identifier string
- * @returns True if model should include thinking blocks
- */
-export function shouldIncludeThinking(model: string): boolean {
-  if (!model || typeof model !== "string") {
-    return false
-  }
-
-  const lowerModel = model.toLowerCase()
-
-  // Check for -high suffix (primary indicator of thinking capability)
-  if (lowerModel.endsWith("-high")) {
-    return true
-  }
-
-  // Also check for explicit thinking in model name
-  if (lowerModel.includes("thinking")) {
-    return true
-  }
-
-  return false
-}
-
-/**
- * Check if a model is thinking-capable (broader check)
- *
- * This is a broader check than shouldIncludeThinking - it detects models
- * that have thinking capability, even if not explicitly requesting thinking output.
- *
- * @param model - Model identifier string
- * @returns True if model supports thinking/reasoning
- */
-export function isThinkingCapableModel(model: string): boolean {
-  if (!model || typeof model !== "string") {
-    return false
-  }
-
-  const lowerModel = model.toLowerCase()
-
-  return (
-    lowerModel.includes("thinking") ||
-    lowerModel.includes("gemini-3") ||
-    lowerModel.endsWith("-high")
-  )
-}
-
-/**
- * Check if a part is a thinking/reasoning block
- *
- * Detects both Gemini-style (thought: true) and Anthropic-style
- * (type: "thinking" or type: "reasoning") formats.
- *
- * @param part - Content part to check
- * @returns True if part is a thinking block
- */
-function isThinkingPart(part: GeminiPart): boolean {
-  // Gemini-style: thought flag
-  if (part.thought === true) {
-    return true
-  }
-
-  // Anthropic-style: type field
-  if (part.type === "thinking" || part.type === "reasoning") {
-    return true
-  }
-
-  return false
-}
-
-/**
- * Check if a thinking part has a valid signature
- *
- * Signatures are required for multi-turn conversations with Claude models.
- * Gemini uses `thoughtSignature`, Anthropic uses `signature`.
- *
- * @param part - Thinking part to check
- * @returns True if part has valid signature
- */
-function hasValidSignature(part: GeminiPart): boolean {
-  // Gemini-style signature
-  if (part.thought === true && part.thoughtSignature) {
-    return true
-  }
-
-  // Anthropic-style signature
-  if ((part.type === "thinking" || part.type === "reasoning") && part.signature) {
-    return true
-  }
-
-  return false
-}
-
-/**
- * Extract thinking blocks from a Gemini response
- *
- * Parses the response structure to identify and extract all thinking/reasoning
- * content. Supports both Gemini-style (thought: true) and Anthropic-style
- * (type: "thinking") formats.
- *
- * @param response - Gemini response object
- * @returns Extraction result with thinking blocks and metadata
- */
-export function extractThinkingBlocks(response: GeminiResponse): ThinkingExtractionResult {
-  const thinkingBlocks: ThinkingBlock[] = []
-
-  // Handle candidates array (standard Gemini format)
-  if (response.candidates && Array.isArray(response.candidates)) {
-    for (const candidate of response.candidates) {
-      const parts = candidate.content?.parts
-      if (!parts || !Array.isArray(parts)) {
-        continue
-      }
-
-      for (let i = 0; i < parts.length; i++) {
-        const part = parts[i]
-        if (!part || typeof part !== "object") {
-          continue
-        }
-
-        if (isThinkingPart(part)) {
-          const block: ThinkingBlock = {
-            text: part.text || "",
-            index: thinkingBlocks.length,
-          }
-
-          // Extract signature if present
-          if (part.thought === true && part.thoughtSignature) {
-            block.signature = part.thoughtSignature
-          } else if (part.signature) {
-            block.signature = part.signature
-          }
-
-          thinkingBlocks.push(block)
-        }
-      }
-    }
-  }
-
-  // Handle direct content array (Anthropic-style response)
-  if (response.content && Array.isArray(response.content)) {
-    for (let i = 0; i < response.content.length; i++) {
-      const item = response.content[i]
-      if (!item || typeof item !== "object") {
-        continue
-      }
-
-      if (item.type === "thinking" || item.type === "reasoning") {
-        thinkingBlocks.push({
-          text: item.text || "",
-          signature: item.signature,
-          index: thinkingBlocks.length,
-        })
-      }
-    }
-  }
-
-  // Combine all thinking text
-  const combinedThinking = thinkingBlocks.map((b) => b.text).join("\n\n")
-
-  return {
-    thinkingBlocks,
-    combinedThinking,
-    hasThinking: thinkingBlocks.length > 0,
-  }
-}
-
-/**
- * Format thinking blocks for OpenAI-compatible output
- *
- * Converts Gemini thinking block format to OpenAI's expected structure.
- * OpenAI expects thinking content as special message blocks or annotations.
- *
- * Output format:
- * ```
- * [
- *   { type: "reasoning", text: "thinking content...", signature?: "..." },
- *   ...
- * ]
- * ```
- *
- * @param thinking - Array of thinking blocks to format
- * @returns OpenAI-compatible formatted array
- */
-export function formatThinkingForOpenAI(
-  thinking: ThinkingBlock[],
-): Array<{ type: "reasoning"; text: string; signature?: string }> {
-  if (!thinking || !Array.isArray(thinking) || thinking.length === 0) {
-    return []
-  }
-
-  return thinking.map((block) => {
-    const formatted: { type: "reasoning"; text: string; signature?: string } = {
-      type: "reasoning",
-      text: block.text || "",
-    }
-
-    if (block.signature) {
-      formatted.signature = block.signature
-    }
-
-    return formatted
-  })
-}
-
-/**
- * Transform thinking parts in a candidate to OpenAI format
- *
- * Modifies candidate content parts to use OpenAI-style reasoning format
- * while preserving the rest of the response structure.
- *
- * @param candidate - Gemini candidate to transform
- * @returns Transformed candidate with reasoning-formatted thinking
- */
-export function transformCandidateThinking(candidate: GeminiCandidate): GeminiCandidate {
-  if (!candidate || typeof candidate !== "object") {
-    return candidate
-  }
-
-  const content = candidate.content
-  if (!content || typeof content !== "object" || !Array.isArray(content.parts)) {
-    return candidate
-  }
-
-  const thinkingTexts: string[] = []
-  const transformedParts = content.parts.map((part) => {
-    if (part && typeof part === "object" && part.thought === true) {
-      thinkingTexts.push(part.text || "")
-      // Transform to reasoning format
-      return {
-        ...part,
-        type: "reasoning" as const,
-        thought: undefined, // Remove Gemini-specific field
-      }
-    }
-    return part
-  })
-
-  const result: GeminiCandidate & { reasoning_content?: string } = {
-    ...candidate,
-    content: { ...content, parts: transformedParts },
-  }
-
-  // Add combined reasoning content for convenience
-  if (thinkingTexts.length > 0) {
-    result.reasoning_content = thinkingTexts.join("\n\n")
-  }
-
-  return result
-}
-
-/**
- * Transform Anthropic-style thinking blocks to reasoning format
- *
- * Converts `type: "thinking"` blocks to `type: "reasoning"` for consistency.
- *
- * @param content - Array of content blocks
- * @returns Transformed content array
- */
-export function transformAnthropicThinking(
-  content: Array<{ type?: string; text?: string; signature?: string }>,
-): Array<{ type?: string; text?: string; signature?: string }> {
-  if (!content || !Array.isArray(content)) {
-    return content
-  }
-
-  return content.map((block) => {
-    if (block && typeof block === "object" && block.type === "thinking") {
-      return {
-        type: "reasoning",
-        text: block.text || "",
-        ...(block.signature ? { signature: block.signature } : {}),
-      }
-    }
-    return block
-  })
-}
-
-/**
- * Filter out unsigned thinking blocks
- *
- * Claude API requires signed thinking blocks for multi-turn conversations.
- * This function removes thinking blocks without valid signatures.
- *
- * @param parts - Array of content parts
- * @returns Filtered array without unsigned thinking blocks
- */
-export function filterUnsignedThinkingBlocks(parts: GeminiPart[]): GeminiPart[] {
-  if (!parts || !Array.isArray(parts)) {
-    return parts
-  }
-
-  return parts.filter((part) => {
-    if (!part || typeof part !== "object") {
-      return true
-    }
-
-    // If it's a thinking part, only keep it if signed
-    if (isThinkingPart(part)) {
-      return hasValidSignature(part)
-    }
-
-    // Keep all non-thinking parts
-    return true
-  })
-}
-
-/**
- * Transform entire response thinking parts
- *
- * Main transformation function that handles both Gemini-style and
- * Anthropic-style thinking blocks in a response.
- *
- * @param response - Response object to transform
- * @returns Transformed response with standardized reasoning format
- */
-export function transformResponseThinking(response: GeminiResponse): GeminiResponse {
-  if (!response || typeof response !== "object") {
-    return response
-  }
-
-  const result: GeminiResponse = { ...response }
-
-  // Transform candidates (Gemini-style)
-  if (Array.isArray(result.candidates)) {
-    result.candidates = result.candidates.map(transformCandidateThinking)
-  }
-
-  // Transform direct content (Anthropic-style)
-  if (Array.isArray(result.content)) {
-    result.content = transformAnthropicThinking(result.content)
-  }
-
-  return result
-}
-
-/**
- * Thinking configuration for requests
- */
-export interface ThinkingConfig {
-  /** Token budget for thinking/reasoning */
-  thinkingBudget?: number
-  /** Whether to include thoughts in response */
-  includeThoughts?: boolean
-}
-
-/**
- * Normalize thinking configuration
- *
- * Ensures thinkingConfig is valid: includeThoughts only allowed when budget > 0.
- *
- * @param config - Raw thinking configuration
- * @returns Normalized configuration or undefined
- */
-export function normalizeThinkingConfig(config: unknown): ThinkingConfig | undefined {
-  if (!config || typeof config !== "object") {
-    return undefined
-  }
-
-  const record = config as Record<string, unknown>
-  const budgetRaw = record.thinkingBudget ?? record.thinking_budget
-  const includeRaw = record.includeThoughts ?? record.include_thoughts
-
-  const thinkingBudget =
-    typeof budgetRaw === "number" && Number.isFinite(budgetRaw) ? budgetRaw : undefined
-  const includeThoughts = typeof includeRaw === "boolean" ? includeRaw : undefined
-
-  const enableThinking = thinkingBudget !== undefined && thinkingBudget > 0
-  const finalInclude = enableThinking ? (includeThoughts ?? false) : false
-
-  // Return undefined if no meaningful config
-  if (
-    !enableThinking &&
-    finalInclude === false &&
-    thinkingBudget === undefined &&
-    includeThoughts === undefined
-  ) {
-    return undefined
-  }
-
-  const normalized: ThinkingConfig = {}
-  if (thinkingBudget !== undefined) {
-    normalized.thinkingBudget = thinkingBudget
-  }
-  if (finalInclude !== undefined) {
-    normalized.includeThoughts = finalInclude
-  }
-  return normalized
-}
-
-/**
- * Extract thinking configuration from request payload
- *
- * Supports both Gemini-style thinkingConfig and Anthropic-style thinking options.
- *
- * @param requestPayload - Request body
- * @param generationConfig - Generation config from request
- * @param extraBody - Extra body options
- * @returns Extracted thinking configuration or undefined
- */
-export function extractThinkingConfig(
-  requestPayload: Record<string, unknown>,
-  generationConfig?: Record<string, unknown>,
-  extraBody?: Record<string, unknown>,
-): ThinkingConfig | undefined {
-  // Check for explicit thinkingConfig
-  const thinkingConfig =
-    generationConfig?.thinkingConfig ?? extraBody?.thinkingConfig ?? requestPayload.thinkingConfig
-
-  if (thinkingConfig && typeof thinkingConfig === "object") {
-    const config = thinkingConfig as Record<string, unknown>
-    return {
-      includeThoughts: Boolean(config.includeThoughts),
-      thinkingBudget:
-        typeof config.thinkingBudget === "number" ? config.thinkingBudget : DEFAULT_THINKING_BUDGET,
-    }
-  }
-
-  // Convert Anthropic-style "thinking" option: { type: "enabled", budgetTokens: N }
-  const anthropicThinking = extraBody?.thinking ?? requestPayload.thinking
-  if (anthropicThinking && typeof anthropicThinking === "object") {
-    const thinking = anthropicThinking as Record<string, unknown>
-    if (thinking.type === "enabled" || thinking.budgetTokens) {
-      return {
-        includeThoughts: true,
-        thinkingBudget:
-          typeof thinking.budgetTokens === "number"
-            ? thinking.budgetTokens
-            : DEFAULT_THINKING_BUDGET,
-      }
-    }
-  }
-
-  return undefined
-}
-
-/**
- * Resolve final thinking configuration based on model and context
- *
- * Handles special cases like Claude models requiring signed thinking blocks
- * for multi-turn conversations.
- *
- * @param userConfig - User-provided thinking configuration
- * @param isThinkingModel - Whether model supports thinking
- * @param isClaudeModel - Whether model is Claude (not used in Antigravity, but kept for compatibility)
- * @param hasAssistantHistory - Whether conversation has assistant history
- * @returns Final thinking configuration
- */
-export function resolveThinkingConfig(
-  userConfig: ThinkingConfig | undefined,
-  isThinkingModel: boolean,
-  isClaudeModel: boolean,
-  hasAssistantHistory: boolean,
-): ThinkingConfig | undefined {
-  // Claude models with history need signed thinking blocks
-  // Since we can't guarantee signatures, disable thinking
-  if (isClaudeModel && hasAssistantHistory) {
-    return { includeThoughts: false, thinkingBudget: 0 }
-  }
-
-  // Enable thinking by default for thinking-capable models
-  if (isThinkingModel && !userConfig) {
-    return { includeThoughts: true, thinkingBudget: DEFAULT_THINKING_BUDGET }
-  }
-
-  return userConfig
-}

src/auth/antigravity/thought-signature-store.ts

@@ -1,97 +0,0 @@
-/**
- * Thought Signature Store
- *
- * Stores and retrieves thought signatures for multi-turn conversations.
- * Gemini 3 Pro requires thought_signature on function call content blocks
- * in subsequent requests to maintain reasoning continuity.
- *
- * Key responsibilities:
- * - Store the latest thought signature per session
- * - Provide signature for injection into function call requests
- * - Clear signatures when sessions end
- */
-
-/**
- * In-memory store for thought signatures indexed by session ID
- */
-const signatureStore = new Map<string, string>()
-
-/**
- * In-memory store for session IDs per fetch instance
- * Used to maintain consistent sessionId across multi-turn conversations
- */
-const sessionIdStore = new Map<string, string>()
-
-/**
- * Store a thought signature for a session
- *
- * @param sessionKey - Unique session identifier (typically fetch instance ID)
- * @param signature - The thought signature from model response
- */
-export function setThoughtSignature(sessionKey: string, signature: string): void {
-  if (sessionKey && signature) {
-    signatureStore.set(sessionKey, signature)
-  }
-}
-
-/**
- * Retrieve the stored thought signature for a session
- *
- * @param sessionKey - Unique session identifier
- * @returns The stored signature or undefined if not found
- */
-export function getThoughtSignature(sessionKey: string): string | undefined {
-  return signatureStore.get(sessionKey)
-}
-
-/**
- * Clear the thought signature for a session
- *
- * @param sessionKey - Unique session identifier
- */
-export function clearThoughtSignature(sessionKey: string): void {
-  signatureStore.delete(sessionKey)
-}
-
-/**
- * Store or retrieve a persistent session ID for a fetch instance
- *
- * @param fetchInstanceId - Unique identifier for the fetch instance
- * @param sessionId - Optional session ID to store (if not provided, returns existing or generates new)
- * @returns The session ID for this fetch instance
- */
-export function getOrCreateSessionId(fetchInstanceId: string, sessionId?: string): string {
-  if (sessionId) {
-    sessionIdStore.set(fetchInstanceId, sessionId)
-    return sessionId
-  }
-
-  const existing = sessionIdStore.get(fetchInstanceId)
-  if (existing) {
-    return existing
-  }
-
-  const n = Math.floor(Math.random() * Number.MAX_SAFE_INTEGER)
-  const newSessionId = `-${n}`
-  sessionIdStore.set(fetchInstanceId, newSessionId)
-  return newSessionId
-}
-
-/**
- * Clear the session ID for a fetch instance
- *
- * @param fetchInstanceId - Unique identifier for the fetch instance
- */
-export function clearSessionId(fetchInstanceId: string): void {
-  sessionIdStore.delete(fetchInstanceId)
-}
-
-/**
- * Clear all stored data for a fetch instance (signature + session ID)
- *
- * @param fetchInstanceId - Unique identifier for the fetch instance
- */
-export function clearFetchInstanceData(fetchInstanceId: string): void {
-  signatureStore.delete(fetchInstanceId)
-  sessionIdStore.delete(fetchInstanceId)
-}

src/auth/antigravity/token.ts

@@ -1,213 +0,0 @@
-import {
-  ANTIGRAVITY_CLIENT_ID,
-  ANTIGRAVITY_CLIENT_SECRET,
-  ANTIGRAVITY_TOKEN_REFRESH_BUFFER_MS,
-  GOOGLE_TOKEN_URL,
-} from "./constants"
-import type {
-  AntigravityRefreshParts,
-  AntigravityTokenExchangeResult,
-  AntigravityTokens,
-  OAuthErrorPayload,
-  ParsedOAuthError,
-} from "./types"
-
-export class AntigravityTokenRefreshError extends Error {
-  code?: string
-  description?: string
-  status: number
-  statusText: string
-  responseBody?: string
-
-  constructor(options: {
-    message: string
-    code?: string
-    description?: string
-    status: number
-    statusText: string
-    responseBody?: string
-  }) {
-    super(options.message)
-    this.name = "AntigravityTokenRefreshError"
-    this.code = options.code
-    this.description = options.description
-    this.status = options.status
-    this.statusText = options.statusText
-    this.responseBody = options.responseBody
-  }
-
-  get isInvalidGrant(): boolean {
-    return this.code === "invalid_grant"
-  }
-
-  get isNetworkError(): boolean {
-    return this.status === 0
-  }
-}
-
-function parseOAuthErrorPayload(text: string | undefined): ParsedOAuthError {
-  if (!text) {
-    return {}
-  }
-
-  try {
-    const payload = JSON.parse(text) as OAuthErrorPayload
-    let code: string | undefined
-
-    if (typeof payload.error === "string") {
-      code = payload.error
-    } else if (payload.error && typeof payload.error === "object") {
-      code = payload.error.status ?? payload.error.code
-    }
-
-    return {
-      code,
-      description: payload.error_description,
-    }
-  } catch {
-    return { description: text }
-  }
-}
-
-export function isTokenExpired(tokens: AntigravityTokens): boolean {
-  const expirationTime = tokens.timestamp + tokens.expires_in * 1000
-  return Date.now() >= expirationTime - ANTIGRAVITY_TOKEN_REFRESH_BUFFER_MS
-}
-
-const MAX_REFRESH_RETRIES = 3
-const INITIAL_RETRY_DELAY_MS = 1000
-
-function calculateRetryDelay(attempt: number): number {
-  return Math.min(INITIAL_RETRY_DELAY_MS * Math.pow(2, attempt), 10000)
-}
-
-function isRetryableError(status: number): boolean {
-  if (status === 0) return true
-  if (status === 429) return true
-  if (status >= 500 && status < 600) return true
-  return false
-}
-
-export async function refreshAccessToken(
-  refreshToken: string,
-  clientId: string = ANTIGRAVITY_CLIENT_ID,
-  clientSecret: string = ANTIGRAVITY_CLIENT_SECRET
-): Promise<AntigravityTokenExchangeResult> {
-  const params = new URLSearchParams({
-    grant_type: "refresh_token",
-    refresh_token: refreshToken,
-    client_id: clientId,
-    client_secret: clientSecret,
-  })
-
-  let lastError: AntigravityTokenRefreshError | undefined
-
-  for (let attempt = 0; attempt <= MAX_REFRESH_RETRIES; attempt++) {
-    try {
-      const response = await fetch(GOOGLE_TOKEN_URL, {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/x-www-form-urlencoded",
-        },
-        body: params,
-      })
-
-      if (response.ok) {
-        const data = (await response.json()) as {
-          access_token: string
-          refresh_token?: string
-          expires_in: number
-          token_type: string
-        }
-
-        return {
-          access_token: data.access_token,
-          refresh_token: data.refresh_token || refreshToken,
-          expires_in: data.expires_in,
-          token_type: data.token_type,
-        }
-      }
-
-      const responseBody = await response.text().catch(() => undefined)
-      const parsed = parseOAuthErrorPayload(responseBody)
-
-      lastError = new AntigravityTokenRefreshError({
-        message: parsed.description || `Token refresh failed: ${response.status} ${response.statusText}`,
-        code: parsed.code,
-        description: parsed.description,
-        status: response.status,
-        statusText: response.statusText,
-        responseBody,
-      })
-
-      if (parsed.code === "invalid_grant") {
-        throw lastError
-      }
-
-      if (!isRetryableError(response.status)) {
-        throw lastError
-      }
-
-      if (attempt < MAX_REFRESH_RETRIES) {
-        const delay = calculateRetryDelay(attempt)
-        await new Promise((resolve) => setTimeout(resolve, delay))
-      }
-    } catch (error) {
-      if (error instanceof AntigravityTokenRefreshError) {
-        throw error
-      }
-
-      lastError = new AntigravityTokenRefreshError({
-        message: error instanceof Error ? error.message : "Network error during token refresh",
-        status: 0,
-        statusText: "Network Error",
-      })
-
-      if (attempt < MAX_REFRESH_RETRIES) {
-        const delay = calculateRetryDelay(attempt)
-        await new Promise((resolve) => setTimeout(resolve, delay))
-      }
-    }
-  }
-
-  throw lastError || new AntigravityTokenRefreshError({
-    message: "Token refresh failed after all retries",
-    status: 0,
-    statusText: "Max Retries Exceeded",
-  })
-}
-
-/**
- * Parse a stored token string into its component parts.
- * Storage format: `refreshToken|projectId|managedProjectId`
- *
- * @param stored - The pipe-separated stored token string
- * @returns Parsed refresh parts with refreshToken, projectId, and optional managedProjectId
- */
-export function parseStoredToken(stored: string): AntigravityRefreshParts {
-  const parts = stored.split("|")
-  const [refreshToken, projectId, managedProjectId] = parts
-
-  return {
-    refreshToken: refreshToken || "",
-    projectId: projectId || undefined,
-    managedProjectId: managedProjectId || undefined,
-  }
-}
-
-/**
- * Format token components for storage.
- * Creates a pipe-separated string: `refreshToken|projectId|managedProjectId`
- *
- * @param refreshToken - The refresh token
- * @param projectId - The GCP project ID
- * @param managedProjectId - Optional managed project ID for enterprise users
- * @returns Formatted string for storage
- */
-export function formatTokenForStorage(
-  refreshToken: string,
-  projectId: string,
-  managedProjectId?: string
-): string {
-  return `${refreshToken}|${projectId}|${managedProjectId || ""}`
-}

src/auth/antigravity/tools.ts

@@ -1,243 +0,0 @@
-/**
- * Antigravity Tool Normalization
- * Converts tools between OpenAI and Gemini formats.
- *
- * OpenAI format:
- *   { "type": "function", "function": { "name": "x", "description": "...", "parameters": {...} } }
- *
- * Gemini format:
- *   { "functionDeclarations": [{ "name": "x", "description": "...", "parameters": {...} }] }
- *
- * Note: This is for Gemini models ONLY. Claude models are not supported via Antigravity.
- */
-
-/**
- * OpenAI function tool format
- */
-export interface OpenAITool {
-  type: string
-  function?: {
-    name: string
-    description?: string
-    parameters?: Record<string, unknown>
-  }
-}
-
-/**
- * Gemini function declaration format
- */
-export interface GeminiFunctionDeclaration {
-  name: string
-  description?: string
-  parameters?: Record<string, unknown>
-}
-
-/**
- * Gemini tools format (array of functionDeclarations)
- */
-export interface GeminiTools {
-  functionDeclarations: GeminiFunctionDeclaration[]
-}
-
-/**
- * OpenAI tool call in response
- */
-export interface OpenAIToolCall {
-  id: string
-  type: "function"
-  function: {
-    name: string
-    arguments: string
-  }
-}
-
-/**
- * Gemini function call in response
- */
-export interface GeminiFunctionCall {
-  name: string
-  args: Record<string, unknown>
-}
-
-/**
- * Gemini function response format
- */
-export interface GeminiFunctionResponse {
-  name: string
-  response: Record<string, unknown>
-}
-
-/**
- * Gemini tool result containing function calls
- */
-export interface GeminiToolResult {
-  functionCall?: GeminiFunctionCall
-  functionResponse?: GeminiFunctionResponse
-}
-
-/**
- * Normalize OpenAI-format tools to Gemini format.
- * Converts an array of OpenAI tools to Gemini's functionDeclarations format.
- *
- * - Handles `function` type tools with name, description, parameters
- * - Logs warning for unsupported tool types (does NOT silently drop them)
- * - Creates a single object with functionDeclarations array
- *
- * @param tools - Array of OpenAI-format tools
- * @returns Gemini-format tools object with functionDeclarations, or undefined if no valid tools
- */
-export function normalizeToolsForGemini(
-  tools: OpenAITool[]
-): GeminiTools | undefined {
-  if (!tools || tools.length === 0) {
-    return undefined
-  }
-
-  const functionDeclarations: GeminiFunctionDeclaration[] = []
-
-  for (const tool of tools) {
-    if (!tool || typeof tool !== "object") {
-      continue
-    }
-
-    const toolType = tool.type ?? "function"
-    if (toolType === "function" && tool.function) {
-      const declaration: GeminiFunctionDeclaration = {
-        name: tool.function.name,
-      }
-
-      if (tool.function.description) {
-        declaration.description = tool.function.description
-      }
-
-      if (tool.function.parameters) {
-        declaration.parameters = tool.function.parameters
-      } else {
-        declaration.parameters = { type: "object", properties: {} }
-      }
-
-      functionDeclarations.push(declaration)
-    } else if (toolType !== "function" && process.env.ANTIGRAVITY_DEBUG === "1") {
-      console.warn(
-        `[antigravity-tools] Unsupported tool type: "${toolType}". Tool will be skipped.`
-      )
-    }
-  }
-
-  // Return undefined if no valid function declarations
-  if (functionDeclarations.length === 0) {
-    return undefined
-  }
-
-  return { functionDeclarations }
-}
-
-/**
- * Convert Gemini tool results (functionCall) back to OpenAI tool_call format.
- * Handles both functionCall (request) and functionResponse (result) formats.
- *
- * Gemini functionCall format:
- *   { "name": "tool_name", "args": { ... } }
- *
- * OpenAI tool_call format:
- *   { "id": "call_xxx", "type": "function", "function": { "name": "tool_name", "arguments": "..." } }
- *
- * @param results - Array of Gemini tool results containing functionCall or functionResponse
- * @returns Array of OpenAI-format tool calls
- */
-export function normalizeToolResultsFromGemini(
-  results: GeminiToolResult[]
-): OpenAIToolCall[] {
-  if (!results || results.length === 0) {
-    return []
-  }
-
-  const toolCalls: OpenAIToolCall[] = []
-  let callCounter = 0
-
-  for (const result of results) {
-    // Handle functionCall (tool invocation from model)
-    if (result.functionCall) {
-      callCounter++
-      const toolCall: OpenAIToolCall = {
-        id: `call_${Date.now()}_${callCounter}`,
-        type: "function",
-        function: {
-          name: result.functionCall.name,
-          arguments: JSON.stringify(result.functionCall.args ?? {}),
-        },
-      }
-      toolCalls.push(toolCall)
-    }
-  }
-
-  return toolCalls
-}
-
-/**
- * Convert a single Gemini functionCall to OpenAI tool_call format.
- * Useful for streaming responses where each chunk may contain a function call.
- *
- * @param functionCall - Gemini function call
- * @param id - Optional tool call ID (generates one if not provided)
- * @returns OpenAI-format tool call
- */
-export function convertFunctionCallToToolCall(
-  functionCall: GeminiFunctionCall,
-  id?: string
-): OpenAIToolCall {
-  return {
-    id: id ?? `call_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`,
-    type: "function",
-    function: {
-      name: functionCall.name,
-      arguments: JSON.stringify(functionCall.args ?? {}),
-    },
-  }
-}
-
-/**
- * Check if a tool array contains any function-type tools.
- *
- * @param tools - Array of OpenAI-format tools
- * @returns true if there are function tools to normalize
- */
-export function hasFunctionTools(tools: OpenAITool[]): boolean {
-  if (!tools || tools.length === 0) {
-    return false
-  }
-
-  return tools.some((tool) => tool.type === "function" && tool.function)
-}
-
-/**
- * Extract function declarations from already-normalized Gemini tools.
- * Useful when tools may already be in Gemini format.
- *
- * @param tools - Tools that may be in Gemini or OpenAI format
- * @returns Array of function declarations
- */
-export function extractFunctionDeclarations(
-  tools: unknown
-): GeminiFunctionDeclaration[] {
-  if (!tools || typeof tools !== "object") {
-    return []
-  }
-
-  // Check if already in Gemini format
-  const geminiTools = tools as Record<string, unknown>
-  if (
-    Array.isArray(geminiTools.functionDeclarations) &&
-    geminiTools.functionDeclarations.length > 0
-  ) {
-    return geminiTools.functionDeclarations as GeminiFunctionDeclaration[]
-  }
-
-  // Check if it's an array of OpenAI tools
-  if (Array.isArray(tools)) {
-    const normalized = normalizeToolsForGemini(tools as OpenAITool[])
-    return normalized?.functionDeclarations ?? []
-  }
-
-  return []
-}

src/auth/antigravity/types.ts

@@ -1,213 +0,0 @@
-/**
- * Antigravity Auth Type Definitions
- * Matches cliproxyapi/sdk/auth/antigravity.go token format exactly
- */
-
-/**
- * Token storage format for Antigravity authentication
- * Matches Go metadata structure: type, access_token, refresh_token, expires_in, timestamp, email, project_id
- */
-export interface AntigravityTokens {
-  /** Always "antigravity" for this auth type */
-  type: "antigravity"
-  /** OAuth access token from Google */
-  access_token: string
-  /** OAuth refresh token from Google */
-  refresh_token: string
-  /** Token expiration time in seconds */
-  expires_in: number
-  /** Unix timestamp in milliseconds when tokens were obtained */
-  timestamp: number
-  /** ISO 8601 formatted expiration datetime (optional, for display) */
-  expired?: string
-  /** User's email address from Google userinfo */
-  email?: string
-  /** GCP project ID from loadCodeAssist API */
-  project_id?: string
-}
-
-/**
- * Project context returned from loadCodeAssist API
- * Used to get cloudaicompanionProject for API calls
- */
-export interface AntigravityProjectContext {
-  /** GCP project ID for Cloud AI Companion */
-  cloudaicompanionProject?: string
-  /** Managed project ID for enterprise users (optional) */
-  managedProjectId?: string
-}
-
-/**
- * Metadata for loadCodeAssist API request
- */
-export interface AntigravityClientMetadata {
-  /** IDE type identifier */
-  ideType: "IDE_UNSPECIFIED" | string
-  /** Platform identifier */
-  platform: "PLATFORM_UNSPECIFIED" | string
-  /** Plugin type - typically "GEMINI" */
-  pluginType: "GEMINI" | string
-}
-
-/**
- * Request body for loadCodeAssist API
- */
-export interface AntigravityLoadCodeAssistRequest {
-  metadata: AntigravityClientMetadata
-}
-
-export interface AntigravityUserTier {
-  id?: string
-  isDefault?: boolean
-  userDefinedCloudaicompanionProject?: boolean
-}
-
-export interface AntigravityLoadCodeAssistResponse {
-  cloudaicompanionProject?: string | { id: string }
-  currentTier?: { id?: string }
-  allowedTiers?: AntigravityUserTier[]
-}
-
-export interface AntigravityOnboardUserPayload {
-  done?: boolean
-  response?: {
-    cloudaicompanionProject?: { id?: string }
-  }
-}
-
-/**
- * Request body format for Antigravity API calls
- * Wraps the actual request with project and model context
- */
-export interface AntigravityRequestBody {
-  /** GCP project ID */
-  project: string
-  /** Model identifier (e.g., "gemini-3-pro-preview") */
-  model: string
-  /** User agent identifier */
-  userAgent: string
-  /** Unique request ID */
-  requestId: string
-  /** The actual request payload */
-  request: Record<string, unknown>
-}
-
-/**
- * Response format from Antigravity API
- * Follows OpenAI-compatible structure with Gemini extensions
- */
-export interface AntigravityResponse {
-  /** Response ID */
-  id?: string
-  /** Object type (e.g., "chat.completion") */
-  object?: string
-  /** Creation timestamp */
-  created?: number
-  /** Model used for response */
-  model?: string
-  /** Response choices */
-  choices?: AntigravityResponseChoice[]
-  /** Token usage statistics */
-  usage?: AntigravityUsage
-  /** Error information if request failed */
-  error?: AntigravityError
-}
-
-/**
- * Single response choice in Antigravity response
- */
-export interface AntigravityResponseChoice {
-  /** Choice index */
-  index: number
-  /** Message content */
-  message?: {
-    role: "assistant"
-    content?: string
-    tool_calls?: AntigravityToolCall[]
-  }
-  /** Delta for streaming responses */
-  delta?: {
-    role?: "assistant"
-    content?: string
-    tool_calls?: AntigravityToolCall[]
-  }
-  /** Finish reason */
-  finish_reason?: "stop" | "tool_calls" | "length" | "content_filter" | null
-}
-
-/**
- * Tool call in Antigravity response
- */
-export interface AntigravityToolCall {
-  id: string
-  type: "function"
-  function: {
-    name: string
-    arguments: string
-  }
-}
-
-/**
- * Token usage statistics
- */
-export interface AntigravityUsage {
-  prompt_tokens: number
-  completion_tokens: number
-  total_tokens: number
-}
-
-/**
- * Error response from Antigravity API
- */
-export interface AntigravityError {
-  message: string
-  type?: string
-  code?: string | number
-}
-
-/**
- * Token exchange result from Google OAuth
- * Matches antigravityTokenResponse in Go
- */
-export interface AntigravityTokenExchangeResult {
-  access_token: string
-  refresh_token: string
-  expires_in: number
-  token_type: string
-}
-
-/**
- * User info from Google userinfo API
- */
-export interface AntigravityUserInfo {
-  email: string
-  name?: string
-  picture?: string
-}
-
-/**
- * Parsed refresh token parts
- * Format: refreshToken|projectId|managedProjectId
- */
-export interface AntigravityRefreshParts {
-  refreshToken: string
-  projectId?: string
-  managedProjectId?: string
-}
-
-/**
- * OAuth error payload from Google
- * Google returns errors in multiple formats, this handles all of them
- */
-export interface OAuthErrorPayload {
-  error?: string | { status?: string; code?: string; message?: string }
-  error_description?: string
-}
-
-/**
- * Parsed OAuth error with normalized fields
- */
-export interface ParsedOAuthError {
-  code?: string
-  description?: string
-}

src/cli/AGENTS.md

@@ -1,93 +0,0 @@
-# CLI KNOWLEDGE BASE
-
-## OVERVIEW
-
-Command-line interface for oh-my-opencode. Interactive installer, health diagnostics (doctor), and runtime commands. Entry point: `bunx oh-my-opencode`.
-
-## STRUCTURE
-
-```
-cli/
-├── index.ts              # Commander.js entry point, subcommand routing
-├── install.ts            # Interactive TUI installer
-├── config-manager.ts     # Config detection, parsing, merging (669 lines)
-├── types.ts              # CLI-specific types
-├── doctor/               # Health check system
-│   ├── index.ts          # Doctor command entry
-│   ├── constants.ts      # Check categories, descriptions
-│   ├── types.ts          # Check result interfaces
-│   └── checks/           # 17 individual health checks
-├── get-local-version/    # Version detection utility
-│   ├── index.ts
-│   └── formatter.ts
-└── run/                  # OpenCode session launcher
-    ├── index.ts
-    └── completion.test.ts
-```
-
-## CLI COMMANDS
-
-| Command | Purpose | Key File |
-|---------|---------|----------|
-| `install` | Interactive setup wizard | `install.ts` |
-| `doctor` | Environment health checks | `doctor/index.ts` |
-| `run` | Launch OpenCode session | `run/index.ts` |
-
-## DOCTOR CHECKS
-
-17 checks in `doctor/checks/`:
-
-| Check | Validates |
-|-------|-----------|
-| `version.ts` | OpenCode version >= 1.0.150 |
-| `config.ts` | Plugin registered in opencode.json |
-| `bun.ts` | Bun runtime available |
-| `node.ts` | Node.js version compatibility |
-| `git.ts` | Git installed |
-| `anthropic-auth.ts` | Claude authentication |
-| `openai-auth.ts` | OpenAI authentication |
-| `google-auth.ts` | Google/Gemini authentication |
-| `lsp-*.ts` | Language server availability |
-| `mcp-*.ts` | MCP server connectivity |
-
-## INSTALLATION FLOW
-
-1. **Detection**: Find existing `opencode.json` / `opencode.jsonc`
-2. **TUI Prompts**: Claude subscription? ChatGPT? Gemini?
-3. **Config Generation**: Build `oh-my-opencode.json` based on answers
-4. **Plugin Registration**: Add to `plugin` array in opencode.json
-5. **Auth Guidance**: Instructions for `opencode auth login`
-
-## CONFIG-MANAGER
-
-The largest file (669 lines) handles:
-
-- **JSONC support**: Parses comments and trailing commas
-- **Multi-source detection**: User (~/.config/opencode/) + Project (.opencode/)
-- **Schema validation**: Zod-based config validation
-- **Migration**: Handles legacy config formats
-- **Error collection**: Aggregates parsing errors for doctor
-
-## HOW TO ADD A DOCTOR CHECK
-
-1. Create `src/cli/doctor/checks/my-check.ts`:
-   ```typescript
-   import type { DoctorCheck } from "../types"
-   
-   export const myCheck: DoctorCheck = {
-     name: "my-check",
-     category: "environment",
-     check: async () => {
-       // Return { status: "pass" | "warn" | "fail", message: string }
-     }
-   }
-   ```
-2. Add to `src/cli/doctor/checks/index.ts`
-3. Update `constants.ts` if new category
-
-## ANTI-PATTERNS (CLI)
-
-- **Blocking prompts in non-TTY**: Check `process.stdout.isTTY` before TUI
-- **Hardcoded paths**: Use shared utilities for config paths
-- **Ignoring JSONC**: User configs may have comments
-- **Silent failures**: Doctor checks must return clear status/message

src/cli/config-manager.test.ts

@@ -1,36 +0,0 @@
-import { describe, expect, test } from "bun:test"
-
-import { ANTIGRAVITY_PROVIDER_CONFIG } from "./config-manager"
-
-describe("config-manager ANTIGRAVITY_PROVIDER_CONFIG", () => {
-  test("Gemini models include full spec (limit + modalities)", () => {
-    const google = (ANTIGRAVITY_PROVIDER_CONFIG as any).google
-    expect(google).toBeTruthy()
-
-    const models = google.models as Record<string, any>
-    expect(models).toBeTruthy()
-
-    const required = [
-      "gemini-3-pro-high",
-      "gemini-3-pro-medium",
-      "gemini-3-pro-low",
-      "gemini-3-flash",
-      "gemini-3-flash-lite",
-    ]
-
-    for (const key of required) {
-      const model = models[key]
-      expect(model).toBeTruthy()
-      expect(typeof model.name).toBe("string")
-      expect(model.name.includes("(Antigravity)")).toBe(true)
-
-      expect(model.limit).toBeTruthy()
-      expect(typeof model.limit.context).toBe("number")
-      expect(typeof model.limit.output).toBe("number")
-
-      expect(model.modalities).toBeTruthy()
-      expect(Array.isArray(model.modalities.input)).toBe(true)
-      expect(Array.isArray(model.modalities.output)).toBe(true)
-    }
-  })
-})

src/cli/config-manager.ts

@@ -1,669 +0,0 @@
-import { existsSync, mkdirSync, readFileSync, writeFileSync, statSync } 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")
-const OPENCODE_JSON = join(OPENCODE_CONFIG_DIR, "opencode.json")
-const OPENCODE_JSONC = join(OPENCODE_CONFIG_DIR, "opencode.jsonc")
-const OPENCODE_PACKAGE_JSON = join(OPENCODE_CONFIG_DIR, "package.json")
-const OMO_CONFIG = join(OPENCODE_CONFIG_DIR, "oh-my-opencode.json")
-
-const OPENCODE_BINARIES = ["opencode", "opencode-desktop"] as const
-
-const CHATGPT_HOTFIX_REPO = "code-yeongyu/opencode-openai-codex-auth#fix/orphaned-function-call-output-with-tools"
-
-const BUN_INSTALL_TIMEOUT_SECONDS = 60
-const BUN_INSTALL_TIMEOUT_MS = BUN_INSTALL_TIMEOUT_SECONDS * 1000
-
-interface NodeError extends Error {
-  code?: string
-}
-
-function isPermissionError(err: unknown): boolean {
-  const nodeErr = err as NodeError
-  return nodeErr?.code === "EACCES" || nodeErr?.code === "EPERM"
-}
-
-function isFileNotFoundError(err: unknown): boolean {
-  const nodeErr = err as NodeError
-  return nodeErr?.code === "ENOENT"
-}
-
-function formatErrorWithSuggestion(err: unknown, context: string): string {
-  if (isPermissionError(err)) {
-    return `Permission denied: Cannot ${context}. Try running with elevated permissions or check file ownership.`
-  }
-
-  if (isFileNotFoundError(err)) {
-    return `File not found while trying to ${context}. The file may have been deleted or moved.`
-  }
-
-  if (err instanceof SyntaxError) {
-    return `JSON syntax error while trying to ${context}: ${err.message}. Check for missing commas, brackets, or invalid characters.`
-  }
-
-  const message = err instanceof Error ? err.message : String(err)
-
-  if (message.includes("ENOSPC")) {
-    return `Disk full: Cannot ${context}. Free up disk space and try again.`
-  }
-
-  if (message.includes("EROFS")) {
-    return `Read-only filesystem: Cannot ${context}. Check if the filesystem is mounted read-only.`
-  }
-
-  return `Failed to ${context}: ${message}`
-}
-
-export async function fetchLatestVersion(packageName: string): Promise<string | null> {
-  try {
-    const res = await fetch(`https://registry.npmjs.org/${packageName}/latest`)
-    if (!res.ok) return null
-    const data = await res.json() as { version: string }
-    return data.version
-  } catch {
-    return null
-  }
-}
-
-type ConfigFormat = "json" | "jsonc" | "none"
-
-interface OpenCodeConfig {
-  plugin?: string[]
-  [key: string]: unknown
-}
-
-export function detectConfigFormat(): { format: ConfigFormat; path: string } {
-  if (existsSync(OPENCODE_JSONC)) {
-    return { format: "jsonc", path: OPENCODE_JSONC }
-  }
-  if (existsSync(OPENCODE_JSON)) {
-    return { format: "json", path: OPENCODE_JSON }
-  }
-  return { format: "none", path: OPENCODE_JSON }
-}
-
-interface ParseConfigResult {
-  config: OpenCodeConfig | null
-  error?: string
-}
-
-function isEmptyOrWhitespace(content: string): boolean {
-  return content.trim().length === 0
-}
-
-function parseConfig(path: string, _isJsonc: boolean): OpenCodeConfig | null {
-  const result = parseConfigWithError(path)
-  return result.config
-}
-
-function parseConfigWithError(path: string): ParseConfigResult {
-  try {
-    const stat = statSync(path)
-    if (stat.size === 0) {
-      return { config: null, error: `Config file is empty: ${path}. Delete it or add valid JSON content.` }
-    }
-
-    const content = readFileSync(path, "utf-8")
-
-    if (isEmptyOrWhitespace(content)) {
-      return { config: null, error: `Config file contains only whitespace: ${path}. Delete it or add valid JSON content.` }
-    }
-
-    const config = parseJsonc<OpenCodeConfig>(content)
-
-    if (config === null || config === undefined) {
-      return { config: null, error: `Config file parsed to null/undefined: ${path}. Ensure it contains valid JSON.` }
-    }
-
-    if (typeof config !== "object" || Array.isArray(config)) {
-      return { config: null, error: `Config file must contain a JSON object, not ${Array.isArray(config) ? "an array" : typeof config}: ${path}` }
-    }
-
-    return { config }
-  } catch (err) {
-    return { config: null, error: formatErrorWithSuggestion(err, `parse config file ${path}`) }
-  }
-}
-
-function ensureConfigDir(): void {
-  if (!existsSync(OPENCODE_CONFIG_DIR)) {
-    mkdirSync(OPENCODE_CONFIG_DIR, { recursive: true })
-  }
-}
-
-export function addPluginToOpenCodeConfig(): ConfigMergeResult {
-  try {
-    ensureConfigDir()
-  } catch (err) {
-    return { success: false, configPath: OPENCODE_CONFIG_DIR, error: formatErrorWithSuggestion(err, "create config directory") }
-  }
-
-  const { format, path } = detectConfigFormat()
-  const pluginName = "oh-my-opencode"
-
-  try {
-    if (format === "none") {
-      const config: OpenCodeConfig = { plugin: [pluginName] }
-      writeFileSync(path, JSON.stringify(config, null, 2) + "\n")
-      return { success: true, configPath: path }
-    }
-
-    const parseResult = parseConfigWithError(path)
-    if (!parseResult.config) {
-      return { success: false, configPath: path, error: parseResult.error ?? "Failed to parse config file" }
-    }
-
-    const config = parseResult.config
-    const plugins = config.plugin ?? []
-    if (plugins.some((p) => p.startsWith(pluginName))) {
-      return { success: true, configPath: path }
-    }
-
-    config.plugin = [...plugins, pluginName]
-
-    if (format === "jsonc") {
-      const content = readFileSync(path, "utf-8")
-      const pluginArrayRegex = /"plugin"\s*:\s*\[([\s\S]*?)\]/
-      const match = content.match(pluginArrayRegex)
-
-      if (match) {
-        const arrayContent = match[1].trim()
-        const newArrayContent = arrayContent
-          ? `${arrayContent},\n    "${pluginName}"`
-          : `"${pluginName}"`
-        const newContent = content.replace(pluginArrayRegex, `"plugin": [\n    ${newArrayContent}\n  ]`)
-        writeFileSync(path, newContent)
-      } else {
-        const newContent = content.replace(/^(\s*\{)/, `$1\n  "plugin": ["${pluginName}"],`)
-        writeFileSync(path, newContent)
-      }
-    } else {
-      writeFileSync(path, JSON.stringify(config, null, 2) + "\n")
-    }
-
-    return { success: true, configPath: path }
-  } catch (err) {
-    return { success: false, configPath: path, error: formatErrorWithSuggestion(err, "update opencode config") }
-  }
-}
-
-function deepMerge<T extends Record<string, unknown>>(target: T, source: Partial<T>): T {
-  const result = { ...target }
-
-  for (const key of Object.keys(source) as Array<keyof T>) {
-    const sourceValue = source[key]
-    const targetValue = result[key]
-
-    if (
-      sourceValue !== null &&
-      typeof sourceValue === "object" &&
-      !Array.isArray(sourceValue) &&
-      targetValue !== null &&
-      typeof targetValue === "object" &&
-      !Array.isArray(targetValue)
-    ) {
-      result[key] = deepMerge(
-        targetValue as Record<string, unknown>,
-        sourceValue as Record<string, unknown>
-      ) as T[keyof T]
-    } else if (sourceValue !== undefined) {
-      result[key] = sourceValue as T[keyof T]
-    }
-  }
-
-  return result
-}
-
-export function generateOmoConfig(installConfig: InstallConfig): Record<string, unknown> {
-  const config: Record<string, unknown> = {
-    $schema: "https://raw.githubusercontent.com/code-yeongyu/oh-my-opencode/master/assets/oh-my-opencode.schema.json",
-  }
-
-  if (installConfig.hasGemini) {
-    config.google_auth = false
-  }
-
-  const agents: Record<string, Record<string, unknown>> = {}
-
-  if (!installConfig.hasClaude) {
-    agents["Sisyphus"] = { model: "opencode/big-pickle" }
-  }
-
-  if (installConfig.hasGemini) {
-    agents["librarian"] = { model: "google/gemini-3-flash" }
-    agents["explore"] = { model: "google/gemini-3-flash" }
-  } else if (installConfig.hasClaude && installConfig.isMax20) {
-    agents["explore"] = { model: "anthropic/claude-haiku-4-5" }
-  } else {
-    agents["librarian"] = { model: "opencode/big-pickle" }
-    agents["explore"] = { model: "opencode/big-pickle" }
-  }
-
-  if (!installConfig.hasChatGPT) {
-    agents["oracle"] = {
-      model: installConfig.hasClaude ? "anthropic/claude-opus-4-5" : "opencode/big-pickle",
-    }
-  }
-
-  if (installConfig.hasGemini) {
-    agents["frontend-ui-ux-engineer"] = { model: "google/gemini-3-pro-high" }
-    agents["document-writer"] = { model: "google/gemini-3-flash" }
-    agents["multimodal-looker"] = { model: "google/gemini-3-flash" }
-  } else {
-    const fallbackModel = installConfig.hasClaude ? "anthropic/claude-opus-4-5" : "opencode/big-pickle"
-    agents["frontend-ui-ux-engineer"] = { model: fallbackModel }
-    agents["document-writer"] = { model: fallbackModel }
-    agents["multimodal-looker"] = { model: fallbackModel }
-  }
-
-  if (Object.keys(agents).length > 0) {
-    config.agents = agents
-  }
-
-  return config
-}
-
-export function writeOmoConfig(installConfig: InstallConfig): ConfigMergeResult {
-  try {
-    ensureConfigDir()
-  } catch (err) {
-    return { success: false, configPath: OPENCODE_CONFIG_DIR, error: formatErrorWithSuggestion(err, "create config directory") }
-  }
-
-  try {
-    const newConfig = generateOmoConfig(installConfig)
-
-    if (existsSync(OMO_CONFIG)) {
-      try {
-        const stat = statSync(OMO_CONFIG)
-        const content = readFileSync(OMO_CONFIG, "utf-8")
-
-        if (stat.size === 0 || isEmptyOrWhitespace(content)) {
-          writeFileSync(OMO_CONFIG, JSON.stringify(newConfig, null, 2) + "\n")
-          return { success: true, configPath: OMO_CONFIG }
-        }
-
-        const existing = parseJsonc<Record<string, unknown>>(content)
-        if (!existing || typeof existing !== "object" || Array.isArray(existing)) {
-          writeFileSync(OMO_CONFIG, JSON.stringify(newConfig, null, 2) + "\n")
-          return { success: true, configPath: OMO_CONFIG }
-        }
-
-        delete existing.agents
-        const merged = deepMerge(existing, newConfig)
-        writeFileSync(OMO_CONFIG, JSON.stringify(merged, null, 2) + "\n")
-      } catch (parseErr) {
-        if (parseErr instanceof SyntaxError) {
-          writeFileSync(OMO_CONFIG, JSON.stringify(newConfig, null, 2) + "\n")
-          return { success: true, configPath: OMO_CONFIG }
-        }
-        throw parseErr
-      }
-    } else {
-      writeFileSync(OMO_CONFIG, JSON.stringify(newConfig, null, 2) + "\n")
-    }
-
-    return { success: true, configPath: OMO_CONFIG }
-  } catch (err) {
-    return { success: false, configPath: OMO_CONFIG, error: formatErrorWithSuggestion(err, "write oh-my-opencode config") }
-  }
-}
-
-interface OpenCodeBinaryResult {
-  binary: string
-  version: string
-}
-
-async function findOpenCodeBinaryWithVersion(): Promise<OpenCodeBinaryResult | null> {
-  for (const binary of OPENCODE_BINARIES) {
-    try {
-      const proc = Bun.spawn([binary, "--version"], {
-        stdout: "pipe",
-        stderr: "pipe",
-      })
-      const output = await new Response(proc.stdout).text()
-      await proc.exited
-      if (proc.exitCode === 0) {
-        return { binary, version: output.trim() }
-      }
-    } catch {
-      continue
-    }
-  }
-  return null
-}
-
-export async function isOpenCodeInstalled(): Promise<boolean> {
-  const result = await findOpenCodeBinaryWithVersion()
-  return result !== null
-}
-
-export async function getOpenCodeVersion(): Promise<string | null> {
-  const result = await findOpenCodeBinaryWithVersion()
-  return result?.version ?? null
-}
-
-export async function addAuthPlugins(config: InstallConfig): Promise<ConfigMergeResult> {
-  try {
-    ensureConfigDir()
-  } catch (err) {
-    return { success: false, configPath: OPENCODE_CONFIG_DIR, error: formatErrorWithSuggestion(err, "create config directory") }
-  }
-
-  const { format, path } = detectConfigFormat()
-
-  try {
-    let existingConfig: OpenCodeConfig | null = null
-    if (format !== "none") {
-      const parseResult = parseConfigWithError(path)
-      if (parseResult.error && !parseResult.config) {
-        existingConfig = {}
-      } else {
-        existingConfig = parseResult.config
-      }
-    }
-
-    const plugins: string[] = existingConfig?.plugin ?? []
-
-    if (config.hasGemini) {
-      const version = await fetchLatestVersion("opencode-antigravity-auth")
-      const pluginEntry = version ? `opencode-antigravity-auth@${version}` : "opencode-antigravity-auth"
-      if (!plugins.some((p) => p.startsWith("opencode-antigravity-auth"))) {
-        plugins.push(pluginEntry)
-      }
-    }
-
-    if (config.hasChatGPT) {
-      if (!plugins.some((p) => p.startsWith("opencode-openai-codex-auth"))) {
-        plugins.push("opencode-openai-codex-auth")
-      }
-    }
-
-    const newConfig = { ...(existingConfig ?? {}), plugin: plugins }
-    writeFileSync(path, JSON.stringify(newConfig, null, 2) + "\n")
-    return { success: true, configPath: path }
-  } catch (err) {
-    return { success: false, configPath: path, error: formatErrorWithSuggestion(err, "add auth plugins to config") }
-  }
-}
-
-export function setupChatGPTHotfix(): ConfigMergeResult {
-  try {
-    ensureConfigDir()
-  } catch (err) {
-    return { success: false, configPath: OPENCODE_CONFIG_DIR, error: formatErrorWithSuggestion(err, "create config directory") }
-  }
-
-  try {
-    let packageJson: Record<string, unknown> = {}
-    if (existsSync(OPENCODE_PACKAGE_JSON)) {
-      try {
-        const stat = statSync(OPENCODE_PACKAGE_JSON)
-        const content = readFileSync(OPENCODE_PACKAGE_JSON, "utf-8")
-
-        if (stat.size > 0 && !isEmptyOrWhitespace(content)) {
-          packageJson = JSON.parse(content)
-          if (typeof packageJson !== "object" || packageJson === null || Array.isArray(packageJson)) {
-            packageJson = {}
-          }
-        }
-      } catch (parseErr) {
-        if (parseErr instanceof SyntaxError) {
-          packageJson = {}
-        } else {
-          throw parseErr
-        }
-      }
-    }
-
-    const deps = (packageJson.dependencies ?? {}) as Record<string, string>
-    deps["opencode-openai-codex-auth"] = CHATGPT_HOTFIX_REPO
-    packageJson.dependencies = deps
-
-    writeFileSync(OPENCODE_PACKAGE_JSON, JSON.stringify(packageJson, null, 2) + "\n")
-    return { success: true, configPath: OPENCODE_PACKAGE_JSON }
-  } catch (err) {
-    return { success: false, configPath: OPENCODE_PACKAGE_JSON, error: formatErrorWithSuggestion(err, "setup ChatGPT hotfix in package.json") }
-  }
-}
-
-export interface BunInstallResult {
-  success: boolean
-  timedOut?: boolean
-  error?: string
-}
-
-export async function runBunInstall(): Promise<boolean> {
-  const result = await runBunInstallWithDetails()
-  return result.success
-}
-
-export async function runBunInstallWithDetails(): Promise<BunInstallResult> {
-  try {
-    const proc = Bun.spawn(["bun", "install"], {
-      cwd: OPENCODE_CONFIG_DIR,
-      stdout: "pipe",
-      stderr: "pipe",
-    })
-
-    const timeoutPromise = new Promise<"timeout">((resolve) =>
-      setTimeout(() => resolve("timeout"), BUN_INSTALL_TIMEOUT_MS)
-    )
-
-    const exitPromise = proc.exited.then(() => "completed" as const)
-
-    const result = await Promise.race([exitPromise, timeoutPromise])
-
-    if (result === "timeout") {
-      try {
-        proc.kill()
-      } catch {
-        /* intentionally empty - process may have already exited */
-      }
-      return {
-        success: false,
-        timedOut: true,
-        error: `bun install timed out after ${BUN_INSTALL_TIMEOUT_SECONDS} seconds. Try running manually: cd ~/.config/opencode && bun i`,
-      }
-    }
-
-    if (proc.exitCode !== 0) {
-      const stderr = await new Response(proc.stderr).text()
-      return {
-        success: false,
-        error: stderr.trim() || `bun install failed with exit code ${proc.exitCode}`,
-      }
-    }
-
-    return { success: true }
-  } catch (err) {
-    const message = err instanceof Error ? err.message : String(err)
-    return {
-      success: false,
-      error: `bun install failed: ${message}. Is bun installed? Try: curl -fsSL https://bun.sh/install | bash`,
-    }
-  }
-}
-
-export const ANTIGRAVITY_PROVIDER_CONFIG = {
-  google: {
-    name: "Google",
-    // NOTE: opencode-antigravity-auth expects full model specs (name/limit/modalities).
-    // If these are incomplete, models may appear but fail at runtime (e.g. 404).
-    models: {
-      "gemini-3-pro-high": {
-        name: "Gemini 3 Pro High (Antigravity)",
-        thinking: true,
-        attachment: true,
-        limit: { context: 1048576, output: 65535 },
-        modalities: { input: ["text", "image", "pdf"], output: ["text"] },
-      },
-      "gemini-3-pro-medium": {
-        name: "Gemini 3 Pro Medium (Antigravity)",
-        thinking: true,
-        attachment: true,
-        limit: { context: 1048576, output: 65535 },
-        modalities: { input: ["text", "image", "pdf"], output: ["text"] },
-      },
-      "gemini-3-pro-low": {
-        name: "Gemini 3 Pro Low (Antigravity)",
-        thinking: true,
-        attachment: true,
-        limit: { context: 1048576, output: 65535 },
-        modalities: { input: ["text", "image", "pdf"], output: ["text"] },
-      },
-      "gemini-3-flash": {
-        name: "Gemini 3 Flash (Antigravity)",
-        attachment: true,
-        limit: { context: 1048576, output: 65536 },
-        modalities: { input: ["text", "image", "pdf"], output: ["text"] },
-      },
-      "gemini-3-flash-lite": {
-        name: "Gemini 3 Flash Lite (Antigravity)",
-        attachment: true,
-        limit: { context: 1048576, output: 65536 },
-        modalities: { input: ["text", "image", "pdf"], output: ["text"] },
-      },
-    },
-  },
-}
-
-const CODEX_PROVIDER_CONFIG = {
-  openai: {
-    name: "OpenAI",
-    api: "codex",
-    models: {
-      "gpt-5.2": { name: "GPT-5.2" },
-      "o3": { name: "o3", thinking: true },
-      "o4-mini": { name: "o4-mini", thinking: true },
-      "codex-1": { name: "Codex-1" },
-    },
-  },
-}
-
-export function addProviderConfig(config: InstallConfig): ConfigMergeResult {
-  try {
-    ensureConfigDir()
-  } catch (err) {
-    return { success: false, configPath: OPENCODE_CONFIG_DIR, error: formatErrorWithSuggestion(err, "create config directory") }
-  }
-
-  const { format, path } = detectConfigFormat()
-
-  try {
-    let existingConfig: OpenCodeConfig | null = null
-    if (format !== "none") {
-      const parseResult = parseConfigWithError(path)
-      if (parseResult.error && !parseResult.config) {
-        existingConfig = {}
-      } else {
-        existingConfig = parseResult.config
-      }
-    }
-
-    const newConfig = { ...(existingConfig ?? {}) }
-
-    const providers = (newConfig.provider ?? {}) as Record<string, unknown>
-
-    if (config.hasGemini) {
-      providers.google = ANTIGRAVITY_PROVIDER_CONFIG.google
-    }
-
-    if (config.hasChatGPT) {
-      providers.openai = CODEX_PROVIDER_CONFIG.openai
-    }
-
-    if (Object.keys(providers).length > 0) {
-      newConfig.provider = providers
-    }
-
-    writeFileSync(path, JSON.stringify(newConfig, null, 2) + "\n")
-    return { success: true, configPath: path }
-  } catch (err) {
-    return { success: false, configPath: path, error: formatErrorWithSuggestion(err, "add provider config") }
-  }
-}
-
-interface OmoConfigData {
-  google_auth?: boolean
-  agents?: Record<string, { model?: string }>
-}
-
-export function detectCurrentConfig(): DetectedConfig {
-  const result: DetectedConfig = {
-    isInstalled: false,
-    hasClaude: true,
-    isMax20: true,
-    hasChatGPT: true,
-    hasGemini: false,
-  }
-
-  const { format, path } = detectConfigFormat()
-  if (format === "none") {
-    return result
-  }
-
-  const parseResult = parseConfigWithError(path)
-  if (!parseResult.config) {
-    return result
-  }
-
-  const openCodeConfig = parseResult.config
-  const plugins = openCodeConfig.plugin ?? []
-  result.isInstalled = plugins.some((p) => p.startsWith("oh-my-opencode"))
-
-  if (!result.isInstalled) {
-    return result
-  }
-
-  result.hasGemini = plugins.some((p) => p.startsWith("opencode-antigravity-auth"))
-  result.hasChatGPT = plugins.some((p) => p.startsWith("opencode-openai-codex-auth"))
-
-  if (!existsSync(OMO_CONFIG)) {
-    return result
-  }
-
-  try {
-    const stat = statSync(OMO_CONFIG)
-    if (stat.size === 0) {
-      return result
-    }
-
-    const content = readFileSync(OMO_CONFIG, "utf-8")
-    if (isEmptyOrWhitespace(content)) {
-      return result
-    }
-
-    const omoConfig = parseJsonc<OmoConfigData>(content)
-    if (!omoConfig || typeof omoConfig !== "object") {
-      return result
-    }
-
-    const agents = omoConfig.agents ?? {}
-
-    if (agents["Sisyphus"]?.model === "opencode/big-pickle") {
-      result.hasClaude = false
-      result.isMax20 = false
-    } else if (agents["librarian"]?.model === "opencode/big-pickle") {
-      result.hasClaude = true
-      result.isMax20 = false
-    }
-
-    if (agents["oracle"]?.model?.startsWith("anthropic/")) {
-      result.hasChatGPT = false
-    } else if (agents["oracle"]?.model === "opencode/big-pickle") {
-      result.hasChatGPT = false
-    }
-
-    if (omoConfig.google_auth === false) {
-      result.hasGemini = plugins.some((p) => p.startsWith("opencode-antigravity-auth"))
-    }
-  } catch {
-    /* intentionally empty - malformed omo config returns defaults from opencode config detection */
-  }
-
-  return result
-}

src/cli/doctor/checks/auth.test.ts

@@ -1,114 +0,0 @@
-import { describe, it, expect, spyOn, afterEach } from "bun:test"
-import * as auth from "./auth"
-
-describe("auth check", () => {
-  describe("getAuthProviderInfo", () => {
-    it("returns anthropic as always available", () => {
-      // #given anthropic provider
-      // #when getting info
-      const info = auth.getAuthProviderInfo("anthropic")
-
-      // #then should show plugin installed (builtin)
-      expect(info.id).toBe("anthropic")
-      expect(info.pluginInstalled).toBe(true)
-    })
-
-    it("returns correct name for each provider", () => {
-      // #given each provider
-      // #when getting info
-      // #then should have correct names
-      expect(auth.getAuthProviderInfo("anthropic").name).toContain("Claude")
-      expect(auth.getAuthProviderInfo("openai").name).toContain("ChatGPT")
-      expect(auth.getAuthProviderInfo("google").name).toContain("Gemini")
-    })
-  })
-
-  describe("checkAuthProvider", () => {
-    let getInfoSpy: ReturnType<typeof spyOn>
-
-    afterEach(() => {
-      getInfoSpy?.mockRestore()
-    })
-
-    it("returns pass when plugin installed", async () => {
-      // #given plugin installed
-      getInfoSpy = spyOn(auth, "getAuthProviderInfo").mockReturnValue({
-        id: "anthropic",
-        name: "Anthropic (Claude)",
-        pluginInstalled: true,
-        configured: true,
-      })
-
-      // #when checking
-      const result = await auth.checkAuthProvider("anthropic")
-
-      // #then should pass
-      expect(result.status).toBe("pass")
-    })
-
-    it("returns skip when plugin not installed", async () => {
-      // #given plugin not installed
-      getInfoSpy = spyOn(auth, "getAuthProviderInfo").mockReturnValue({
-        id: "openai",
-        name: "OpenAI (ChatGPT)",
-        pluginInstalled: false,
-        configured: false,
-      })
-
-      // #when checking
-      const result = await auth.checkAuthProvider("openai")
-
-      // #then should skip
-      expect(result.status).toBe("skip")
-      expect(result.message).toContain("not installed")
-    })
-  })
-
-  describe("checkAnthropicAuth", () => {
-    it("returns a check result", async () => {
-      // #given
-      // #when checking anthropic
-      const result = await auth.checkAnthropicAuth()
-
-      // #then should return valid result
-      expect(result.name).toBeDefined()
-      expect(["pass", "fail", "warn", "skip"]).toContain(result.status)
-    })
-  })
-
-  describe("checkOpenAIAuth", () => {
-    it("returns a check result", async () => {
-      // #given
-      // #when checking openai
-      const result = await auth.checkOpenAIAuth()
-
-      // #then should return valid result
-      expect(result.name).toBeDefined()
-      expect(["pass", "fail", "warn", "skip"]).toContain(result.status)
-    })
-  })
-
-  describe("checkGoogleAuth", () => {
-    it("returns a check result", async () => {
-      // #given
-      // #when checking google
-      const result = await auth.checkGoogleAuth()
-
-      // #then should return valid result
-      expect(result.name).toBeDefined()
-      expect(["pass", "fail", "warn", "skip"]).toContain(result.status)
-    })
-  })
-
-  describe("getAuthCheckDefinitions", () => {
-    it("returns definitions for all three providers", () => {
-      // #given
-      // #when getting definitions
-      const defs = auth.getAuthCheckDefinitions()
-
-      // #then should have 3 definitions
-      expect(defs.length).toBe(3)
-      expect(defs.every((d) => d.category === "authentication")).toBe(true)
-    })
-  })
-})

src/cli/doctor/checks/auth.ts

@@ -1,115 +0,0 @@
-import { existsSync, readFileSync } from "node:fs"
-import { homedir } from "node:os"
-import { join } from "node:path"
-import type { CheckResult, CheckDefinition, AuthProviderInfo, AuthProviderId } from "../types"
-import { CHECK_IDS, CHECK_NAMES } from "../constants"
-import { parseJsonc } from "../../../shared"
-
-const OPENCODE_CONFIG_DIR = join(homedir(), ".config", "opencode")
-const OPENCODE_JSON = join(OPENCODE_CONFIG_DIR, "opencode.json")
-const OPENCODE_JSONC = join(OPENCODE_CONFIG_DIR, "opencode.jsonc")
-
-const AUTH_PLUGINS: Record<AuthProviderId, { plugin: string; name: string }> = {
-  anthropic: { plugin: "builtin", name: "Anthropic (Claude)" },
-  openai: { plugin: "opencode-openai-codex-auth", name: "OpenAI (ChatGPT)" },
-  google: { plugin: "opencode-antigravity-auth", name: "Google (Gemini)" },
-}
-
-function getOpenCodeConfig(): { plugin?: string[] } | null {
-  const configPath = existsSync(OPENCODE_JSONC) ? OPENCODE_JSONC : OPENCODE_JSON
-  if (!existsSync(configPath)) return null
-
-  try {
-    const content = readFileSync(configPath, "utf-8")
-    return parseJsonc<{ plugin?: string[] }>(content)
-  } catch {
-    return null
-  }
-}
-
-function isPluginInstalled(plugins: string[], pluginName: string): boolean {
-  if (pluginName === "builtin") return true
-  return plugins.some((p) => p === pluginName || p.startsWith(`${pluginName}@`))
-}
-
-export function getAuthProviderInfo(providerId: AuthProviderId): AuthProviderInfo {
-  const config = getOpenCodeConfig()
-  const plugins = config?.plugin ?? []
-  const authConfig = AUTH_PLUGINS[providerId]
-
-  const pluginInstalled = isPluginInstalled(plugins, authConfig.plugin)
-
-  return {
-    id: providerId,
-    name: authConfig.name,
-    pluginInstalled,
-    configured: pluginInstalled,
-  }
-}
-
-export async function checkAuthProvider(providerId: AuthProviderId): Promise<CheckResult> {
-  const info = getAuthProviderInfo(providerId)
-  const checkId = `auth-${providerId}` as keyof typeof CHECK_NAMES
-  const checkName = CHECK_NAMES[checkId] || info.name
-
-  if (!info.pluginInstalled) {
-    return {
-      name: checkName,
-      status: "skip",
-      message: "Auth plugin not installed",
-      details: [
-        `Plugin: ${AUTH_PLUGINS[providerId].plugin}`,
-        "Run: bunx oh-my-opencode install",
-      ],
-    }
-  }
-
-  return {
-    name: checkName,
-    status: "pass",
-    message: "Auth plugin available",
-    details: [
-      providerId === "anthropic"
-        ? "Run: opencode auth login (select Anthropic)"
-        : `Plugin: ${AUTH_PLUGINS[providerId].plugin}`,
-    ],
-  }
-}
-
-export async function checkAnthropicAuth(): Promise<CheckResult> {
-  return checkAuthProvider("anthropic")
-}
-
-export async function checkOpenAIAuth(): Promise<CheckResult> {
-  return checkAuthProvider("openai")
-}
-
-export async function checkGoogleAuth(): Promise<CheckResult> {
-  return checkAuthProvider("google")
-}
-
-export function getAuthCheckDefinitions(): CheckDefinition[] {
-  return [
-    {
-      id: CHECK_IDS.AUTH_ANTHROPIC,
-      name: CHECK_NAMES[CHECK_IDS.AUTH_ANTHROPIC],
-      category: "authentication",
-      check: checkAnthropicAuth,
-      critical: false,
-    },
-    {
-      id: CHECK_IDS.AUTH_OPENAI,
-      name: CHECK_NAMES[CHECK_IDS.AUTH_OPENAI],
-      category: "authentication",
-      check: checkOpenAIAuth,
-      critical: false,
-    },
-    {
-      id: CHECK_IDS.AUTH_GOOGLE,
-      name: CHECK_NAMES[CHECK_IDS.AUTH_GOOGLE],
-      category: "authentication",
-      check: checkGoogleAuth,
-      critical: false,
-    },
-  ]
-}

src/cli/doctor/checks/config.test.ts

@@ -1,103 +0,0 @@
-import { describe, it, expect, spyOn, afterEach } from "bun:test"
-import * as config from "./config"
-
-describe("config check", () => {
-  describe("validateConfig", () => {
-    it("returns valid: false for non-existent file", () => {
-      // #given non-existent file path
-      // #when validating
-      const result = config.validateConfig("/non/existent/path.json")
-
-      // #then should indicate invalid
-      expect(result.valid).toBe(false)
-      expect(result.errors.length).toBeGreaterThan(0)
-    })
-  })
-
-  describe("getConfigInfo", () => {
-    it("returns exists: false when no config found", () => {
-      // #given no config file exists
-      // #when getting config info
-      const info = config.getConfigInfo()
-
-      // #then should handle gracefully
-      expect(typeof info.exists).toBe("boolean")
-      expect(typeof info.valid).toBe("boolean")
-    })
-  })
-
-  describe("checkConfigValidity", () => {
-    let getInfoSpy: ReturnType<typeof spyOn>
-
-    afterEach(() => {
-      getInfoSpy?.mockRestore()
-    })
-
-    it("returns pass when no config exists (uses defaults)", async () => {
-      // #given no config file
-      getInfoSpy = spyOn(config, "getConfigInfo").mockReturnValue({
-        exists: false,
-        path: null,
-        format: null,
-        valid: true,
-        errors: [],
-      })
-
-      // #when checking validity
-      const result = await config.checkConfigValidity()
-
-      // #then should pass with default message
-      expect(result.status).toBe("pass")
-      expect(result.message).toContain("default")
-    })
-
-    it("returns pass when config is valid", async () => {
-      // #given valid config
-      getInfoSpy = spyOn(config, "getConfigInfo").mockReturnValue({
-        exists: true,
-        path: "/home/user/.config/opencode/oh-my-opencode.json",
-        format: "json",
-        valid: true,
-        errors: [],
-      })
-
-      // #when checking validity
-      const result = await config.checkConfigValidity()
-
-      // #then should pass
-      expect(result.status).toBe("pass")
-      expect(result.message).toContain("JSON")
-    })
-
-    it("returns fail when config has validation errors", async () => {
-      // #given invalid config
-      getInfoSpy = spyOn(config, "getConfigInfo").mockReturnValue({
-        exists: true,
-        path: "/home/user/.config/opencode/oh-my-opencode.json",
-        format: "json",
-        valid: false,
-        errors: ["agents.oracle: Invalid model format"],
-      })
-
-      // #when checking validity
-      const result = await config.checkConfigValidity()
-
-      // #then should fail with errors
-      expect(result.status).toBe("fail")
-      expect(result.details?.some((d) => d.includes("Error"))).toBe(true)
-    })
-  })
-
-  describe("getConfigCheckDefinition", () => {
-    it("returns valid check definition", () => {
-      // #given
-      // #when getting definition
-      const def = config.getConfigCheckDefinition()
-
-      // #then should have required properties
-      expect(def.id).toBe("config-validation")
-      expect(def.category).toBe("configuration")
-      expect(def.critical).toBe(false)
-    })
-  })
-})

src/cli/doctor/checks/config.ts

@@ -1,123 +0,0 @@
-import { existsSync, readFileSync } from "node:fs"
-import { homedir } from "node:os"
-import { join } from "node:path"
-import type { CheckResult, CheckDefinition, ConfigInfo } from "../types"
-import { CHECK_IDS, CHECK_NAMES, PACKAGE_NAME } from "../constants"
-import { parseJsonc, detectConfigFile } from "../../../shared"
-import { OhMyOpenCodeConfigSchema } from "../../../config"
-
-const USER_CONFIG_DIR = join(homedir(), ".config", "opencode")
-const USER_CONFIG_BASE = join(USER_CONFIG_DIR, `${PACKAGE_NAME}`)
-const PROJECT_CONFIG_BASE = join(process.cwd(), ".opencode", PACKAGE_NAME)
-
-function findConfigPath(): { path: string; format: "json" | "jsonc" } | null {
-  const projectDetected = detectConfigFile(PROJECT_CONFIG_BASE)
-  if (projectDetected.format !== "none") {
-    return { path: projectDetected.path, format: projectDetected.format as "json" | "jsonc" }
-  }
-
-  const userDetected = detectConfigFile(USER_CONFIG_BASE)
-  if (userDetected.format !== "none") {
-    return { path: userDetected.path, format: userDetected.format as "json" | "jsonc" }
-  }
-
-  return null
-}
-
-export function validateConfig(configPath: string): { valid: boolean; errors: string[] } {
-  try {
-    const content = readFileSync(configPath, "utf-8")
-    const rawConfig = parseJsonc<Record<string, unknown>>(content)
-    const result = OhMyOpenCodeConfigSchema.safeParse(rawConfig)
-
-    if (!result.success) {
-      const errors = result.error.issues.map(
-        (i) => `${i.path.join(".")}: ${i.message}`
-      )
-      return { valid: false, errors }
-    }
-
-    return { valid: true, errors: [] }
-  } catch (err) {
-    return {
-      valid: false,
-      errors: [err instanceof Error ? err.message : "Failed to parse config"],
-    }
-  }
-}
-
-export function getConfigInfo(): ConfigInfo {
-  const configPath = findConfigPath()
-
-  if (!configPath) {
-    return {
-      exists: false,
-      path: null,
-      format: null,
-      valid: true,
-      errors: [],
-    }
-  }
-
-  if (!existsSync(configPath.path)) {
-    return {
-      exists: false,
-      path: configPath.path,
-      format: configPath.format,
-      valid: true,
-      errors: [],
-    }
-  }
-
-  const validation = validateConfig(configPath.path)
-
-  return {
-    exists: true,
-    path: configPath.path,
-    format: configPath.format,
-    valid: validation.valid,
-    errors: validation.errors,
-  }
-}
-
-export async function checkConfigValidity(): Promise<CheckResult> {
-  const info = getConfigInfo()
-
-  if (!info.exists) {
-    return {
-      name: CHECK_NAMES[CHECK_IDS.CONFIG_VALIDATION],
-      status: "pass",
-      message: "Using default configuration",
-      details: ["No custom config file found (optional)"],
-    }
-  }
-
-  if (!info.valid) {
-    return {
-      name: CHECK_NAMES[CHECK_IDS.CONFIG_VALIDATION],
-      status: "fail",
-      message: "Configuration has validation errors",
-      details: [
-        `Path: ${info.path}`,
-        ...info.errors.map((e) => `Error: ${e}`),
-      ],
-    }
-  }
-
-  return {
-    name: CHECK_NAMES[CHECK_IDS.CONFIG_VALIDATION],
-    status: "pass",
-    message: `Valid ${info.format?.toUpperCase()} config`,
-    details: [`Path: ${info.path}`],
-  }
-}
-
-export function getConfigCheckDefinition(): CheckDefinition {
-  return {
-    id: CHECK_IDS.CONFIG_VALIDATION,
-    name: CHECK_NAMES[CHECK_IDS.CONFIG_VALIDATION],
-    category: "configuration",
-    check: checkConfigValidity,
-    critical: false,
-  }
-}

src/cli/doctor/checks/dependencies.test.ts

@@ -1,152 +0,0 @@
-import { describe, it, expect, spyOn, afterEach } from "bun:test"
-import * as deps from "./dependencies"
-
-describe("dependencies check", () => {
-  describe("checkAstGrepCli", () => {
-    it("returns dependency info", async () => {
-      // #given
-      // #when checking ast-grep cli
-      const info = await deps.checkAstGrepCli()
-
-      // #then should return valid info
-      expect(info.name).toBe("AST-Grep CLI")
-      expect(info.required).toBe(false)
-      expect(typeof info.installed).toBe("boolean")
-    })
-  })
-
-  describe("checkAstGrepNapi", () => {
-    it("returns dependency info", () => {
-      // #given
-      // #when checking ast-grep napi
-      const info = deps.checkAstGrepNapi()
-
-      // #then should return valid info
-      expect(info.name).toBe("AST-Grep NAPI")
-      expect(info.required).toBe(false)
-      expect(typeof info.installed).toBe("boolean")
-    })
-  })
-
-  describe("checkCommentChecker", () => {
-    it("returns dependency info", async () => {
-      // #given
-      // #when checking comment checker
-      const info = await deps.checkCommentChecker()
-
-      // #then should return valid info
-      expect(info.name).toBe("Comment Checker")
-      expect(info.required).toBe(false)
-      expect(typeof info.installed).toBe("boolean")
-    })
-  })
-
-  describe("checkDependencyAstGrepCli", () => {
-    let checkSpy: ReturnType<typeof spyOn>
-
-    afterEach(() => {
-      checkSpy?.mockRestore()
-    })
-
-    it("returns pass when installed", async () => {
-      // #given ast-grep installed
-      checkSpy = spyOn(deps, "checkAstGrepCli").mockResolvedValue({
-        name: "AST-Grep CLI",
-        required: false,
-        installed: true,
-        version: "0.25.0",
-        path: "/usr/local/bin/sg",
-      })
-
-      // #when checking
-      const result = await deps.checkDependencyAstGrepCli()
-
-      // #then should pass
-      expect(result.status).toBe("pass")
-      expect(result.message).toContain("0.25.0")
-    })
-
-    it("returns warn when not installed", async () => {
-      // #given ast-grep not installed
-      checkSpy = spyOn(deps, "checkAstGrepCli").mockResolvedValue({
-        name: "AST-Grep CLI",
-        required: false,
-        installed: false,
-        version: null,
-        path: null,
-        installHint: "Install: npm install -g @ast-grep/cli",
-      })
-
-      // #when checking
-      const result = await deps.checkDependencyAstGrepCli()
-
-      // #then should warn (optional)
-      expect(result.status).toBe("warn")
-      expect(result.message).toContain("optional")
-    })
-  })
-
-  describe("checkDependencyAstGrepNapi", () => {
-    let checkSpy: ReturnType<typeof spyOn>
-
-    afterEach(() => {
-      checkSpy?.mockRestore()
-    })
-
-    it("returns pass when installed", async () => {
-      // #given napi installed
-      checkSpy = spyOn(deps, "checkAstGrepNapi").mockReturnValue({
-        name: "AST-Grep NAPI",
-        required: false,
-        installed: true,
-        version: null,
-        path: null,
-      })
-
-      // #when checking
-      const result = await deps.checkDependencyAstGrepNapi()
-
-      // #then should pass
-      expect(result.status).toBe("pass")
-    })
-  })
-
-  describe("checkDependencyCommentChecker", () => {
-    let checkSpy: ReturnType<typeof spyOn>
-
-    afterEach(() => {
-      checkSpy?.mockRestore()
-    })
-
-    it("returns warn when not installed", async () => {
-      // #given comment checker not installed
-      checkSpy = spyOn(deps, "checkCommentChecker").mockResolvedValue({
-        name: "Comment Checker",
-        required: false,
-        installed: false,
-        version: null,
-        path: null,
-        installHint: "Hook will be disabled if not available",
-      })
-
-      // #when checking
-      const result = await deps.checkDependencyCommentChecker()
-
-      // #then should warn
-      expect(result.status).toBe("warn")
-    })
-  })
-
-  describe("getDependencyCheckDefinitions", () => {
-    it("returns definitions for all dependencies", () => {
-      // #given
-      // #when getting definitions
-      const defs = deps.getDependencyCheckDefinitions()
-
-      // #then should have 3 definitions
-      expect(defs.length).toBe(3)
-      expect(defs.every((d) => d.category === "dependencies")).toBe(true)
-      expect(defs.every((d) => d.critical === false)).toBe(true)
-    })
-  })
-})

src/cli/doctor/checks/dependencies.ts

@@ -1,163 +0,0 @@
-import type { CheckResult, CheckDefinition, DependencyInfo } from "../types"
-import { CHECK_IDS, CHECK_NAMES } from "../constants"
-
-async function checkBinaryExists(binary: string): Promise<{ exists: boolean; path: string | null }> {
-  try {
-    const proc = Bun.spawn(["which", binary], { stdout: "pipe", stderr: "pipe" })
-    const output = await new Response(proc.stdout).text()
-    await proc.exited
-    if (proc.exitCode === 0) {
-      return { exists: true, path: output.trim() }
-    }
-  } catch {
-    // intentionally empty - binary not found
-  }
-  return { exists: false, path: null }
-}
-
-async function getBinaryVersion(binary: string): Promise<string | null> {
-  try {
-    const proc = Bun.spawn([binary, "--version"], { stdout: "pipe", stderr: "pipe" })
-    const output = await new Response(proc.stdout).text()
-    await proc.exited
-    if (proc.exitCode === 0) {
-      return output.trim().split("\n")[0]
-    }
-  } catch {
-    // intentionally empty - version unavailable
-  }
-  return null
-}
-
-export async function checkAstGrepCli(): Promise<DependencyInfo> {
-  const binaryCheck = await checkBinaryExists("sg")
-  const altBinaryCheck = !binaryCheck.exists ? await checkBinaryExists("ast-grep") : null
-
-  const binary = binaryCheck.exists ? binaryCheck : altBinaryCheck
-  if (!binary || !binary.exists) {
-    return {
-      name: "AST-Grep CLI",
-      required: false,
-      installed: false,
-      version: null,
-      path: null,
-      installHint: "Install: npm install -g @ast-grep/cli",
-    }
-  }
-
-  const version = await getBinaryVersion(binary.path!)
-
-  return {
-    name: "AST-Grep CLI",
-    required: false,
-    installed: true,
-    version,
-    path: binary.path,
-  }
-}
-
-export function checkAstGrepNapi(): DependencyInfo {
-  try {
-    require.resolve("@ast-grep/napi")
-    return {
-      name: "AST-Grep NAPI",
-      required: false,
-      installed: true,
-      version: null,
-      path: null,
-    }
-  } catch {
-    return {
-      name: "AST-Grep NAPI",
-      required: false,
-      installed: false,
-      version: null,
-      path: null,
-      installHint: "Will use CLI fallback if available",
-    }
-  }
-}
-
-export async function checkCommentChecker(): Promise<DependencyInfo> {
-  const binaryCheck = await checkBinaryExists("comment-checker")
-
-  if (!binaryCheck.exists) {
-    return {
-      name: "Comment Checker",
-      required: false,
-      installed: false,
-      version: null,
-      path: null,
-      installHint: "Hook will be disabled if not available",
-    }
-  }
-
-  const version = await getBinaryVersion("comment-checker")
-
-  return {
-    name: "Comment Checker",
-    required: false,
-    installed: true,
-    version,
-    path: binaryCheck.path,
-  }
-}
-
-function dependencyToCheckResult(dep: DependencyInfo, checkName: string): CheckResult {
-  if (dep.installed) {
-    return {
-      name: checkName,
-      status: "pass",
-      message: dep.version ?? "installed",
-      details: dep.path ? [`Path: ${dep.path}`] : undefined,
-    }
-  }
-
-  return {
-    name: checkName,
-    status: "warn",
-    message: "Not installed (optional)",
-    details: dep.installHint ? [dep.installHint] : undefined,
-  }
-}
-
-export async function checkDependencyAstGrepCli(): Promise<CheckResult> {
-  const info = await checkAstGrepCli()
-  return dependencyToCheckResult(info, CHECK_NAMES[CHECK_IDS.DEP_AST_GREP_CLI])
-}
-
-export async function checkDependencyAstGrepNapi(): Promise<CheckResult> {
-  const info = checkAstGrepNapi()
-  return dependencyToCheckResult(info, CHECK_NAMES[CHECK_IDS.DEP_AST_GREP_NAPI])
-}
-
-export async function checkDependencyCommentChecker(): Promise<CheckResult> {
-  const info = await checkCommentChecker()
-  return dependencyToCheckResult(info, CHECK_NAMES[CHECK_IDS.DEP_COMMENT_CHECKER])
-}
-
-export function getDependencyCheckDefinitions(): CheckDefinition[] {
-  return [
-    {
-      id: CHECK_IDS.DEP_AST_GREP_CLI,
-      name: CHECK_NAMES[CHECK_IDS.DEP_AST_GREP_CLI],
-      category: "dependencies",
-      check: checkDependencyAstGrepCli,
-      critical: false,
-    },
-    {
-      id: CHECK_IDS.DEP_AST_GREP_NAPI,
-      name: CHECK_NAMES[CHECK_IDS.DEP_AST_GREP_NAPI],
-      category: "dependencies",
-      check: checkDependencyAstGrepNapi,
-      critical: false,
-    },
-    {
-      id: CHECK_IDS.DEP_COMMENT_CHECKER,
-      name: CHECK_NAMES[CHECK_IDS.DEP_COMMENT_CHECKER],
-      category: "dependencies",
-      check: checkDependencyCommentChecker,
-      critical: false,
-    },
-  ]
-}

src/cli/doctor/checks/index.ts

@@ -1,31 +0,0 @@
-import type { CheckDefinition } from "../types"
-import { getOpenCodeCheckDefinition } from "./opencode"
-import { getPluginCheckDefinition } from "./plugin"
-import { getConfigCheckDefinition } from "./config"
-import { getAuthCheckDefinitions } from "./auth"
-import { getDependencyCheckDefinitions } from "./dependencies"
-import { getLspCheckDefinition } from "./lsp"
-import { getMcpCheckDefinitions } from "./mcp"
-import { getVersionCheckDefinition } from "./version"
-
-export * from "./opencode"
-export * from "./plugin"
-export * from "./config"
-export * from "./auth"
-export * from "./dependencies"
-export * from "./lsp"
-export * from "./mcp"
-export * from "./version"
-
-export function getAllCheckDefinitions(): CheckDefinition[] {
-  return [
-    getOpenCodeCheckDefinition(),
-    getPluginCheckDefinition(),
-    getConfigCheckDefinition(),
-    ...getAuthCheckDefinitions(),
-    ...getDependencyCheckDefinitions(),
-    getLspCheckDefinition(),
-    ...getMcpCheckDefinitions(),
-    getVersionCheckDefinition(),
-  ]
-}

src/cli/doctor/checks/lsp.test.ts

@@ -1,117 +0,0 @@
-import { describe, it, expect, spyOn, afterEach } from "bun:test"
-import * as lsp from "./lsp"
-import type { LspServerInfo } from "../types"
-
-describe("lsp check", () => {
-  describe("getLspServersInfo", () => {
-    it("returns array of server info", async () => {
-      // #given
-      // #when getting servers info
-      const servers = await lsp.getLspServersInfo()
-
-      // #then should return array with expected structure
-      expect(Array.isArray(servers)).toBe(true)
-      servers.forEach((s) => {
-        expect(s.id).toBeDefined()
-        expect(typeof s.installed).toBe("boolean")
-        expect(Array.isArray(s.extensions)).toBe(true)
-      })
-    })
-  })
-
-  describe("getLspServerStats", () => {
-    it("counts installed servers correctly", () => {
-      // #given servers with mixed installation status
-      const servers = [
-        { id: "ts", installed: true, extensions: [".ts"], source: "builtin" as const },
-        { id: "py", installed: false, extensions: [".py"], source: "builtin" as const },
-        { id: "go", installed: true, extensions: [".go"], source: "builtin" as const },
-      ]
-
-      // #when getting stats
-      const stats = lsp.getLspServerStats(servers)
-
-      // #then should count correctly
-      expect(stats.installed).toBe(2)
-      expect(stats.total).toBe(3)
-    })
-
-    it("handles empty array", () => {
-      // #given no servers
-      const servers: LspServerInfo[] = []
-
-      // #when getting stats
-      const stats = lsp.getLspServerStats(servers)
-
-      // #then should return zeros
-      expect(stats.installed).toBe(0)
-      expect(stats.total).toBe(0)
-    })
-  })
-
-  describe("checkLspServers", () => {
-    let getServersSpy: ReturnType<typeof spyOn>
-
-    afterEach(() => {
-      getServersSpy?.mockRestore()
-    })
-
-    it("returns warn when no servers installed", async () => {
-      // #given no servers installed
-      getServersSpy = spyOn(lsp, "getLspServersInfo").mockResolvedValue([
-        { id: "typescript-language-server", installed: false, extensions: [".ts"], source: "builtin" },
-        { id: "pyright", installed: false, extensions: [".py"], source: "builtin" },
-      ])
-
-      // #when checking
-      const result = await lsp.checkLspServers()
-
-      // #then should warn
-      expect(result.status).toBe("warn")
-      expect(result.message).toContain("No LSP servers")
-    })
-
-    it("returns pass when servers installed", async () => {
-      // #given some servers installed
-      getServersSpy = spyOn(lsp, "getLspServersInfo").mockResolvedValue([
-        { id: "typescript-language-server", installed: true, extensions: [".ts"], source: "builtin" },
-        { id: "pyright", installed: false, extensions: [".py"], source: "builtin" },
-      ])
-
-      // #when checking
-      const result = await lsp.checkLspServers()
-
-      // #then should pass with count
-      expect(result.status).toBe("pass")
-      expect(result.message).toContain("1/2")
-    })
-
-    it("lists installed and missing servers in details", async () => {
-      // #given mixed installation
-      getServersSpy = spyOn(lsp, "getLspServersInfo").mockResolvedValue([
-        { id: "typescript-language-server", installed: true, extensions: [".ts"], source: "builtin" },
-        { id: "pyright", installed: false, extensions: [".py"], source: "builtin" },
-      ])
-
-      // #when checking
-      const result = await lsp.checkLspServers()
-
-      // #then should list both
-      expect(result.details?.some((d) => d.includes("Installed"))).toBe(true)
-      expect(result.details?.some((d) => d.includes("Not found"))).toBe(true)
-    })
-  })
-
-  describe("getLspCheckDefinition", () => {
-    it("returns valid check definition", () => {
-      // #given
-      // #when getting definition
-      const def = lsp.getLspCheckDefinition()
-
-      // #then should have required properties
-      expect(def.id).toBe("lsp-servers")
-      expect(def.category).toBe("tools")
-      expect(def.critical).toBe(false)
-    })
-  })
-})

src/cli/doctor/checks/lsp.ts

@@ -1,85 +0,0 @@
-import type { CheckResult, CheckDefinition, LspServerInfo } from "../types"
-import { CHECK_IDS, CHECK_NAMES } from "../constants"
-
-const DEFAULT_LSP_SERVERS: Array<{
-  id: string
-  binary: string
-  extensions: string[]
-}> = [
-  { id: "typescript-language-server", binary: "typescript-language-server", extensions: [".ts", ".tsx", ".js", ".jsx"] },
-  { id: "pyright", binary: "pyright-langserver", extensions: [".py"] },
-  { id: "rust-analyzer", binary: "rust-analyzer", extensions: [".rs"] },
-  { id: "gopls", binary: "gopls", extensions: [".go"] },
-]
-
-async function checkBinaryExists(binary: string): Promise<boolean> {
-  try {
-    const proc = Bun.spawn(["which", binary], { stdout: "pipe", stderr: "pipe" })
-    await proc.exited
-    return proc.exitCode === 0
-  } catch {
-    return false
-  }
-}
-
-export async function getLspServersInfo(): Promise<LspServerInfo[]> {
-  const servers: LspServerInfo[] = []
-
-  for (const server of DEFAULT_LSP_SERVERS) {
-    const installed = await checkBinaryExists(server.binary)
-    servers.push({
-      id: server.id,
-      installed,
-      extensions: server.extensions,
-      source: "builtin",
-    })
-  }
-
-  return servers
-}
-
-export function getLspServerStats(servers: LspServerInfo[]): { installed: number; total: number } {
-  const installed = servers.filter((s) => s.installed).length
-  return { installed, total: servers.length }
-}
-
-export async function checkLspServers(): Promise<CheckResult> {
-  const servers = await getLspServersInfo()
-  const stats = getLspServerStats(servers)
-  const installedServers = servers.filter((s) => s.installed)
-  const missingServers = servers.filter((s) => !s.installed)
-
-  if (stats.installed === 0) {
-    return {
-      name: CHECK_NAMES[CHECK_IDS.LSP_SERVERS],
-      status: "warn",
-      message: "No LSP servers detected",
-      details: [
-        "LSP tools will have limited functionality",
-        ...missingServers.map((s) => `Missing: ${s.id}`),
-      ],
-    }
-  }
-
-  const details = [
-    ...installedServers.map((s) => `Installed: ${s.id}`),
-    ...missingServers.map((s) => `Not found: ${s.id} (optional)`),
-  ]
-
-  return {
-    name: CHECK_NAMES[CHECK_IDS.LSP_SERVERS],
-    status: "pass",
-    message: `${stats.installed}/${stats.total} servers available`,
-    details,
-  }
-}
-
-export function getLspCheckDefinition(): CheckDefinition {
-  return {
-    id: CHECK_IDS.LSP_SERVERS,
-    name: CHECK_NAMES[CHECK_IDS.LSP_SERVERS],
-    category: "tools",
-    check: checkLspServers,
-    critical: false,
-  }
-}

src/cli/doctor/checks/mcp.test.ts

@@ -1,117 +0,0 @@
-import { describe, it, expect, spyOn, afterEach } from "bun:test"
-import * as mcp from "./mcp"
-
-describe("mcp check", () => {
-  describe("getBuiltinMcpInfo", () => {
-    it("returns builtin servers", () => {
-      // #given
-      // #when getting builtin info
-      const servers = mcp.getBuiltinMcpInfo()
-
-      // #then should include expected servers
-      expect(servers.length).toBe(3)
-      expect(servers.every((s) => s.type === "builtin")).toBe(true)
-      expect(servers.every((s) => s.enabled === true)).toBe(true)
-      expect(servers.map((s) => s.id)).toContain("context7")
-      expect(servers.map((s) => s.id)).toContain("websearch_exa")
-      expect(servers.map((s) => s.id)).toContain("grep_app")
-    })
-  })
-
-  describe("getUserMcpInfo", () => {
-    it("returns empty array when no user config", () => {
-      // #given no user config exists
-      // #when getting user info
-      const servers = mcp.getUserMcpInfo()
-
-      // #then should return array (may be empty)
-      expect(Array.isArray(servers)).toBe(true)
-    })
-  })
-
-  describe("checkBuiltinMcpServers", () => {
-    it("returns pass with server count", async () => {
-      // #given
-      // #when checking builtin servers
-      const result = await mcp.checkBuiltinMcpServers()
-
-      // #then should pass
-      expect(result.status).toBe("pass")
-      expect(result.message).toContain("3")
-      expect(result.message).toContain("enabled")
-    })
-
-    it("lists enabled servers in details", async () => {
-      // #given
-      // #when checking builtin servers
-      const result = await mcp.checkBuiltinMcpServers()
-
-      // #then should list servers
-      expect(result.details?.some((d) => d.includes("context7"))).toBe(true)
-      expect(result.details?.some((d) => d.includes("websearch_exa"))).toBe(true)
-      expect(result.details?.some((d) => d.includes("grep_app"))).toBe(true)
-    })
-  })
-
-  describe("checkUserMcpServers", () => {
-    let getUserSpy: ReturnType<typeof spyOn>
-
-    afterEach(() => {
-      getUserSpy?.mockRestore()
-    })
-
-    it("returns skip when no user config", async () => {
-      // #given no user servers
-      getUserSpy = spyOn(mcp, "getUserMcpInfo").mockReturnValue([])
-
-      // #when checking
-      const result = await mcp.checkUserMcpServers()
-
-      // #then should skip
-      expect(result.status).toBe("skip")
-      expect(result.message).toContain("No user MCP")
-    })
-
-    it("returns pass when valid user servers", async () => {
-      // #given valid user servers
-      getUserSpy = spyOn(mcp, "getUserMcpInfo").mockReturnValue([
-        { id: "custom-mcp", type: "user", enabled: true, valid: true },
-      ])
-
-      // #when checking
-      const result = await mcp.checkUserMcpServers()
-
-      // #then should pass
-      expect(result.status).toBe("pass")
-      expect(result.message).toContain("1")
-    })
-
-    it("returns warn when servers have issues", async () => {
-      // #given invalid server config
-      getUserSpy = spyOn(mcp, "getUserMcpInfo").mockReturnValue([
-        { id: "bad-mcp", type: "user", enabled: true, valid: false, error: "Missing command" },
-      ])
-
-      // #when checking
-      const result = await mcp.checkUserMcpServers()
-
-      // #then should warn
-      expect(result.status).toBe("warn")
-      expect(result.details?.some((d) => d.includes("Invalid"))).toBe(true)
-    })
-  })
-
-  describe("getMcpCheckDefinitions", () => {
-    it("returns definitions for builtin and user", () => {
-      // #given
-      // #when getting definitions
-      const defs = mcp.getMcpCheckDefinitions()
-
-      // #then should have 2 definitions
-      expect(defs.length).toBe(2)
-      expect(defs.every((d) => d.category === "tools")).toBe(true)
-      expect(defs.map((d) => d.id)).toContain("mcp-builtin")
-      expect(defs.map((d) => d.id)).toContain("mcp-user")
-    })
-  })
-})

src/cli/doctor/checks/mcp.ts

@@ -1,128 +0,0 @@
-import { existsSync, readFileSync } from "node:fs"
-import { homedir } from "node:os"
-import { join } from "node:path"
-import type { CheckResult, CheckDefinition, McpServerInfo } from "../types"
-import { CHECK_IDS, CHECK_NAMES } from "../constants"
-import { parseJsonc } from "../../../shared"
-
-const BUILTIN_MCP_SERVERS = ["context7", "websearch_exa", "grep_app"]
-
-const MCP_CONFIG_PATHS = [
-  join(homedir(), ".claude", ".mcp.json"),
-  join(process.cwd(), ".mcp.json"),
-  join(process.cwd(), ".claude", ".mcp.json"),
-]
-
-interface McpConfig {
-  mcpServers?: Record<string, unknown>
-}
-
-function loadUserMcpConfig(): Record<string, unknown> {
-  const servers: Record<string, unknown> = {}
-
-  for (const configPath of MCP_CONFIG_PATHS) {
-    if (!existsSync(configPath)) continue
-
-    try {
-      const content = readFileSync(configPath, "utf-8")
-      const config = parseJsonc<McpConfig>(content)
-      if (config.mcpServers) {
-        Object.assign(servers, config.mcpServers)
-      }
-    } catch {
-      // intentionally empty - skip invalid configs
-    }
-  }
-
-  return servers
-}
-
-export function getBuiltinMcpInfo(): McpServerInfo[] {
-  return BUILTIN_MCP_SERVERS.map((id) => ({
-    id,
-    type: "builtin" as const,
-    enabled: true,
-    valid: true,
-  }))
-}
-
-export function getUserMcpInfo(): McpServerInfo[] {
-  const userServers = loadUserMcpConfig()
-  const servers: McpServerInfo[] = []
-
-  for (const [id, config] of Object.entries(userServers)) {
-    const isValid = typeof config === "object" && config !== null
-    servers.push({
-      id,
-      type: "user",
-      enabled: true,
-      valid: isValid,
-      error: isValid ? undefined : "Invalid configuration format",
-    })
-  }
-
-  return servers
-}
-
-export async function checkBuiltinMcpServers(): Promise<CheckResult> {
-  const servers = getBuiltinMcpInfo()
-
-  return {
-    name: CHECK_NAMES[CHECK_IDS.MCP_BUILTIN],
-    status: "pass",
-    message: `${servers.length} built-in servers enabled`,
-    details: servers.map((s) => `Enabled: ${s.id}`),
-  }
-}
-
-export async function checkUserMcpServers(): Promise<CheckResult> {
-  const servers = getUserMcpInfo()
-
-  if (servers.length === 0) {
-    return {
-      name: CHECK_NAMES[CHECK_IDS.MCP_USER],
-      status: "skip",
-      message: "No user MCP configuration found",
-      details: ["Optional: Add .mcp.json for custom MCP servers"],
-    }
-  }
-
-  const invalidServers = servers.filter((s) => !s.valid)
-  if (invalidServers.length > 0) {
-    return {
-      name: CHECK_NAMES[CHECK_IDS.MCP_USER],
-      status: "warn",
-      message: `${invalidServers.length} server(s) have configuration issues`,
-      details: [
-        ...servers.filter((s) => s.valid).map((s) => `Valid: ${s.id}`),
-        ...invalidServers.map((s) => `Invalid: ${s.id} - ${s.error}`),
-      ],
-    }
-  }
-
-  return {
-    name: CHECK_NAMES[CHECK_IDS.MCP_USER],
-    status: "pass",
-    message: `${servers.length} user server(s) configured`,
-    details: servers.map((s) => `Configured: ${s.id}`),
-  }
-}
-
-export function getMcpCheckDefinitions(): CheckDefinition[] {
-  return [
-    {
-      id: CHECK_IDS.MCP_BUILTIN,
-      name: CHECK_NAMES[CHECK_IDS.MCP_BUILTIN],
-      category: "tools",
-      check: checkBuiltinMcpServers,
-      critical: false,
-    },
-    {
-      id: CHECK_IDS.MCP_USER,
-      name: CHECK_NAMES[CHECK_IDS.MCP_USER],
-      category: "tools",
-      check: checkUserMcpServers,
-      critical: false,
-    },
-  ]
-}

src/cli/doctor/checks/opencode.test.ts

@@ -1,139 +0,0 @@
-import { describe, it, expect, spyOn, beforeEach, afterEach } from "bun:test"
-import * as opencode from "./opencode"
-import { MIN_OPENCODE_VERSION } from "../constants"
-
-describe("opencode check", () => {
-  describe("compareVersions", () => {
-    it("returns true when current >= minimum", () => {
-      // #given versions where current is greater
-      // #when comparing
-      // #then should return true
-      expect(opencode.compareVersions("1.0.200", "1.0.150")).toBe(true)
-      expect(opencode.compareVersions("1.1.0", "1.0.150")).toBe(true)
-      expect(opencode.compareVersions("2.0.0", "1.0.150")).toBe(true)
-    })
-
-    it("returns true when versions are equal", () => {
-      // #given equal versions
-      // #when comparing
-      // #then should return true
-      expect(opencode.compareVersions("1.0.150", "1.0.150")).toBe(true)
-    })
-
-    it("returns false when current < minimum", () => {
-      // #given version below minimum
-      // #when comparing
-      // #then should return false
-      expect(opencode.compareVersions("1.0.100", "1.0.150")).toBe(false)
-      expect(opencode.compareVersions("0.9.0", "1.0.150")).toBe(false)
-    })
-
-    it("handles version prefixes", () => {
-      // #given version with v prefix
-      // #when comparing
-      // #then should strip prefix and compare correctly
-      expect(opencode.compareVersions("v1.0.200", "1.0.150")).toBe(true)
-    })
-
-    it("handles prerelease versions", () => {
-      // #given prerelease version
-      // #when comparing
-      // #then should use base version
-      expect(opencode.compareVersions("1.0.200-beta.1", "1.0.150")).toBe(true)
-    })
-  })
-
-  describe("getOpenCodeInfo", () => {
-    it("returns installed: false when binary not found", async () => {
-      // #given no opencode binary
-      const spy = spyOn(opencode, "findOpenCodeBinary").mockResolvedValue(null)
-
-      // #when getting info
-      const info = await opencode.getOpenCodeInfo()
-
-      // #then should indicate not installed
-      expect(info.installed).toBe(false)
-      expect(info.version).toBeNull()
-      expect(info.path).toBeNull()
-      expect(info.binary).toBeNull()
-
-      spy.mockRestore()
-    })
-  })
-
-  describe("checkOpenCodeInstallation", () => {
-    let getInfoSpy: ReturnType<typeof spyOn>
-
-    afterEach(() => {
-      getInfoSpy?.mockRestore()
-    })
-
-    it("returns fail when not installed", async () => {
-      // #given opencode not installed
-      getInfoSpy = spyOn(opencode, "getOpenCodeInfo").mockResolvedValue({
-        installed: false,
-        version: null,
-        path: null,
-        binary: null,
-      })
-
-      // #when checking installation
-      const result = await opencode.checkOpenCodeInstallation()
-
-      // #then should fail with installation hint
-      expect(result.status).toBe("fail")
-      expect(result.message).toContain("not installed")
-      expect(result.details).toBeDefined()
-      expect(result.details?.some((d) => d.includes("opencode.ai"))).toBe(true)
-    })
-
-    it("returns warn when version below minimum", async () => {
-      // #given old version installed
-      getInfoSpy = spyOn(opencode, "getOpenCodeInfo").mockResolvedValue({
-        installed: true,
-        version: "1.0.100",
-        path: "/usr/local/bin/opencode",
-        binary: "opencode",
-      })
-
-      // #when checking installation
-      const result = await opencode.checkOpenCodeInstallation()
-
-      // #then should warn about old version
-      expect(result.status).toBe("warn")
-      expect(result.message).toContain("below minimum")
-      expect(result.details?.some((d) => d.includes(MIN_OPENCODE_VERSION))).toBe(true)
-    })
-
-    it("returns pass when properly installed", async () => {
-      // #given current version installed
-      getInfoSpy = spyOn(opencode, "getOpenCodeInfo").mockResolvedValue({
-        installed: true,
-        version: "1.0.200",
-        path: "/usr/local/bin/opencode",
-        binary: "opencode",
-      })
-
-      // #when checking installation
-      const result = await opencode.checkOpenCodeInstallation()
-
-      // #then should pass
-      expect(result.status).toBe("pass")
-      expect(result.message).toContain("1.0.200")
-    })
-  })
-
-  describe("getOpenCodeCheckDefinition", () => {
-    it("returns valid check definition", () => {
-      // #given
-      // #when getting definition
-      const def = opencode.getOpenCodeCheckDefinition()
-
-      // #then should have required properties
-      expect(def.id).toBe("opencode-installation")
-      expect(def.category).toBe("installation")
-      expect(def.critical).toBe(true)
-      expect(typeof def.check).toBe("function")
-    })
-  })
-})

src/cli/doctor/checks/opencode.ts

@@ -1,118 +0,0 @@
-import type { CheckResult, CheckDefinition, OpenCodeInfo } from "../types"
-import { CHECK_IDS, CHECK_NAMES, MIN_OPENCODE_VERSION, OPENCODE_BINARIES } from "../constants"
-
-export async function findOpenCodeBinary(): Promise<{ binary: string; path: string } | null> {
-  for (const binary of OPENCODE_BINARIES) {
-    try {
-      const proc = Bun.spawn(["which", binary], { stdout: "pipe", stderr: "pipe" })
-      const output = await new Response(proc.stdout).text()
-      await proc.exited
-      if (proc.exitCode === 0) {
-        return { binary, path: output.trim() }
-      }
-    } catch {
-      continue
-    }
-  }
-  return null
-}
-
-export async function getOpenCodeVersion(binary: string): Promise<string | null> {
-  try {
-    const proc = Bun.spawn([binary, "--version"], { stdout: "pipe", stderr: "pipe" })
-    const output = await new Response(proc.stdout).text()
-    await proc.exited
-    if (proc.exitCode === 0) {
-      return output.trim()
-    }
-  } catch {
-    return null
-  }
-  return null
-}
-
-export function compareVersions(current: string, minimum: string): boolean {
-  const parseVersion = (v: string): number[] => {
-    const cleaned = v.replace(/^v/, "").split("-")[0]
-    return cleaned.split(".").map((n) => parseInt(n, 10) || 0)
-  }
-
-  const curr = parseVersion(current)
-  const min = parseVersion(minimum)
-
-  for (let i = 0; i < Math.max(curr.length, min.length); i++) {
-    const c = curr[i] ?? 0
-    const m = min[i] ?? 0
-    if (c > m) return true
-    if (c < m) return false
-  }
-  return true
-}
-
-export async function getOpenCodeInfo(): Promise<OpenCodeInfo> {
-  const binaryInfo = await findOpenCodeBinary()
-
-  if (!binaryInfo) {
-    return {
-      installed: false,
-      version: null,
-      path: null,
-      binary: null,
-    }
-  }
-
-  const version = await getOpenCodeVersion(binaryInfo.binary)
-
-  return {
-    installed: true,
-    version,
-    path: binaryInfo.path,
-    binary: binaryInfo.binary as "opencode" | "opencode-desktop",
-  }
-}
-
-export async function checkOpenCodeInstallation(): Promise<CheckResult> {
-  const info = await getOpenCodeInfo()
-
-  if (!info.installed) {
-    return {
-      name: CHECK_NAMES[CHECK_IDS.OPENCODE_INSTALLATION],
-      status: "fail",
-      message: "OpenCode is not installed",
-      details: [
-        "Visit: https://opencode.ai/docs for installation instructions",
-        "Run: npm install -g opencode",
-      ],
-    }
-  }
-
-  if (info.version && !compareVersions(info.version, MIN_OPENCODE_VERSION)) {
-    return {
-      name: CHECK_NAMES[CHECK_IDS.OPENCODE_INSTALLATION],
-      status: "warn",
-      message: `Version ${info.version} is below minimum ${MIN_OPENCODE_VERSION}`,
-      details: [
-        `Current: ${info.version}`,
-        `Required: >= ${MIN_OPENCODE_VERSION}`,
-        "Run: npm update -g opencode",
-      ],
-    }
-  }
-
-  return {
-    name: CHECK_NAMES[CHECK_IDS.OPENCODE_INSTALLATION],
-    status: "pass",
-    message: info.version ?? "installed",
-    details: info.path ? [`Path: ${info.path}`] : undefined,
-  }
-}
-
-export function getOpenCodeCheckDefinition(): CheckDefinition {
-  return {
-    id: CHECK_IDS.OPENCODE_INSTALLATION,
-    name: CHECK_NAMES[CHECK_IDS.OPENCODE_INSTALLATION],
-    category: "installation",
-    check: checkOpenCodeInstallation,
-    critical: true,
-  }
-}

src/cli/doctor/checks/plugin.test.ts

@@ -1,109 +0,0 @@
-import { describe, it, expect, spyOn, afterEach } from "bun:test"
-import * as plugin from "./plugin"
-
-describe("plugin check", () => {
-  describe("getPluginInfo", () => {
-    it("returns registered: false when config not found", () => {
-      // #given no config file exists
-      // #when getting plugin info
-      // #then should indicate not registered
-      const info = plugin.getPluginInfo()
-      expect(typeof info.registered).toBe("boolean")
-      expect(typeof info.isPinned).toBe("boolean")
-    })
-  })
-
-  describe("checkPluginRegistration", () => {
-    let getInfoSpy: ReturnType<typeof spyOn>
-
-    afterEach(() => {
-      getInfoSpy?.mockRestore()
-    })
-
-    it("returns fail when config file not found", async () => {
-      // #given no config file
-      getInfoSpy = spyOn(plugin, "getPluginInfo").mockReturnValue({
-        registered: false,
-        configPath: null,
-        entry: null,
-        isPinned: false,
-        pinnedVersion: null,
-      })
-
-      // #when checking registration
-      const result = await plugin.checkPluginRegistration()
-
-      // #then should fail with hint
-      expect(result.status).toBe("fail")
-      expect(result.message).toContain("not found")
-    })
-
-    it("returns fail when plugin not registered", async () => {
-      // #given config exists but plugin not registered
-      getInfoSpy = spyOn(plugin, "getPluginInfo").mockReturnValue({
-        registered: false,
-        configPath: "/home/user/.config/opencode/opencode.json",
-        entry: null,
-        isPinned: false,
-        pinnedVersion: null,
-      })
-
-      // #when checking registration
-      const result = await plugin.checkPluginRegistration()
-
-      // #then should fail
-      expect(result.status).toBe("fail")
-      expect(result.message).toContain("not registered")
-    })
-
-    it("returns pass when plugin registered", async () => {
-      // #given plugin registered
-      getInfoSpy = spyOn(plugin, "getPluginInfo").mockReturnValue({
-        registered: true,
-        configPath: "/home/user/.config/opencode/opencode.json",
-        entry: "oh-my-opencode",
-        isPinned: false,
-        pinnedVersion: null,
-      })
-
-      // #when checking registration
-      const result = await plugin.checkPluginRegistration()
-
-      // #then should pass
-      expect(result.status).toBe("pass")
-      expect(result.message).toContain("Registered")
-    })
-
-    it("indicates pinned version when applicable", async () => {
-      // #given plugin pinned to version
-      getInfoSpy = spyOn(plugin, "getPluginInfo").mockReturnValue({
-        registered: true,
-        configPath: "/home/user/.config/opencode/opencode.json",
-        entry: "oh-my-opencode@2.7.0",
-        isPinned: true,
-        pinnedVersion: "2.7.0",
-      })
-
-      // #when checking registration
-      const result = await plugin.checkPluginRegistration()
-
-      // #then should show pinned version
-      expect(result.status).toBe("pass")
-      expect(result.message).toContain("pinned")
-      expect(result.message).toContain("2.7.0")
-    })
-  })
-
-  describe("getPluginCheckDefinition", () => {
-    it("returns valid check definition", () => {
-      // #given
-      // #when getting definition
-      const def = plugin.getPluginCheckDefinition()
-
-      // #then should have required properties
-      expect(def.id).toBe("plugin-registration")
-      expect(def.category).toBe("installation")
-      expect(def.critical).toBe(true)
-    })
-  })
-})

src/cli/doctor/checks/plugin.ts

@@ -1,127 +0,0 @@
-import { existsSync, readFileSync } from "node:fs"
-import { homedir } from "node:os"
-import { join } from "node:path"
-import type { CheckResult, CheckDefinition, PluginInfo } from "../types"
-import { CHECK_IDS, CHECK_NAMES, PACKAGE_NAME } from "../constants"
-import { parseJsonc } from "../../../shared"
-
-const OPENCODE_CONFIG_DIR = join(homedir(), ".config", "opencode")
-const OPENCODE_JSON = join(OPENCODE_CONFIG_DIR, "opencode.json")
-const OPENCODE_JSONC = join(OPENCODE_CONFIG_DIR, "opencode.jsonc")
-
-function detectConfigPath(): { path: string; format: "json" | "jsonc" } | null {
-  if (existsSync(OPENCODE_JSONC)) {
-    return { path: OPENCODE_JSONC, format: "jsonc" }
-  }
-  if (existsSync(OPENCODE_JSON)) {
-    return { path: OPENCODE_JSON, format: "json" }
-  }
-  return null
-}
-
-function findPluginEntry(plugins: string[]): { entry: string; isPinned: boolean; version: string | null } | null {
-  for (const plugin of plugins) {
-    if (plugin === PACKAGE_NAME || plugin.startsWith(`${PACKAGE_NAME}@`)) {
-      const isPinned = plugin.includes("@")
-      const version = isPinned ? plugin.split("@")[1] : null
-      return { entry: plugin, isPinned, version }
-    }
-  }
-  return null
-}
-
-export function getPluginInfo(): PluginInfo {
-  const configInfo = detectConfigPath()
-
-  if (!configInfo) {
-    return {
-      registered: false,
-      configPath: null,
-      entry: null,
-      isPinned: false,
-      pinnedVersion: null,
-    }
-  }
-
-  try {
-    const content = readFileSync(configInfo.path, "utf-8")
-    const config = parseJsonc<{ plugin?: string[] }>(content)
-    const plugins = config.plugin ?? []
-    const pluginEntry = findPluginEntry(plugins)
-
-    if (!pluginEntry) {
-      return {
-        registered: false,
-        configPath: configInfo.path,
-        entry: null,
-        isPinned: false,
-        pinnedVersion: null,
-      }
-    }
-
-    return {
-      registered: true,
-      configPath: configInfo.path,
-      entry: pluginEntry.entry,
-      isPinned: pluginEntry.isPinned,
-      pinnedVersion: pluginEntry.version,
-    }
-  } catch {
-    return {
-      registered: false,
-      configPath: configInfo.path,
-      entry: null,
-      isPinned: false,
-      pinnedVersion: null,
-    }
-  }
-}
-
-export async function checkPluginRegistration(): Promise<CheckResult> {
-  const info = getPluginInfo()
-
-  if (!info.configPath) {
-    return {
-      name: CHECK_NAMES[CHECK_IDS.PLUGIN_REGISTRATION],
-      status: "fail",
-      message: "OpenCode config file not found",
-      details: [
-        "Run: bunx oh-my-opencode install",
-        `Expected: ${OPENCODE_JSON} or ${OPENCODE_JSONC}`,
-      ],
-    }
-  }
-
-  if (!info.registered) {
-    return {
-      name: CHECK_NAMES[CHECK_IDS.PLUGIN_REGISTRATION],
-      status: "fail",
-      message: "Plugin not registered in config",
-      details: [
-        "Run: bunx oh-my-opencode install",
-        `Config: ${info.configPath}`,
-      ],
-    }
-  }
-
-  const message = info.isPinned
-    ? `Registered (pinned: ${info.pinnedVersion})`
-    : "Registered"
-
-  return {
-    name: CHECK_NAMES[CHECK_IDS.PLUGIN_REGISTRATION],
-    status: "pass",
-    message,
-    details: [`Config: ${info.configPath}`],
-  }
-}
-
-export function getPluginCheckDefinition(): CheckDefinition {
-  return {
-    id: CHECK_IDS.PLUGIN_REGISTRATION,
-    name: CHECK_NAMES[CHECK_IDS.PLUGIN_REGISTRATION],
-    category: "installation",
-    check: checkPluginRegistration,
-    critical: true,
-  }
-}

src/cli/doctor/checks/version.test.ts

@@ -1,148 +0,0 @@
-import { describe, it, expect, spyOn, afterEach } from "bun:test"
-import * as version from "./version"
-
-describe("version check", () => {
-  describe("getVersionInfo", () => {
-    it("returns version check info structure", async () => {
-      // #given
-      // #when getting version info
-      const info = await version.getVersionInfo()
-
-      // #then should have expected structure
-      expect(typeof info.isUpToDate).toBe("boolean")
-      expect(typeof info.isLocalDev).toBe("boolean")
-      expect(typeof info.isPinned).toBe("boolean")
-    })
-  })
-
-  describe("checkVersionStatus", () => {
-    let getInfoSpy: ReturnType<typeof spyOn>
-
-    afterEach(() => {
-      getInfoSpy?.mockRestore()
-    })
-
-    it("returns pass when in local dev mode", async () => {
-      // #given local dev mode
-      getInfoSpy = spyOn(version, "getVersionInfo").mockResolvedValue({
-        currentVersion: "local-dev",
-        latestVersion: "2.7.0",
-        isUpToDate: true,
-        isLocalDev: true,
-        isPinned: false,
-      })
-
-      // #when checking
-      const result = await version.checkVersionStatus()
-
-      // #then should pass with dev message
-      expect(result.status).toBe("pass")
-      expect(result.message).toContain("local development")
-    })
-
-    it("returns pass when pinned", async () => {
-      // #given pinned version
-      getInfoSpy = spyOn(version, "getVersionInfo").mockResolvedValue({
-        currentVersion: "2.6.0",
-        latestVersion: "2.7.0",
-        isUpToDate: true,
-        isLocalDev: false,
-        isPinned: true,
-      })
-
-      // #when checking
-      const result = await version.checkVersionStatus()
-
-      // #then should pass with pinned message
-      expect(result.status).toBe("pass")
-      expect(result.message).toContain("Pinned")
-    })
-
-    it("returns warn when unable to determine version", async () => {
-      // #given no version info
-      getInfoSpy = spyOn(version, "getVersionInfo").mockResolvedValue({
-        currentVersion: null,
-        latestVersion: "2.7.0",
-        isUpToDate: false,
-        isLocalDev: false,
-        isPinned: false,
-      })
-
-      // #when checking
-      const result = await version.checkVersionStatus()
-
-      // #then should warn
-      expect(result.status).toBe("warn")
-      expect(result.message).toContain("Unable to determine")
-    })
-
-    it("returns warn when network error", async () => {
-      // #given network error
-      getInfoSpy = spyOn(version, "getVersionInfo").mockResolvedValue({
-        currentVersion: "2.6.0",
-        latestVersion: null,
-        isUpToDate: true,
-        isLocalDev: false,
-        isPinned: false,
-      })
-
-      // #when checking
-      const result = await version.checkVersionStatus()
-
-      // #then should warn
-      expect(result.status).toBe("warn")
-      expect(result.details?.some((d) => d.includes("network"))).toBe(true)
-    })
-
-    it("returns warn when update available", async () => {
-      // #given update available
-      getInfoSpy = spyOn(version, "getVersionInfo").mockResolvedValue({
-        currentVersion: "2.6.0",
-        latestVersion: "2.7.0",
-        isUpToDate: false,
-        isLocalDev: false,
-        isPinned: false,
-      })
-
-      // #when checking
-      const result = await version.checkVersionStatus()
-
-      // #then should warn with update info
-      expect(result.status).toBe("warn")
-      expect(result.message).toContain("Update available")
-      expect(result.message).toContain("2.6.0")
-      expect(result.message).toContain("2.7.0")
-    })
-
-    it("returns pass when up to date", async () => {
-      // #given up to date
-      getInfoSpy = spyOn(version, "getVersionInfo").mockResolvedValue({
-        currentVersion: "2.7.0",
-        latestVersion: "2.7.0",
-        isUpToDate: true,
-        isLocalDev: false,
-        isPinned: false,
-      })
-
-      // #when checking
-      const result = await version.checkVersionStatus()
-
-      // #then should pass
-      expect(result.status).toBe("pass")
-      expect(result.message).toContain("Up to date")
-    })
-  })
-
-  describe("getVersionCheckDefinition", () => {
-    it("returns valid check definition", () => {
-      // #given
-      // #when getting definition
-      const def = version.getVersionCheckDefinition()
-
-      // #then should have required properties
-      expect(def.id).toBe("version-status")
-      expect(def.category).toBe("updates")
-      expect(def.critical).toBe(false)
-    })
-  })
-})

src/cli/doctor/checks/version.ts

@@ -1,133 +0,0 @@
-import type { CheckResult, CheckDefinition, VersionCheckInfo } from "../types"
-import { CHECK_IDS, CHECK_NAMES } from "../constants"
-import {
-  getCachedVersion,
-  getLatestVersion,
-  isLocalDevMode,
-  findPluginEntry,
-} from "../../../hooks/auto-update-checker/checker"
-
-function compareVersions(current: string, latest: string): boolean {
-  const parseVersion = (v: string): number[] => {
-    const cleaned = v.replace(/^v/, "").split("-")[0]
-    return cleaned.split(".").map((n) => parseInt(n, 10) || 0)
-  }
-
-  const curr = parseVersion(current)
-  const lat = parseVersion(latest)
-
-  for (let i = 0; i < Math.max(curr.length, lat.length); i++) {
-    const c = curr[i] ?? 0
-    const l = lat[i] ?? 0
-    if (c < l) return false
-    if (c > l) return true
-  }
-  return true
-}
-
-export async function getVersionInfo(): Promise<VersionCheckInfo> {
-  const cwd = process.cwd()
-
-  if (isLocalDevMode(cwd)) {
-    return {
-      currentVersion: "local-dev",
-      latestVersion: null,
-      isUpToDate: true,
-      isLocalDev: true,
-      isPinned: false,
-    }
-  }
-
-  const pluginInfo = findPluginEntry(cwd)
-  if (pluginInfo?.isPinned) {
-    return {
-      currentVersion: pluginInfo.pinnedVersion,
-      latestVersion: null,
-      isUpToDate: true,
-      isLocalDev: false,
-      isPinned: true,
-    }
-  }
-
-  const currentVersion = getCachedVersion()
-  const latestVersion = await getLatestVersion()
-
-  const isUpToDate =
-    !currentVersion ||
-    !latestVersion ||
-    compareVersions(currentVersion, latestVersion)
-
-  return {
-    currentVersion,
-    latestVersion,
-    isUpToDate,
-    isLocalDev: false,
-    isPinned: false,
-  }
-}
-
-export async function checkVersionStatus(): Promise<CheckResult> {
-  const info = await getVersionInfo()
-
-  if (info.isLocalDev) {
-    return {
-      name: CHECK_NAMES[CHECK_IDS.VERSION_STATUS],
-      status: "pass",
-      message: "Running in local development mode",
-      details: ["Using file:// protocol from config"],
-    }
-  }
-
-  if (info.isPinned) {
-    return {
-      name: CHECK_NAMES[CHECK_IDS.VERSION_STATUS],
-      status: "pass",
-      message: `Pinned to version ${info.currentVersion}`,
-      details: ["Update check skipped for pinned versions"],
-    }
-  }
-
-  if (!info.currentVersion) {
-    return {
-      name: CHECK_NAMES[CHECK_IDS.VERSION_STATUS],
-      status: "warn",
-      message: "Unable to determine current version",
-      details: ["Run: bunx oh-my-opencode get-local-version"],
-    }
-  }
-
-  if (!info.latestVersion) {
-    return {
-      name: CHECK_NAMES[CHECK_IDS.VERSION_STATUS],
-      status: "warn",
-      message: `Current: ${info.currentVersion}`,
-      details: ["Unable to check for updates (network error)"],
-    }
-  }
-
-  if (!info.isUpToDate) {
-    return {
-      name: CHECK_NAMES[CHECK_IDS.VERSION_STATUS],
-      status: "warn",
-      message: `Update available: ${info.currentVersion} -> ${info.latestVersion}`,
-      details: ["Run: cd ~/.config/opencode && bun update oh-my-opencode"],
-    }
-  }
-
-  return {
-    name: CHECK_NAMES[CHECK_IDS.VERSION_STATUS],
-    status: "pass",
-    message: `Up to date (${info.currentVersion})`,
-    details: info.latestVersion ? [`Latest: ${info.latestVersion}`] : undefined,
-  }
-}
-
-export function getVersionCheckDefinition(): CheckDefinition {
-  return {
-    id: CHECK_IDS.VERSION_STATUS,
-    name: CHECK_NAMES[CHECK_IDS.VERSION_STATUS],
-    category: "updates",
-    check: checkVersionStatus,
-    critical: false,
-  }
-}

src/cli/doctor/constants.ts

@@ -1,70 +0,0 @@
-import color from "picocolors"
-
-export const SYMBOLS = {
-  check: color.green("\u2713"),
-  cross: color.red("\u2717"),
-  warn: color.yellow("\u26A0"),
-  info: color.blue("\u2139"),
-  arrow: color.cyan("\u2192"),
-  bullet: color.dim("\u2022"),
-  skip: color.dim("\u25CB"),
-} as const
-
-export const STATUS_COLORS = {
-  pass: color.green,
-  fail: color.red,
-  warn: color.yellow,
-  skip: color.dim,
-} as const
-
-export const CHECK_IDS = {
-  OPENCODE_INSTALLATION: "opencode-installation",
-  PLUGIN_REGISTRATION: "plugin-registration",
-  CONFIG_VALIDATION: "config-validation",
-  AUTH_ANTHROPIC: "auth-anthropic",
-  AUTH_OPENAI: "auth-openai",
-  AUTH_GOOGLE: "auth-google",
-  DEP_AST_GREP_CLI: "dep-ast-grep-cli",
-  DEP_AST_GREP_NAPI: "dep-ast-grep-napi",
-  DEP_COMMENT_CHECKER: "dep-comment-checker",
-  LSP_SERVERS: "lsp-servers",
-  MCP_BUILTIN: "mcp-builtin",
-  MCP_USER: "mcp-user",
-  VERSION_STATUS: "version-status",
-} as const
-
-export const CHECK_NAMES: Record<string, string> = {
-  [CHECK_IDS.OPENCODE_INSTALLATION]: "OpenCode Installation",
-  [CHECK_IDS.PLUGIN_REGISTRATION]: "Plugin Registration",
-  [CHECK_IDS.CONFIG_VALIDATION]: "Configuration Validity",
-  [CHECK_IDS.AUTH_ANTHROPIC]: "Anthropic (Claude) Auth",
-  [CHECK_IDS.AUTH_OPENAI]: "OpenAI (ChatGPT) Auth",
-  [CHECK_IDS.AUTH_GOOGLE]: "Google (Gemini) Auth",
-  [CHECK_IDS.DEP_AST_GREP_CLI]: "AST-Grep CLI",
-  [CHECK_IDS.DEP_AST_GREP_NAPI]: "AST-Grep NAPI",
-  [CHECK_IDS.DEP_COMMENT_CHECKER]: "Comment Checker",
-  [CHECK_IDS.LSP_SERVERS]: "LSP Servers",
-  [CHECK_IDS.MCP_BUILTIN]: "Built-in MCP Servers",
-  [CHECK_IDS.MCP_USER]: "User MCP Configuration",
-  [CHECK_IDS.VERSION_STATUS]: "Version Status",
-} as const
-
-export const CATEGORY_NAMES: Record<string, string> = {
-  installation: "Installation",
-  configuration: "Configuration",
-  authentication: "Authentication",
-  dependencies: "Dependencies",
-  tools: "Tools & Servers",
-  updates: "Updates",
-} as const
-
-export const EXIT_CODES = {
-  SUCCESS: 0,
-  FAILURE: 1,
-} as const
-
-export const MIN_OPENCODE_VERSION = "1.0.150"
-
-export const PACKAGE_NAME = "oh-my-opencode"
-
-export const OPENCODE_BINARIES = ["opencode", "opencode-desktop"] as const

src/cli/doctor/formatter.test.ts

@@ -1,218 +0,0 @@
-import { describe, it, expect } from "bun:test"
-import {
-  formatStatusSymbol,
-  formatCheckResult,
-  formatCategoryHeader,
-  formatSummary,
-  formatHeader,
-  formatFooter,
-  formatJsonOutput,
-  formatBox,
-  formatHelpSuggestions,
-} from "./formatter"
-import type { CheckResult, DoctorSummary, DoctorResult } from "./types"
-
-describe("formatter", () => {
-  describe("formatStatusSymbol", () => {
-    it("returns green check for pass", () => {
-      const symbol = formatStatusSymbol("pass")
-      expect(symbol).toContain("\u2713")
-    })
-
-    it("returns red cross for fail", () => {
-      const symbol = formatStatusSymbol("fail")
-      expect(symbol).toContain("\u2717")
-    })
-
-    it("returns yellow warning for warn", () => {
-      const symbol = formatStatusSymbol("warn")
-      expect(symbol).toContain("\u26A0")
-    })
-
-    it("returns dim circle for skip", () => {
-      const symbol = formatStatusSymbol("skip")
-      expect(symbol).toContain("\u25CB")
-    })
-  })
-
-  describe("formatCheckResult", () => {
-    it("includes name and message", () => {
-      const result: CheckResult = {
-        name: "Test Check",
-        status: "pass",
-        message: "All good",
-      }
-
-      const output = formatCheckResult(result, false)
-
-      expect(output).toContain("Test Check")
-      expect(output).toContain("All good")
-    })
-
-    it("includes details when verbose", () => {
-      const result: CheckResult = {
-        name: "Test Check",
-        status: "pass",
-        message: "OK",
-        details: ["Detail 1", "Detail 2"],
-      }
-
-      const output = formatCheckResult(result, true)
-
-      expect(output).toContain("Detail 1")
-      expect(output).toContain("Detail 2")
-    })
-
-    it("hides details when not verbose", () => {
-      const result: CheckResult = {
-        name: "Test Check",
-        status: "pass",
-        message: "OK",
-        details: ["Detail 1"],
-      }
-
-      const output = formatCheckResult(result, false)
-
-      expect(output).not.toContain("Detail 1")
-    })
-  })
-
-  describe("formatCategoryHeader", () => {
-    it("formats category name with styling", () => {
-      const header = formatCategoryHeader("installation")
-
-      expect(header).toContain("Installation")
-    })
-  })
-
-  describe("formatSummary", () => {
-    it("shows all counts", () => {
-      const summary: DoctorSummary = {
-        total: 10,
-        passed: 7,
-        failed: 1,
-        warnings: 2,
-        skipped: 0,
-        duration: 150,
-      }
-
-      const output = formatSummary(summary)
-
-      expect(output).toContain("7 passed")
-      expect(output).toContain("1 failed")
-      expect(output).toContain("2 warnings")
-      expect(output).toContain("10 checks")
-      expect(output).toContain("150ms")
-    })
-  })
-
-  describe("formatHeader", () => {
-    it("includes doctor branding", () => {
-      const header = formatHeader()
-
-      expect(header).toContain("Doctor")
-    })
-  })
-
-  describe("formatFooter", () => {
-    it("shows error message when failures", () => {
-      const summary: DoctorSummary = {
-        total: 5,
-        passed: 4,
-        failed: 1,
-        warnings: 0,
-        skipped: 0,
-        duration: 100,
-      }
-
-      const footer = formatFooter(summary)
-
-      expect(footer).toContain("Issues detected")
-    })
-
-    it("shows warning message when warnings only", () => {
-      const summary: DoctorSummary = {
-        total: 5,
-        passed: 4,
-        failed: 0,
-        warnings: 1,
-        skipped: 0,
-        duration: 100,
-      }
-
-      const footer = formatFooter(summary)
-
-      expect(footer).toContain("warnings")
-    })
-
-    it("shows success message when all pass", () => {
-      const summary: DoctorSummary = {
-        total: 5,
-        passed: 5,
-        failed: 0,
-        warnings: 0,
-        skipped: 0,
-        duration: 100,
-      }
-
-      const footer = formatFooter(summary)
-
-      expect(footer).toContain("operational")
-    })
-  })
-
-  describe("formatJsonOutput", () => {
-    it("returns valid JSON", () => {
-      const result: DoctorResult = {
-        results: [{ name: "Test", status: "pass", message: "OK" }],
-        summary: { total: 1, passed: 1, failed: 0, warnings: 0, skipped: 0, duration: 50 },
-        exitCode: 0,
-      }
-
-      const output = formatJsonOutput(result)
-      const parsed = JSON.parse(output)
-
-      expect(parsed.results.length).toBe(1)
-      expect(parsed.summary.total).toBe(1)
-      expect(parsed.exitCode).toBe(0)
-    })
-  })
-
-  describe("formatBox", () => {
-    it("wraps content in box", () => {
-      const box = formatBox("Test content")
-
-      expect(box).toContain("Test content")
-      expect(box).toContain("\u2500")
-    })
-
-    it("includes title when provided", () => {
-      const box = formatBox("Content", "My Title")
-
-      expect(box).toContain("My Title")
-    })
-  })
-
-  describe("formatHelpSuggestions", () => {
-    it("extracts suggestions from failed checks", () => {
-      const results: CheckResult[] = [
-        { name: "Test", status: "fail", message: "Error", details: ["Run: fix-command"] },
-        { name: "OK", status: "pass", message: "Good" },
-      ]
-
-      const suggestions = formatHelpSuggestions(results)
-
-      expect(suggestions).toContain("Run: fix-command")
-    })
-
-    it("returns empty array when no failures", () => {
-      const results: CheckResult[] = [
-        { name: "OK", status: "pass", message: "Good" },
-      ]
-
-      const suggestions = formatHelpSuggestions(results)
-
-      expect(suggestions.length).toBe(0)
-    })
-  })
-})

src/cli/doctor/formatter.ts

@@ -1,140 +0,0 @@
-import color from "picocolors"
-import type { CheckResult, DoctorSummary, CheckCategory, DoctorResult } from "./types"
-import { SYMBOLS, STATUS_COLORS, CATEGORY_NAMES } from "./constants"
-
-export function formatStatusSymbol(status: CheckResult["status"]): string {
-  switch (status) {
-    case "pass":
-      return SYMBOLS.check
-    case "fail":
-      return SYMBOLS.cross
-    case "warn":
-      return SYMBOLS.warn
-    case "skip":
-      return SYMBOLS.skip
-  }
-}
-
-export function formatCheckResult(result: CheckResult, verbose: boolean): string {
-  const symbol = formatStatusSymbol(result.status)
-  const colorFn = STATUS_COLORS[result.status]
-  const name = colorFn(result.name)
-  const message = color.dim(result.message)
-
-  let line = `  ${symbol} ${name}`
-  if (result.message) {
-    line += ` ${SYMBOLS.arrow} ${message}`
-  }
-
-  if (verbose && result.details && result.details.length > 0) {
-    const detailLines = result.details.map((d) => `      ${SYMBOLS.bullet} ${color.dim(d)}`).join("\n")
-    line += "\n" + detailLines
-  }
-
-  return line
-}
-
-export function formatCategoryHeader(category: CheckCategory): string {
-  const name = CATEGORY_NAMES[category] || category
-  return `\n${color.bold(color.white(name))}\n${color.dim("\u2500".repeat(40))}`
-}
-
-export function formatSummary(summary: DoctorSummary): string {
-  const lines: string[] = []
-
-  lines.push(color.bold(color.white("Summary")))
-  lines.push(color.dim("\u2500".repeat(40)))
-  lines.push("")
-
-  const passText = summary.passed > 0 ? color.green(`${summary.passed} passed`) : color.dim("0 passed")
-  const failText = summary.failed > 0 ? color.red(`${summary.failed} failed`) : color.dim("0 failed")
-  const warnText = summary.warnings > 0 ? color.yellow(`${summary.warnings} warnings`) : color.dim("0 warnings")
-  const skipText = summary.skipped > 0 ? color.dim(`${summary.skipped} skipped`) : ""
-
-  const parts = [passText, failText, warnText]
-  if (skipText) parts.push(skipText)
-
-  lines.push(`  ${parts.join(", ")}`)
-  lines.push(`  ${color.dim(`Total: ${summary.total} checks in ${summary.duration}ms`)}`)
-
-  return lines.join("\n")
-}
-
-export function formatHeader(): string {
-  return `\n${color.bgMagenta(color.white(" oMoMoMoMo... Doctor "))}\n`
-}
-
-export function formatFooter(summary: DoctorSummary): string {
-  if (summary.failed > 0) {
-    return `\n${SYMBOLS.cross} ${color.red("Issues detected. Please review the errors above.")}\n`
-  }
-  if (summary.warnings > 0) {
-    return `\n${SYMBOLS.warn} ${color.yellow("All systems operational with warnings.")}\n`
-  }
-  return `\n${SYMBOLS.check} ${color.green("All systems operational!")}\n`
-}
-
-export function formatProgress(current: number, total: number, name: string): string {
-  const progress = color.dim(`[${current}/${total}]`)
-  return `${progress} Checking ${name}...`
-}
-
-export function formatJsonOutput(result: DoctorResult): string {
-  return JSON.stringify(result, null, 2)
-}
-
-export function formatDetails(details: string[]): string {
-  return details.map((d) => `      ${SYMBOLS.bullet} ${color.dim(d)}`).join("\n")
-}
-
-function stripAnsi(str: string): string {
-  // eslint-disable-next-line no-control-regex
-  return str.replace(/\x1b\[[0-9;]*m/g, "")
-}
-
-export function formatBox(content: string, title?: string): string {
-  const lines = content.split("\n")
-  const maxWidth = Math.max(...lines.map((l) => stripAnsi(l).length), title?.length ?? 0) + 4
-  const border = color.dim("\u2500".repeat(maxWidth))
-
-  const output: string[] = []
-  output.push("")
-
-  if (title) {
-    output.push(
-      color.dim("\u250C\u2500") +
-        color.bold(` ${title} `) +
-        color.dim("\u2500".repeat(maxWidth - title.length - 4)) +
-        color.dim("\u2510")
-    )
-  } else {
-    output.push(color.dim("\u250C") + border + color.dim("\u2510"))
-  }
-
-  for (const line of lines) {
-    const stripped = stripAnsi(line)
-    const padding = maxWidth - stripped.length
-    output.push(color.dim("\u2502") + ` ${line}${" ".repeat(padding - 1)}` + color.dim("\u2502"))
-  }
-
-  output.push(color.dim("\u2514") + border + color.dim("\u2518"))
-  output.push("")
-
-  return output.join("\n")
-}
-
-export function formatHelpSuggestions(results: CheckResult[]): string[] {
-  const suggestions: string[] = []
-
-  for (const result of results) {
-    if (result.status === "fail" && result.details) {
-      for (const detail of result.details) {
-        if (detail.includes("Run:") || detail.includes("Install:") || detail.includes("Visit:")) {
-          suggestions.push(detail)
-        }
-      }
-    }
-  }
-
-  return suggestions
-}

src/cli/doctor/index.ts

@@ -1,11 +0,0 @@
-import type { DoctorOptions } from "./types"
-import { runDoctor } from "./runner"
-
-export async function doctor(options: DoctorOptions = {}): Promise<number> {
-  const result = await runDoctor(options)
-  return result.exitCode
-}
-
-export * from "./types"
-export { runDoctor } from "./runner"
-export { formatJsonOutput } from "./formatter"

src/cli/doctor/runner.test.ts

@@ -1,153 +0,0 @@
-import { describe, it, expect, spyOn, afterEach } from "bun:test"
-import {
-  runCheck,
-  calculateSummary,
-  determineExitCode,
-  filterChecksByCategory,
-  groupChecksByCategory,
-} from "./runner"
-import type { CheckResult, CheckDefinition, CheckCategory } from "./types"
-
-describe("runner", () => {
-  describe("runCheck", () => {
-    it("returns result from check function", async () => {
-      const check: CheckDefinition = {
-        id: "test",
-        name: "Test Check",
-        category: "installation",
-        check: async () => ({ name: "Test Check", status: "pass", message: "OK" }),
-      }
-
-      const result = await runCheck(check)
-
-      expect(result.name).toBe("Test Check")
-      expect(result.status).toBe("pass")
-    })
-
-    it("measures duration", async () => {
-      const check: CheckDefinition = {
-        id: "test",
-        name: "Test Check",
-        category: "installation",
-        check: async () => {
-          await new Promise((r) => setTimeout(r, 10))
-          return { name: "Test", status: "pass", message: "OK" }
-        },
-      }
-
-      const result = await runCheck(check)
-
-      expect(result.duration).toBeGreaterThanOrEqual(10)
-    })
-
-    it("returns fail on error", async () => {
-      const check: CheckDefinition = {
-        id: "test",
-        name: "Test Check",
-        category: "installation",
-        check: async () => {
-          throw new Error("Test error")
-        },
-      }
-
-      const result = await runCheck(check)
-
-      expect(result.status).toBe("fail")
-      expect(result.message).toContain("Test error")
-    })
-  })
-
-  describe("calculateSummary", () => {
-    it("counts each status correctly", () => {
-      const results: CheckResult[] = [
-        { name: "1", status: "pass", message: "" },
-        { name: "2", status: "pass", message: "" },
-        { name: "3", status: "fail", message: "" },
-        { name: "4", status: "warn", message: "" },
-        { name: "5", status: "skip", message: "" },
-      ]
-
-      const summary = calculateSummary(results, 100)
-
-      expect(summary.total).toBe(5)
-      expect(summary.passed).toBe(2)
-      expect(summary.failed).toBe(1)
-      expect(summary.warnings).toBe(1)
-      expect(summary.skipped).toBe(1)
-      expect(summary.duration).toBe(100)
-    })
-  })
-
-  describe("determineExitCode", () => {
-    it("returns 0 when all pass", () => {
-      const results: CheckResult[] = [
-        { name: "1", status: "pass", message: "" },
-        { name: "2", status: "pass", message: "" },
-      ]
-
-      expect(determineExitCode(results)).toBe(0)
-    })
-
-    it("returns 0 when only warnings", () => {
-      const results: CheckResult[] = [
-        { name: "1", status: "pass", message: "" },
-        { name: "2", status: "warn", message: "" },
-      ]
-
-      expect(determineExitCode(results)).toBe(0)
-    })
-
-    it("returns 1 when any failures", () => {
-      const results: CheckResult[] = [
-        { name: "1", status: "pass", message: "" },
-        { name: "2", status: "fail", message: "" },
-      ]
-
-      expect(determineExitCode(results)).toBe(1)
-    })
-  })
-
-  describe("filterChecksByCategory", () => {
-    const checks: CheckDefinition[] = [
-      { id: "1", name: "Install", category: "installation", check: async () => ({ name: "", status: "pass", message: "" }) },
-      { id: "2", name: "Config", category: "configuration", check: async () => ({ name: "", status: "pass", message: "" }) },
-      { id: "3", name: "Auth", category: "authentication", check: async () => ({ name: "", status: "pass", message: "" }) },
-    ]
-
-    it("returns all checks when no category", () => {
-      const filtered = filterChecksByCategory(checks)
-
-      expect(filtered.length).toBe(3)
-    })
-
-    it("filters to specific category", () => {
-      const filtered = filterChecksByCategory(checks, "installation")
-
-      expect(filtered.length).toBe(1)
-      expect(filtered[0].name).toBe("Install")
-    })
-  })
-
-  describe("groupChecksByCategory", () => {
-    const checks: CheckDefinition[] = [
-      { id: "1", name: "Install1", category: "installation", check: async () => ({ name: "", status: "pass", message: "" }) },
-      { id: "2", name: "Install2", category: "installation", check: async () => ({ name: "", status: "pass", message: "" }) },
-      { id: "3", name: "Config", category: "configuration", check: async () => ({ name: "", status: "pass", message: "" }) },
-    ]
-
-    it("groups checks by category", () => {
-      const groups = groupChecksByCategory(checks)
-
-      expect(groups.get("installation")?.length).toBe(2)
-      expect(groups.get("configuration")?.length).toBe(1)
-    })
-
-    it("maintains order within categories", () => {
-      const groups = groupChecksByCategory(checks)
-      const installChecks = groups.get("installation")!
-
-      expect(installChecks[0].name).toBe("Install1")
-      expect(installChecks[1].name).toBe("Install2")
-    })
-  })
-})

src/cli/doctor/runner.ts

@@ -1,132 +0,0 @@
-import type {
-  DoctorOptions,
-  DoctorResult,
-  CheckDefinition,
-  CheckResult,
-  DoctorSummary,
-  CheckCategory,
-} from "./types"
-import { getAllCheckDefinitions } from "./checks"
-import { EXIT_CODES, CATEGORY_NAMES } from "./constants"
-import {
-  formatHeader,
-  formatCategoryHeader,
-  formatCheckResult,
-  formatSummary,
-  formatFooter,
-  formatJsonOutput,
-} from "./formatter"
-
-export async function runCheck(check: CheckDefinition): Promise<CheckResult> {
-  const start = performance.now()
-  try {
-    const result = await check.check()
-    result.duration = Math.round(performance.now() - start)
-    return result
-  } catch (err) {
-    return {
-      name: check.name,
-      status: "fail",
-      message: err instanceof Error ? err.message : "Unknown error",
-      duration: Math.round(performance.now() - start),
-    }
-  }
-}
-
-export function calculateSummary(results: CheckResult[], duration: number): DoctorSummary {
-  return {
-    total: results.length,
-    passed: results.filter((r) => r.status === "pass").length,
-    failed: results.filter((r) => r.status === "fail").length,
-    warnings: results.filter((r) => r.status === "warn").length,
-    skipped: results.filter((r) => r.status === "skip").length,
-    duration: Math.round(duration),
-  }
-}
-
-export function determineExitCode(results: CheckResult[]): number {
-  const hasFailures = results.some((r) => r.status === "fail")
-  return hasFailures ? EXIT_CODES.FAILURE : EXIT_CODES.SUCCESS
-}
-
-export function filterChecksByCategory(
-  checks: CheckDefinition[],
-  category?: CheckCategory
-): CheckDefinition[] {
-  if (!category) return checks
-  return checks.filter((c) => c.category === category)
-}
-
-export function groupChecksByCategory(
-  checks: CheckDefinition[]
-): Map<CheckCategory, CheckDefinition[]> {
-  const groups = new Map<CheckCategory, CheckDefinition[]>()
-
-  for (const check of checks) {
-    const existing = groups.get(check.category) ?? []
-    existing.push(check)
-    groups.set(check.category, existing)
-  }
-
-  return groups
-}
-
-const CATEGORY_ORDER: CheckCategory[] = [
-  "installation",
-  "configuration",
-  "authentication",
-  "dependencies",
-  "tools",
-  "updates",
-]
-
-export async function runDoctor(options: DoctorOptions): Promise<DoctorResult> {
-  const start = performance.now()
-  const allChecks = getAllCheckDefinitions()
-  const filteredChecks = filterChecksByCategory(allChecks, options.category)
-  const groupedChecks = groupChecksByCategory(filteredChecks)
-
-  const results: CheckResult[] = []
-
-  if (!options.json) {
-    console.log(formatHeader())
-  }
-
-  for (const category of CATEGORY_ORDER) {
-    const checks = groupedChecks.get(category)
-    if (!checks || checks.length === 0) continue
-
-    if (!options.json) {
-      console.log(formatCategoryHeader(category))
-    }
-
-    for (const check of checks) {
-      const result = await runCheck(check)
-      results.push(result)
-
-      if (!options.json) {
-        console.log(formatCheckResult(result, options.verbose ?? false))
-      }
-    }
-  }
-
-  const duration = performance.now() - start
-  const summary = calculateSummary(results, duration)
-  const exitCode = determineExitCode(results)
-
-  const doctorResult: DoctorResult = {
-    results,
-    summary,
-    exitCode,
-  }
-
-  if (options.json) {
-    console.log(formatJsonOutput(doctorResult))
-  } else {
-    console.log("")
-    console.log(formatSummary(summary))
-    console.log(formatFooter(summary))
-  }
-
-  return doctorResult
-}

src/cli/doctor/types.ts

@@ -1,113 +0,0 @@
-export type CheckStatus = "pass" | "fail" | "warn" | "skip"
-
-export interface CheckResult {
-  name: string
-  status: CheckStatus
-  message: string
-  details?: string[]
-  duration?: number
-}
-
-export type CheckFunction = () => Promise<CheckResult>
-
-export type CheckCategory =
-  | "installation"
-  | "configuration"
-  | "authentication"
-  | "dependencies"
-  | "tools"
-  | "updates"
-
-export interface CheckDefinition {
-  id: string
-  name: string
-  category: CheckCategory
-  check: CheckFunction
-  critical?: boolean
-}
-
-export interface DoctorOptions {
-  verbose?: boolean
-  json?: boolean
-  category?: CheckCategory
-}
-
-export interface DoctorSummary {
-  total: number
-  passed: number
-  failed: number
-  warnings: number
-  skipped: number
-  duration: number
-}
-
-export interface DoctorResult {
-  results: CheckResult[]
-  summary: DoctorSummary
-  exitCode: number
-}
-
-export interface OpenCodeInfo {
-  installed: boolean
-  version: string | null
-  path: string | null
-  binary: "opencode" | "opencode-desktop" | null
-}
-
-export interface PluginInfo {
-  registered: boolean
-  configPath: string | null
-  entry: string | null
-  isPinned: boolean
-  pinnedVersion: string | null
-}
-
-export interface ConfigInfo {
-  exists: boolean
-  path: string | null
-  format: "json" | "jsonc" | null
-  valid: boolean
-  errors: string[]
-}
-
-export type AuthProviderId = "anthropic" | "openai" | "google"
-
-export interface AuthProviderInfo {
-  id: AuthProviderId
-  name: string
-  pluginInstalled: boolean
-  configured: boolean
-  error?: string
-}
-
-export interface DependencyInfo {
-  name: string
-  required: boolean
-  installed: boolean
-  version: string | null
-  path: string | null
-  installHint?: string
-}
-
-export interface LspServerInfo {
-  id: string
-  installed: boolean
-  extensions: string[]
-  source: "builtin" | "config" | "plugin"
-}
-
-export interface McpServerInfo {
-  id: string
-  type: "builtin" | "user"
-  enabled: boolean
-  valid: boolean
-  error?: string
-}
-
-export interface VersionCheckInfo {
-  currentVersion: string | null
-  latestVersion: string | null
-  isUpToDate: boolean
-  isLocalDev: boolean
-  isPinned: boolean
-}

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

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

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

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

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

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

src/cli/index.ts

@@ -1,144 +0,0 @@
-#!/usr/bin/env bun
-import { Command } from "commander"
-import { install } from "./install"
-import { run } from "./run"
-import { getLocalVersion } from "./get-local-version"
-import { doctor } from "./doctor"
-import type { InstallArgs } from "./types"
-import type { RunOptions } from "./run"
-import type { GetLocalVersionOptions } from "./get-local-version/types"
-import type { DoctorOptions } from "./doctor"
-
-const packageJson = await import("../../package.json")
-const VERSION = packageJson.version
-
-const program = new Command()
-
-program
-  .name("oh-my-opencode")
-  .description("The ultimate OpenCode plugin - multi-model orchestration, LSP tools, and more")
-  .version(VERSION, "-v, --version", "Show version number")
-
-program
-  .command("install")
-  .description("Install and configure oh-my-opencode with interactive setup")
-  .option("--no-tui", "Run in non-interactive mode (requires all options)")
-  .option("--claude <value>", "Claude subscription: no, yes, max20")
-  .option("--chatgpt <value>", "ChatGPT subscription: no, yes")
-  .option("--gemini <value>", "Gemini integration: no, yes")
-  .option("--skip-auth", "Skip authentication setup hints")
-  .addHelpText("after", `
-Examples:
-  $ bunx oh-my-opencode install
-  $ bunx oh-my-opencode install --no-tui --claude=max20 --chatgpt=yes --gemini=yes
-  $ bunx oh-my-opencode install --no-tui --claude=no --chatgpt=no --gemini=no
-
-Model Providers:
-  Claude      Required for Sisyphus (main orchestrator) and Librarian agents
-  ChatGPT     Powers the Oracle agent for debugging and architecture
-  Gemini      Powers frontend, documentation, and multimodal agents
-`)
-  .action(async (options) => {
-    const args: InstallArgs = {
-      tui: options.tui !== false,
-      claude: options.claude,
-      chatgpt: options.chatgpt,
-      gemini: options.gemini,
-      skipAuth: options.skipAuth ?? false,
-    }
-    const exitCode = await install(args)
-    process.exit(exitCode)
-  })
-
-program
-  .command("run <message>")
-  .description("Run opencode with todo/background task completion enforcement")
-  .option("-a, --agent <name>", "Agent to use (default: Sisyphus)")
-  .option("-d, --directory <path>", "Working directory")
-  .option("-t, --timeout <ms>", "Timeout in milliseconds (default: 30 minutes)", parseInt)
-  .addHelpText("after", `
-Examples:
-  $ bunx oh-my-opencode run "Fix the bug in index.ts"
-  $ bunx oh-my-opencode run --agent Sisyphus "Implement feature X"
-  $ bunx oh-my-opencode run --timeout 3600000 "Large refactoring task"
-
-Unlike 'opencode run', this command waits until:
-  - All todos are completed or cancelled
-  - All child sessions (background tasks) are idle
-`)
-  .action(async (message: string, options) => {
-    const runOptions: RunOptions = {
-      message,
-      agent: options.agent,
-      directory: options.directory,
-      timeout: options.timeout,
-    }
-    const exitCode = await run(runOptions)
-    process.exit(exitCode)
-  })
-
-program
-  .command("get-local-version")
-  .description("Show current installed version and check for updates")
-  .option("-d, --directory <path>", "Working directory to check config from")
-  .option("--json", "Output in JSON format for scripting")
-  .addHelpText("after", `
-Examples:
-  $ bunx oh-my-opencode get-local-version
-  $ bunx oh-my-opencode get-local-version --json
-  $ bunx oh-my-opencode get-local-version --directory /path/to/project
-
-This command shows:
-  - Current installed version
-  - Latest available version on npm
-  - Whether you're up to date
-  - Special modes (local dev, pinned version)
-`)
-  .action(async (options) => {
-    const versionOptions: GetLocalVersionOptions = {
-      directory: options.directory,
-      json: options.json ?? false,
-    }
-    const exitCode = await getLocalVersion(versionOptions)
-    process.exit(exitCode)
-  })
-
-program
-  .command("doctor")
-  .description("Check oh-my-opencode installation health and diagnose issues")
-  .option("--verbose", "Show detailed diagnostic information")
-  .option("--json", "Output results in JSON format")
-  .option("--category <category>", "Run only specific category")
-  .addHelpText("after", `
-Examples:
-  $ bunx oh-my-opencode doctor
-  $ bunx oh-my-opencode doctor --verbose
-  $ bunx oh-my-opencode doctor --json
-  $ bunx oh-my-opencode doctor --category authentication
-
-Categories:
-  installation     Check OpenCode and plugin installation
-  configuration    Validate configuration files
-  authentication   Check auth provider status
-  dependencies     Check external dependencies
-  tools            Check LSP and MCP servers
-  updates          Check for version updates
-`)
-  .action(async (options) => {
-    const doctorOptions: DoctorOptions = {
-      verbose: options.verbose ?? false,
-      json: options.json ?? false,
-      category: options.category,
-    }
-    const exitCode = await doctor(doctorOptions)
-    process.exit(exitCode)
-  })
-
-program
-  .command("version")
-  .description("Show version information")
-  .action(() => {
-    console.log(`oh-my-opencode v${VERSION}`)
-  })
-
-program.parse()

src/cli/install.ts

@@ -1,456 +0,0 @@
-import * as p from "@clack/prompts"
-import color from "picocolors"
-import type { InstallArgs, InstallConfig, ClaudeSubscription, BooleanArg, DetectedConfig } from "./types"
-import {
-  addPluginToOpenCodeConfig,
-  writeOmoConfig,
-  isOpenCodeInstalled,
-  getOpenCodeVersion,
-  addAuthPlugins,
-  setupChatGPTHotfix,
-  runBunInstall,
-  addProviderConfig,
-  detectCurrentConfig,
-} from "./config-manager"
-
-const SYMBOLS = {
-  check: color.green("✓"),
-  cross: color.red("✗"),
-  arrow: color.cyan("→"),
-  bullet: color.dim("•"),
-  info: color.blue("ℹ"),
-  warn: color.yellow("⚠"),
-  star: color.yellow("★"),
-}
-
-function formatProvider(name: string, enabled: boolean, detail?: string): string {
-  const status = enabled ? SYMBOLS.check : color.dim("○")
-  const label = enabled ? color.white(name) : color.dim(name)
-  const suffix = detail ? color.dim(` (${detail})`) : ""
-  return `  ${status} ${label}${suffix}`
-}
-
-function formatConfigSummary(config: InstallConfig): string {
-  const lines: string[] = []
-
-  lines.push(color.bold(color.white("Configuration Summary")))
-  lines.push("")
-
-  const claudeDetail = config.hasClaude ? (config.isMax20 ? "max20" : "standard") : undefined
-  lines.push(formatProvider("Claude", config.hasClaude, claudeDetail))
-  lines.push(formatProvider("ChatGPT", config.hasChatGPT))
-  lines.push(formatProvider("Gemini", config.hasGemini))
-
-  lines.push("")
-  lines.push(color.dim("─".repeat(40)))
-  lines.push("")
-
-  lines.push(color.bold(color.white("Agent Configuration")))
-  lines.push("")
-
-  const sisyphusModel = config.hasClaude ? "claude-opus-4-5" : "big-pickle"
-  const oracleModel = config.hasChatGPT ? "gpt-5.2" : (config.hasClaude ? "claude-opus-4-5" : "big-pickle")
-  const librarianModel = config.hasClaude && config.isMax20 ? "claude-sonnet-4-5" : "big-pickle"
-  const frontendModel = config.hasGemini ? "gemini-3-pro-high" : (config.hasClaude ? "claude-opus-4-5" : "big-pickle")
-
-  lines.push(`  ${SYMBOLS.bullet} Sisyphus     ${SYMBOLS.arrow} ${color.cyan(sisyphusModel)}`)
-  lines.push(`  ${SYMBOLS.bullet} Oracle       ${SYMBOLS.arrow} ${color.cyan(oracleModel)}`)
-  lines.push(`  ${SYMBOLS.bullet} Librarian    ${SYMBOLS.arrow} ${color.cyan(librarianModel)}`)
-  lines.push(`  ${SYMBOLS.bullet} Frontend     ${SYMBOLS.arrow} ${color.cyan(frontendModel)}`)
-
-  return lines.join("\n")
-}
-
-function printHeader(isUpdate: boolean): void {
-  const mode = isUpdate ? "Update" : "Install"
-  console.log()
-  console.log(color.bgMagenta(color.white(` oMoMoMoMo... ${mode} `)))
-  console.log()
-}
-
-function printStep(step: number, total: number, message: string): void {
-  const progress = color.dim(`[${step}/${total}]`)
-  console.log(`${progress} ${message}`)
-}
-
-function printSuccess(message: string): void {
-  console.log(`${SYMBOLS.check} ${message}`)
-}
-
-function printError(message: string): void {
-  console.log(`${SYMBOLS.cross} ${color.red(message)}`)
-}
-
-function printInfo(message: string): void {
-  console.log(`${SYMBOLS.info} ${message}`)
-}
-
-function printWarning(message: string): void {
-  console.log(`${SYMBOLS.warn} ${color.yellow(message)}`)
-}
-
-function printBox(content: string, title?: string): void {
-  const lines = content.split("\n")
-  const maxWidth = Math.max(...lines.map(l => l.replace(/\x1b\[[0-9;]*m/g, "").length), title?.length ?? 0) + 4
-  const border = color.dim("─".repeat(maxWidth))
-
-  console.log()
-  if (title) {
-    console.log(color.dim("┌─") + color.bold(` ${title} `) + color.dim("─".repeat(maxWidth - title.length - 4)) + color.dim("┐"))
-  } else {
-    console.log(color.dim("┌") + border + color.dim("┐"))
-  }
-
-  for (const line of lines) {
-    const stripped = line.replace(/\x1b\[[0-9;]*m/g, "")
-    const padding = maxWidth - stripped.length
-    console.log(color.dim("│") + ` ${line}${" ".repeat(padding - 1)}` + color.dim("│"))
-  }
-
-  console.log(color.dim("└") + border + color.dim("┘"))
-  console.log()
-}
-
-function validateNonTuiArgs(args: InstallArgs): { valid: boolean; errors: string[] } {
-  const errors: string[] = []
-
-  if (args.claude === undefined) {
-    errors.push("--claude is required (values: no, yes, max20)")
-  } else if (!["no", "yes", "max20"].includes(args.claude)) {
-    errors.push(`Invalid --claude value: ${args.claude} (expected: no, yes, max20)`)
-  }
-
-  if (args.chatgpt === undefined) {
-    errors.push("--chatgpt is required (values: no, yes)")
-  } else if (!["no", "yes"].includes(args.chatgpt)) {
-    errors.push(`Invalid --chatgpt value: ${args.chatgpt} (expected: no, yes)`)
-  }
-
-  if (args.gemini === undefined) {
-    errors.push("--gemini is required (values: no, yes)")
-  } else if (!["no", "yes"].includes(args.gemini)) {
-    errors.push(`Invalid --gemini value: ${args.gemini} (expected: no, yes)`)
-  }
-
-  return { valid: errors.length === 0, errors }
-}
-
-function argsToConfig(args: InstallArgs): InstallConfig {
-  return {
-    hasClaude: args.claude !== "no",
-    isMax20: args.claude === "max20",
-    hasChatGPT: args.chatgpt === "yes",
-    hasGemini: args.gemini === "yes",
-  }
-}
-
-function detectedToInitialValues(detected: DetectedConfig): { claude: ClaudeSubscription; chatgpt: BooleanArg; gemini: BooleanArg } {
-  let claude: ClaudeSubscription = "no"
-  if (detected.hasClaude) {
-    claude = detected.isMax20 ? "max20" : "yes"
-  }
-
-  return {
-    claude,
-    chatgpt: detected.hasChatGPT ? "yes" : "no",
-    gemini: detected.hasGemini ? "yes" : "no",
-  }
-}
-
-async function runTuiMode(detected: DetectedConfig): Promise<InstallConfig | null> {
-  const initial = detectedToInitialValues(detected)
-
-  const claude = await p.select({
-    message: "Do you have a Claude Pro/Max subscription?",
-    options: [
-      { value: "no" as const, label: "No", hint: "Will use opencode/big-pickle as fallback" },
-      { value: "yes" as const, label: "Yes (standard)", hint: "Claude Opus 4.5 for orchestration" },
-      { value: "max20" as const, label: "Yes (max20 mode)", hint: "Full power with Claude Sonnet 4.5 for Librarian" },
-    ],
-    initialValue: initial.claude,
-  })
-
-  if (p.isCancel(claude)) {
-    p.cancel("Installation cancelled.")
-    return null
-  }
-
-  const chatgpt = await p.select({
-    message: "Do you have a ChatGPT Plus/Pro subscription?",
-    options: [
-      { value: "no" as const, label: "No", hint: "Oracle will use fallback model" },
-      { value: "yes" as const, label: "Yes", hint: "GPT-5.2 for debugging and architecture" },
-    ],
-    initialValue: initial.chatgpt,
-  })
-
-  if (p.isCancel(chatgpt)) {
-    p.cancel("Installation cancelled.")
-    return null
-  }
-
-  const gemini = await p.select({
-    message: "Will you integrate Google Gemini?",
-    options: [
-      { value: "no" as const, label: "No", hint: "Frontend/docs agents will use fallback" },
-      { value: "yes" as const, label: "Yes", hint: "Beautiful UI generation with Gemini 3 Pro" },
-    ],
-    initialValue: initial.gemini,
-  })
-
-  if (p.isCancel(gemini)) {
-    p.cancel("Installation cancelled.")
-    return null
-  }
-
-  return {
-    hasClaude: claude !== "no",
-    isMax20: claude === "max20",
-    hasChatGPT: chatgpt === "yes",
-    hasGemini: gemini === "yes",
-  }
-}
-
-async function runNonTuiInstall(args: InstallArgs): Promise<number> {
-  const validation = validateNonTuiArgs(args)
-  if (!validation.valid) {
-    printHeader(false)
-    printError("Validation failed:")
-    for (const err of validation.errors) {
-      console.log(`  ${SYMBOLS.bullet} ${err}`)
-    }
-    console.log()
-    printInfo("Usage: bunx oh-my-opencode install --no-tui --claude=<no|yes|max20> --chatgpt=<no|yes> --gemini=<no|yes>")
-    console.log()
-    return 1
-  }
-
-  const detected = detectCurrentConfig()
-  const isUpdate = detected.isInstalled
-
-  printHeader(isUpdate)
-
-  const totalSteps = 6
-  let step = 1
-
-  printStep(step++, totalSteps, "Checking OpenCode installation...")
-  const installed = await isOpenCodeInstalled()
-  if (!installed) {
-    printError("OpenCode is not installed on this system.")
-    printInfo("Visit https://opencode.ai/docs for installation instructions")
-    return 1
-  }
-
-  const version = await getOpenCodeVersion()
-  printSuccess(`OpenCode ${version ?? ""} detected`)
-
-  if (isUpdate) {
-    const initial = detectedToInitialValues(detected)
-    printInfo(`Current config: Claude=${initial.claude}, ChatGPT=${initial.chatgpt}, Gemini=${initial.gemini}`)
-  }
-
-  const config = argsToConfig(args)
-
-  printStep(step++, totalSteps, "Adding oh-my-opencode plugin...")
-  const pluginResult = addPluginToOpenCodeConfig()
-  if (!pluginResult.success) {
-    printError(`Failed: ${pluginResult.error}`)
-    return 1
-  }
-  printSuccess(`Plugin ${isUpdate ? "verified" : "added"} ${SYMBOLS.arrow} ${color.dim(pluginResult.configPath)}`)
-
-  if (config.hasGemini || config.hasChatGPT) {
-    printStep(step++, totalSteps, "Adding auth plugins...")
-    const authResult = await addAuthPlugins(config)
-    if (!authResult.success) {
-      printError(`Failed: ${authResult.error}`)
-      return 1
-    }
-    printSuccess(`Auth plugins configured ${SYMBOLS.arrow} ${color.dim(authResult.configPath)}`)
-
-    printStep(step++, totalSteps, "Adding provider configurations...")
-    const providerResult = addProviderConfig(config)
-    if (!providerResult.success) {
-      printError(`Failed: ${providerResult.error}`)
-      return 1
-    }
-    printSuccess(`Providers configured ${SYMBOLS.arrow} ${color.dim(providerResult.configPath)}`)
-  } else {
-    step += 2
-  }
-
-  if (config.hasChatGPT) {
-    printStep(step++, totalSteps, "Setting up ChatGPT hotfix...")
-    const hotfixResult = setupChatGPTHotfix()
-    if (!hotfixResult.success) {
-      printError(`Failed: ${hotfixResult.error}`)
-      return 1
-    }
-    printSuccess(`Hotfix configured ${SYMBOLS.arrow} ${color.dim(hotfixResult.configPath)}`)
-
-    printInfo("Installing dependencies with bun...")
-    const bunSuccess = await runBunInstall()
-    if (bunSuccess) {
-      printSuccess("Dependencies installed")
-    } else {
-      printWarning("bun install failed - run manually: cd ~/.config/opencode && bun i")
-    }
-  } else {
-    step++
-  }
-
-  printStep(step++, totalSteps, "Writing oh-my-opencode configuration...")
-  const omoResult = writeOmoConfig(config)
-  if (!omoResult.success) {
-    printError(`Failed: ${omoResult.error}`)
-    return 1
-  }
-  printSuccess(`Config written ${SYMBOLS.arrow} ${color.dim(omoResult.configPath)}`)
-
-  printBox(formatConfigSummary(config), isUpdate ? "Updated Configuration" : "Installation Complete")
-
-  if (!config.hasClaude && !config.hasChatGPT && !config.hasGemini) {
-    printWarning("No model providers configured. Using opencode/big-pickle as fallback.")
-  }
-
-  if ((config.hasClaude || config.hasChatGPT || config.hasGemini) && !args.skipAuth) {
-    console.log(color.bold("Next Steps - Authenticate your providers:"))
-    console.log()
-    if (config.hasClaude) {
-      console.log(`  ${SYMBOLS.arrow} ${color.dim("opencode auth login")} ${color.gray("(select Anthropic → Claude Pro/Max)")}`)
-    }
-    if (config.hasChatGPT) {
-      console.log(`  ${SYMBOLS.arrow} ${color.dim("opencode auth login")} ${color.gray("(select OpenAI → ChatGPT Plus/Pro)")}`)
-    }
-    if (config.hasGemini) {
-      console.log(`  ${SYMBOLS.arrow} ${color.dim("opencode auth login")} ${color.gray("(select Google → OAuth with Antigravity)")}`)
-    }
-    console.log()
-  }
-
-  console.log(`${SYMBOLS.star} ${color.bold(color.green(isUpdate ? "Configuration updated!" : "Installation complete!"))}`)
-  console.log(`  Run ${color.cyan("opencode")} to start!`)
-  console.log()
-  console.log(color.dim("oMoMoMoMo... Enjoy!"))
-  console.log()
-
-  return 0
-}
-
-export async function install(args: InstallArgs): Promise<number> {
-  if (!args.tui) {
-    return runNonTuiInstall(args)
-  }
-
-  const detected = detectCurrentConfig()
-  const isUpdate = detected.isInstalled
-
-  p.intro(color.bgMagenta(color.white(isUpdate ? " oMoMoMoMo... Update " : " oMoMoMoMo... ")))
-
-  if (isUpdate) {
-    const initial = detectedToInitialValues(detected)
-    p.log.info(`Existing configuration detected: Claude=${initial.claude}, ChatGPT=${initial.chatgpt}, Gemini=${initial.gemini}`)
-  }
-
-  const s = p.spinner()
-  s.start("Checking OpenCode installation")
-
-  const installed = await isOpenCodeInstalled()
-  if (!installed) {
-    s.stop("OpenCode is not installed")
-    p.log.error("OpenCode is not installed on this system.")
-    p.note("Visit https://opencode.ai/docs for installation instructions", "Installation Guide")
-    p.outro(color.red("Please install OpenCode first."))
-    return 1
-  }
-
-  const version = await getOpenCodeVersion()
-  s.stop(`OpenCode ${version ?? "installed"} ${color.green("✓")}`)
-
-  const config = await runTuiMode(detected)
-  if (!config) return 1
-
-  s.start("Adding oh-my-opencode to OpenCode config")
-  const pluginResult = addPluginToOpenCodeConfig()
-  if (!pluginResult.success) {
-    s.stop(`Failed to add plugin: ${pluginResult.error}`)
-    p.outro(color.red("Installation failed."))
-    return 1
-  }
-  s.stop(`Plugin added to ${color.cyan(pluginResult.configPath)}`)
-
-  if (config.hasGemini || config.hasChatGPT) {
-    s.start("Adding auth plugins (fetching latest versions)")
-    const authResult = await addAuthPlugins(config)
-    if (!authResult.success) {
-      s.stop(`Failed to add auth plugins: ${authResult.error}`)
-      p.outro(color.red("Installation failed."))
-      return 1
-    }
-    s.stop(`Auth plugins added to ${color.cyan(authResult.configPath)}`)
-
-    s.start("Adding provider configurations")
-    const providerResult = addProviderConfig(config)
-    if (!providerResult.success) {
-      s.stop(`Failed to add provider config: ${providerResult.error}`)
-      p.outro(color.red("Installation failed."))
-      return 1
-    }
-    s.stop(`Provider config added to ${color.cyan(providerResult.configPath)}`)
-  }
-
-  if (config.hasChatGPT) {
-    s.start("Setting up ChatGPT hotfix")
-    const hotfixResult = setupChatGPTHotfix()
-    if (!hotfixResult.success) {
-      s.stop(`Failed to setup hotfix: ${hotfixResult.error}`)
-      p.outro(color.red("Installation failed."))
-      return 1
-    }
-    s.stop(`Hotfix configured in ${color.cyan(hotfixResult.configPath)}`)
-
-    s.start("Installing dependencies with bun")
-    const bunSuccess = await runBunInstall()
-    if (bunSuccess) {
-      s.stop("Dependencies installed")
-    } else {
-      s.stop(color.yellow("bun install failed - run manually: cd ~/.config/opencode && bun i"))
-    }
-  }
-
-  s.start("Writing oh-my-opencode configuration")
-  const omoResult = writeOmoConfig(config)
-  if (!omoResult.success) {
-    s.stop(`Failed to write config: ${omoResult.error}`)
-    p.outro(color.red("Installation failed."))
-    return 1
-  }
-  s.stop(`Config written to ${color.cyan(omoResult.configPath)}`)
-
-  if (!config.hasClaude && !config.hasChatGPT && !config.hasGemini) {
-    p.log.warn("No model providers configured. Using opencode/big-pickle as fallback.")
-  }
-
-  p.note(formatConfigSummary(config), isUpdate ? "Updated Configuration" : "Installation Complete")
-
-  if ((config.hasClaude || config.hasChatGPT || config.hasGemini) && !args.skipAuth) {
-    const steps: string[] = []
-    if (config.hasClaude) {
-      steps.push(`${color.dim("opencode auth login")} ${color.gray("(select Anthropic → Claude Pro/Max)")}`)
-    }
-    if (config.hasChatGPT) {
-      steps.push(`${color.dim("opencode auth login")} ${color.gray("(select OpenAI → ChatGPT Plus/Pro)")}`)
-    }
-    if (config.hasGemini) {
-      steps.push(`${color.dim("opencode auth login")} ${color.gray("(select Google → OAuth with Antigravity)")}`)
-    }
-    p.note(steps.join("\n"), "Next Steps - Authenticate your providers")
-  }
-
-  p.log.success(color.bold(isUpdate ? "Configuration updated!" : "Installation complete!"))
-  p.log.message(`Run ${color.cyan("opencode")} to start!`)
-
-  p.outro(color.green("oMoMoMoMo... Enjoy!"))
-
-  return 0
-}

src/cli/run/completion.test.ts

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

src/cli/run/completion.ts

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

src/cli/run/events.test.ts

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