fix: clean up stale lock files and validate installation

- Remove ~/.claude/.locks before each retry attempt to prevent "another process is currently installing" errors after timeout - Validate claude binary is in PATH before reporting success - Add missing PATH setup to base-action/action.yml 🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-Authored-By: Claude <noreply@anthropic.com>
2025-12-15 08:55:53 -08:00
106 changed files with 3096 additions and 6098 deletions
--- a/.claude/commands/label-issue.md
+++ b/.claude/commands/label-issue.md
@ -1,5 +1,5 @@
 ---
-allowed-tools: Bash(./scripts/gh.sh:*),Bash(./scripts/edit-issue-labels.sh:*)
+allowed-tools: Bash(gh label list:*),Bash(gh issue view:*),Bash(gh issue edit:*),Bash(gh search:*)
 description: Apply labels to GitHub issues
 ---

@ -14,18 +14,17 @@ Issue Information:

 TASK OVERVIEW:

-1. First, fetch the list of labels available in this repository by running: `./scripts/gh.sh label list`. Run exactly this command with nothing else.
+1. First, fetch the list of labels available in this repository by running: `gh label list`. Run exactly this command with nothing else.

-2. Next, use gh wrapper commands to get context about the issue:
+2. Next, use gh commands to get context about the issue:

-   - Use `./scripts/gh.sh issue view ${{ github.event.issue.number }}` to retrieve the current issue's details
-   - Use `./scripts/gh.sh search issues` to find similar issues that might provide context for proper categorization
-   - `./scripts/gh.sh` is a wrapper for `gh` CLI. Example commands:
-     - `./scripts/gh.sh label list` — fetch all available labels
-     - `./scripts/gh.sh issue view 123` — view issue details
-     - `./scripts/gh.sh issue view 123 --comments` — view with comments
-     - `./scripts/gh.sh search issues "query" --limit 10` — search for issues
-   - `./scripts/edit-issue-labels.sh` — apply labels to the issue
+   - Use `gh issue view ${{ github.event.issue.number }}` to retrieve the current issue's details
+   - Use `gh search issues` to find similar issues that might provide context for proper categorization
+   - You have access to these Bash commands:
+     - Bash(gh label list:\*) - to get available labels
+     - Bash(gh issue view:\*) - to view issue details
+     - Bash(gh issue edit:\*) - to apply labels to the issue
+     - Bash(gh search:\*) - to search for similar issues

 3. Analyze the issue content, considering:

@ -40,12 +39,12 @@ TASK OVERVIEW:

   - Choose labels that accurately reflect the issue's nature
   - Be specific but comprehensive
-   - IMPORTANT: Add a priority label (P1, P2, or P3) based on the label descriptions from ./scripts/gh.sh label list
+   - IMPORTANT: Add a priority label (P1, P2, or P3) based on the label descriptions from gh label list
   - Consider platform labels (android, ios) if applicable
-   - If you find similar issues using ./scripts/gh.sh search, consider using a "duplicate" label if appropriate. Only do so if the issue is a duplicate of another OPEN issue.
+   - If you find similar issues using gh search, consider using a "duplicate" label if appropriate. Only do so if the issue is a duplicate of another OPEN issue.

 5. Apply the selected labels:
-   - Use `./scripts/edit-issue-labels.sh --add-label LABEL1 --add-label LABEL2` to apply your selected labels (issue number is read from the workflow event)
+   - Use `gh issue edit` to apply your selected labels
   - DO NOT post any comments explaining your decision
   - DO NOT communicate directly with users
   - If no labels are clearly applicable, do not apply any labels
@ -55,7 +54,7 @@ IMPORTANT GUIDELINES:
 - Be thorough in your analysis
 - Only select labels from the provided list above
 - DO NOT post any comments to the issue
- Your ONLY action should be to apply labels using ./scripts/edit-issue-labels.sh
+- Your ONLY action should be to apply labels using gh issue edit
 - It's okay to not add any labels if none are clearly applicable

 ---
--- a/.github/workflows/bump-claude-code-version.yml
+++ b/.github/workflows/bump-claude-code-version.yml
@ -0,0 +1,132 @@
+name: Bump Claude Code Version
+
+on:
+  repository_dispatch:
+    types: [bump_claude_code_version]
+  workflow_dispatch:
+    inputs:
+      version:
+        description: "Claude Code version to bump to"
+        required: true
+        type: string
+
+permissions:
+  contents: write
+
+jobs:
+  bump-version:
+    name: Bump Claude Code Version
+    runs-on: ubuntu-latest
+    environment: release
+    timeout-minutes: 5
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 #v4
+        with:
+          token: ${{ secrets.RELEASE_PAT }}
+          fetch-depth: 0
+
+      - name: Get version from event payload
+        id: get_version
+        run: |
+          # Get version from either repository_dispatch or workflow_dispatch
+          if [ "${{ github.event_name }}" = "repository_dispatch" ]; then
+            NEW_VERSION="${CLIENT_PAYLOAD_VERSION}"
+          else
+            NEW_VERSION="${INPUT_VERSION}"
+          fi
+
+          # Sanitize the version to avoid issues enabled by problematic characters
+          NEW_VERSION=$(echo "$NEW_VERSION" | tr -d '`;$(){}[]|&<>' | tr -s ' ' '-')
+
+          if [ -z "$NEW_VERSION" ]; then
+            echo "Error: version not provided"
+            exit 1
+          fi
+          echo "NEW_VERSION=$NEW_VERSION" >> $GITHUB_ENV
+          echo "new_version=$NEW_VERSION" >> $GITHUB_OUTPUT
+        env:
+          INPUT_VERSION: ${{ inputs.version }}
+          CLIENT_PAYLOAD_VERSION: ${{ github.event.client_payload.version }}
+
+      - name: Create branch and update base-action/action.yml
+        run: |
+          # Variables
+          TIMESTAMP=$(date +'%Y%m%d-%H%M%S')
+          BRANCH_NAME="bump-claude-code-${{ env.NEW_VERSION }}-$TIMESTAMP"
+
+          echo "BRANCH_NAME=$BRANCH_NAME" >> $GITHUB_ENV
+
+          # Get the default branch
+          DEFAULT_BRANCH=$(gh api repos/${GITHUB_REPOSITORY} --jq '.default_branch')
+          echo "DEFAULT_BRANCH=$DEFAULT_BRANCH" >> $GITHUB_ENV
+
+          # Get the latest commit SHA from the default branch
+          BASE_SHA=$(gh api repos/${GITHUB_REPOSITORY}/git/refs/heads/$DEFAULT_BRANCH --jq '.object.sha')
+
+          # Create a new branch
+          gh api \
+            --method POST \
+            repos/${GITHUB_REPOSITORY}/git/refs \
+            -f ref="refs/heads/$BRANCH_NAME" \
+            -f sha="$BASE_SHA"
+
+          # Get the current base-action/action.yml content
+          ACTION_CONTENT=$(gh api repos/${GITHUB_REPOSITORY}/contents/base-action/action.yml?ref=$DEFAULT_BRANCH --jq '.content' | base64 -d)
+
+          # Update the Claude Code version in the npm install command
+          UPDATED_CONTENT=$(echo "$ACTION_CONTENT" | sed -E "s/(npm install -g @anthropic-ai\/claude-code@)[0-9]+\.[0-9]+\.[0-9]+/\1${{ env.NEW_VERSION }}/")
+
+          # Verify the change would be made
+          if ! echo "$UPDATED_CONTENT" | grep -q "@anthropic-ai/claude-code@${{ env.NEW_VERSION }}"; then
+            echo "Error: Failed to update Claude Code version in content"
+            exit 1
+          fi
+
+          # Get the current SHA of base-action/action.yml for the update API call
+          FILE_SHA=$(gh api repos/${GITHUB_REPOSITORY}/contents/base-action/action.yml?ref=$DEFAULT_BRANCH --jq '.sha')
+
+          # Create the updated base-action/action.yml content in base64
+          echo "$UPDATED_CONTENT" | base64 > action.yml.b64
+
+          # Commit the updated base-action/action.yml via GitHub API
+          gh api \
+            --method PUT \
+            repos/${GITHUB_REPOSITORY}/contents/base-action/action.yml \
+            -f message="chore: bump Claude Code version to ${{ env.NEW_VERSION }}" \
+            -F content=@action.yml.b64 \
+            -f sha="$FILE_SHA" \
+            -f branch="$BRANCH_NAME"
+
+          echo "Successfully created branch and updated Claude Code version to ${{ env.NEW_VERSION }}"
+        env:
+          GH_TOKEN: ${{ secrets.RELEASE_PAT }}
+          GITHUB_REPOSITORY: ${{ github.repository }}
+
+      - name: Create Pull Request
+        run: |
+          # Determine trigger type for PR body
+          if [ "${{ github.event_name }}" = "repository_dispatch" ]; then
+            TRIGGER_INFO="repository dispatch event"
+          else
+            TRIGGER_INFO="manual workflow dispatch by @${GITHUB_ACTOR}"
+          fi
+
+          # Create PR body with proper YAML escape
+          printf -v PR_BODY "## Bump Claude Code to ${{ env.NEW_VERSION }}\n\nThis PR updates the Claude Code version in base-action/action.yml to ${{ env.NEW_VERSION }}.\n\n### Changes\n- Updated Claude Code version from current to \`${{ env.NEW_VERSION }}\`\n\n### Triggered by\n- $TRIGGER_INFO\n\n🤖 This PR was automatically created by the bump-claude-code-version workflow."
+
+          echo "Creating PR with gh pr create command"
+          PR_URL=$(gh pr create \
+            --repo "${GITHUB_REPOSITORY}" \
+            --title "chore: bump Claude Code version to ${{ env.NEW_VERSION }}" \
+            --body "$PR_BODY" \
+            --base "${DEFAULT_BRANCH}" \
+            --head "${BRANCH_NAME}")
+
+          echo "PR created successfully: $PR_URL"
+        env:
+          GH_TOKEN: ${{ secrets.RELEASE_PAT }}
+          GITHUB_REPOSITORY: ${{ github.repository }}
+          GITHUB_ACTOR: ${{ github.actor }}
+          DEFAULT_BRANCH: ${{ env.DEFAULT_BRANCH }}
+          BRANCH_NAME: ${{ env.BRANCH_NAME }}
--- a/.github/workflows/ci-all.yml
+++ b/.github/workflows/ci-all.yml
@ -1,37 +0,0 @@
-# Orchestrates all CI workflows - runs on PRs, pushes to main, and manual dispatch
-# Individual test workflows are called as reusable workflows
-name: CI All
-
-on:
-  push:
-    branches:
-      - main
-  pull_request:
-  workflow_dispatch:
-
-permissions:
-  contents: read
-
-jobs:
-  ci:
-    uses: ./.github/workflows/ci.yml
-
-  test-base-action:
-    uses: ./.github/workflows/test-base-action.yml
-    secrets: inherit # Required for ANTHROPIC_API_KEY
-
-  test-custom-executables:
-    uses: ./.github/workflows/test-custom-executables.yml
-    secrets: inherit
-
-  test-mcp-servers:
-    uses: ./.github/workflows/test-mcp-servers.yml
-    secrets: inherit
-
-  test-settings:
-    uses: ./.github/workflows/test-settings.yml
-    secrets: inherit
-
-  test-structured-output:
-    uses: ./.github/workflows/test-structured-output.yml
-    secrets: inherit
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@ -1,14 +1,15 @@
 name: CI

 on:
+  push:
+    branches: [main]
  pull_request:
-  workflow_call:

 jobs:
  test:
    runs-on: ubuntu-latest
    steps:
-      - uses: actions/checkout@v6
+      - uses: actions/checkout@v5

      - uses: oven-sh/setup-bun@v2
        with:
@ -23,7 +24,7 @@ jobs:
  prettier:
    runs-on: ubuntu-latest
    steps:
-      - uses: actions/checkout@v6
+      - uses: actions/checkout@v5

      - uses: oven-sh/setup-bun@v1
        with:
@ -38,7 +39,7 @@ jobs:
  typecheck:
    runs-on: ubuntu-latest
    steps:
-      - uses: actions/checkout@v6
+      - uses: actions/checkout@v5

      - uses: oven-sh/setup-bun@v2
        with:
--- a/.github/workflows/claude-review.yml
+++ b/.github/workflows/claude-review.yml
@ -13,7 +13,7 @@ jobs:
      id-token: write
    steps:
      - name: Checkout repository
-        uses: actions/checkout@v6
+        uses: actions/checkout@v5
        with:
          fetch-depth: 1

@ -25,4 +25,3 @@ jobs:
          prompt: "/review-pr REPO: ${{ github.repository }} PR_NUMBER: ${{ github.event.pull_request.number }}"
          claude_args: |
            --allowedTools "mcp__github_inline_comment__create_inline_comment"
-            --model "claude-opus-4-7"
--- a/.github/workflows/claude.yml
+++ b/.github/workflows/claude.yml
@ -19,21 +19,21 @@ jobs:
      (github.event_name == 'issues' && (contains(github.event.issue.body, '@claude') || contains(github.event.issue.title, '@claude')))
    runs-on: ubuntu-latest
    permissions:
-      contents: write
-      pull-requests: write
-      issues: write
+      contents: read
+      pull-requests: read
+      issues: read
      id-token: write
    steps:
      - name: Checkout repository
-        uses: actions/checkout@v6
+        uses: actions/checkout@v5
        with:
          fetch-depth: 1

      - name: Run Claude Code
        id: claude
-        uses: anthropics/claude-code-action@main
+        uses: anthropics/claude-code-action@v1
        with:
          anthropic_api_key: ${{ secrets.ANTHROPIC_API_KEY }}
          claude_args: |
            --allowedTools "Bash(bun install),Bash(bun test:*),Bash(bun run format),Bash(bun typecheck)"
-            --model "claude-opus-4-7"
+            --model "claude-opus-4-1-20250805"
--- a/.github/workflows/issue-triage.yml
+++ b/.github/workflows/issue-triage.yml
@ -14,16 +14,14 @@ jobs:

    steps:
      - name: Checkout repository
-        uses: actions/checkout@v6
+        uses: actions/checkout@v5
        with:
          fetch-depth: 0

      - name: Run Claude Code for Issue Triage
        uses: anthropics/claude-code-action@main
-        env:
-          CLAUDE_CODE_SCRIPT_CAPS: '{"edit-issue-labels.sh":2}'
        with:
-          prompt: "/label-issue REPO: ${{ github.repository }} ISSUE_NUMBER: ${{ github.event.issue.number }}"
+          prompt: "/label-issue REPO: ${{ github.repository }} ISSUE_NUMBER${{ github.event.issue.number }}"
          anthropic_api_key: ${{ secrets.ANTHROPIC_API_KEY }}
          allowed_non_write_users: "*" # Required for issue triage workflow, if users without repo write access create issues
          github_token: ${{ secrets.GITHUB_TOKEN }}
--- a/.github/workflows/non-write-users-check.yml
+++ b/.github/workflows/non-write-users-check.yml
@ -1,47 +0,0 @@
-name: Non-write Users Check
-on:
-  pull_request:
-    paths:
-      - ".github/**"
-
-permissions:
-  contents: read
-  pull-requests: write
-
-jobs:
-  allowed-non-write-check:
-    runs-on: ubuntu-latest
-    env:
-      GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-    steps:
-      - run: |
-          DIFF=$(gh pr diff "$PR_NUMBER" -R "$REPO" || true)
-
-          if ! echo "$DIFF" | grep -qE '^diff --git a/\.github/.*\.ya?ml'; then
-            exit 0
-          fi
-
-          MATCHES=$(echo "$DIFF" | grep "^+.*allowed_non_write_users" || true)
-
-          if [ -z "$MATCHES" ]; then
-            exit 0
-          fi
-
-          EXISTING=$(gh pr view "$PR_NUMBER" -R "$REPO" --json comments --jq '.comments[].body' \
-            | grep -c "<!-- non-write-users-check -->" || true)
-
-          if [ "$EXISTING" -gt 0 ]; then
-            exit 0
-          fi
-
-          gh pr comment "$PR_NUMBER" -R "$REPO" --body '<!-- non-write-users-check -->
-          **`allowed_non_write_users` detected**
-
-          This PR adds or modifies `allowed_non_write_users`, which allows users without write access to trigger Claude Code Action workflows. This can introduce security risks.
-
-          If this is a new flow, please make sure you actually need `allowed_non_write_users`. If you are editing an existing workflow, double check that you are not adding new Claude permissions which might lead to a vulnerability.
-
-          See existing workflows in this repo for safe usage examples, or contact the AppSec team.'
-        env:
-          PR_NUMBER: ${{ github.event.pull_request.number }}
-          REPO: ${{ github.repository }}
--- a/.github/workflows/release.yml
+++ b/.github/workflows/release.yml
@ -8,23 +8,10 @@ on:
        required: false
        type: boolean
        default: false
-  workflow_run:
-    workflows: ["CI All"]
-    types:
-      - completed
-    branches:
-      - main

 jobs:
  create-release:
    runs-on: ubuntu-latest
-    # Run if: manual dispatch OR (CI All succeeded AND commit is a version bump)
-    if: |
-      github.event_name == 'workflow_dispatch' ||
-      (github.event.workflow_run.conclusion == 'success' &&
-       github.event.workflow_run.head_branch == 'main' &&
-       github.event.workflow_run.event == 'push' &&
-       startsWith(github.event.workflow_run.head_commit.message, 'chore: bump Claude Code to'))
    environment: production
    permissions:
      contents: write
@ -32,7 +19,7 @@ jobs:
      next_version: ${{ steps.next_version.outputs.next_version }}
    steps:
      - name: Checkout code
-        uses: actions/checkout@v6
+        uses: actions/checkout@v5
        with:
          fetch-depth: 0

@ -97,15 +84,14 @@ jobs:

  update-major-tag:
    needs: create-release
-    # Skip for dry runs (workflow_run events are never dry runs)
-    if: github.event_name == 'workflow_run' || !inputs.dry_run
+    if: ${{ !inputs.dry_run }}
    runs-on: ubuntu-latest
    environment: production
    permissions:
      contents: write
    steps:
      - name: Checkout code
-        uses: actions/checkout@v6
+        uses: actions/checkout@v5
        with:
          fetch-depth: 0

@ -123,48 +109,48 @@ jobs:

          echo "Updated $major_version tag to point to $next_version"

-  # release-base-action:
-  #   needs: create-release
-  #   if: ${{ !inputs.dry_run }}
-  #   runs-on: ubuntu-latest
-  #   environment: production
-  #   steps:
-  #     - name: Checkout base-action repo
-  #       uses: actions/checkout@v6
-  #       with:
-  #         repository: anthropics/claude-code-base-action
-  #         token: ${{ secrets.CLAUDE_CODE_BASE_ACTION_PAT }}
-  #         fetch-depth: 0
-  #
-  #     - name: Create and push tag
-  #       run: |
-  #         next_version="${{ needs.create-release.outputs.next_version }}"
-  #
-  #         git config user.name "github-actions[bot]"
-  #         git config user.email "github-actions[bot]@users.noreply.github.com"
-  #
-  #         # Create the version tag
-  #         git tag -a "$next_version" -m "Release $next_version - synced from claude-code-action"
-  #         git push origin "$next_version"
-  #
-  #         # Update the beta tag
-  #         git tag -fa beta -m "Update beta tag to ${next_version}"
-  #         git push origin beta --force
-  #
-  #     - name: Create GitHub release
-  #       env:
-  #         GH_TOKEN: ${{ secrets.CLAUDE_CODE_BASE_ACTION_PAT }}
-  #       run: |
-  #         next_version="${{ needs.create-release.outputs.next_version }}"
-  #
-  #         # Create the release
-  #         gh release create "$next_version" \
-  #           --repo anthropics/claude-code-base-action \
-  #           --title "$next_version" \
-  #           --notes "Release $next_version - synced from anthropics/claude-code-action" \
-  #           --latest=false
-  #
-  #         # Update beta release to be latest
-  #         gh release edit beta \
-  #           --repo anthropics/claude-code-base-action \
-  #           --latest
+  release-base-action:
+    needs: create-release
+    if: ${{ !inputs.dry_run }}
+    runs-on: ubuntu-latest
+    environment: production
+    steps:
+      - name: Checkout base-action repo
+        uses: actions/checkout@v5
+        with:
+          repository: anthropics/claude-code-base-action
+          token: ${{ secrets.CLAUDE_CODE_BASE_ACTION_PAT }}
+          fetch-depth: 0
+
+      # - name: Create and push tag
+      #   run: |
+      #     next_version="${{ needs.create-release.outputs.next_version }}"
+
+      #     git config user.name "github-actions[bot]"
+      #     git config user.email "github-actions[bot]@users.noreply.github.com"
+
+      #     # Create the version tag
+      #     git tag -a "$next_version" -m "Release $next_version - synced from claude-code-action"
+      #     git push origin "$next_version"
+
+      #     # Update the beta tag
+      #     git tag -fa beta -m "Update beta tag to ${next_version}"
+      #     git push origin beta --force
+
+      # - name: Create GitHub release
+      #   env:
+      #     GH_TOKEN: ${{ secrets.CLAUDE_CODE_BASE_ACTION_PAT }}
+      #   run: |
+      #     next_version="${{ needs.create-release.outputs.next_version }}"
+
+      #     # Create the release
+      #     gh release create "$next_version" \
+      #       --repo anthropics/claude-code-base-action \
+      #       --title "$next_version" \
+      #       --notes "Release $next_version - synced from anthropics/claude-code-action" \
+      #       --latest=false
+
+      #     # Update beta release to be latest
+      #     gh release edit beta \
+      #       --repo anthropics/claude-code-base-action \
+      #       --latest
--- a/.github/workflows/test-base-action.yml
+++ b/.github/workflows/test-base-action.yml
@ -1,6 +1,9 @@
 name: Test Claude Code Action

 on:
+  push:
+    branches:
+      - main
  pull_request:
  workflow_dispatch:
    inputs:
@ -8,7 +11,6 @@ on:
        description: "Test prompt for Claude"
        required: false
        default: "List the files in the current directory starting with 'package'"
-  workflow_call:

 jobs:
  test-inline-prompt:
@ -116,3 +118,61 @@ jobs:
            echo "❌ Execution log file not found"
            exit 1
          fi
+
+  test-agent-sdk:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4
+
+      - name: Test with Agent SDK
+        id: sdk-test
+        uses: ./base-action
+        env:
+          USE_AGENT_SDK: "true"
+        with:
+          prompt: ${{ github.event.inputs.test_prompt || 'List the files in the current directory starting with "package"' }}
+          anthropic_api_key: ${{ secrets.ANTHROPIC_API_KEY }}
+          allowed_tools: "LS,Read"
+
+      - name: Verify SDK output
+        run: |
+          OUTPUT_FILE="${{ steps.sdk-test.outputs.execution_file }}"
+          CONCLUSION="${{ steps.sdk-test.outputs.conclusion }}"
+
+          echo "Conclusion: $CONCLUSION"
+          echo "Output file: $OUTPUT_FILE"
+
+          if [ "$CONCLUSION" = "success" ]; then
+            echo "✅ Action completed successfully with Agent SDK"
+          else
+            echo "❌ Action failed with Agent SDK"
+            exit 1
+          fi
+
+          if [ -f "$OUTPUT_FILE" ]; then
+            if [ -s "$OUTPUT_FILE" ]; then
+              echo "✅ Execution log file created successfully with content"
+              echo "Validating JSON format:"
+              if jq . "$OUTPUT_FILE" > /dev/null 2>&1; then
+                echo "✅ Output is valid JSON"
+                # Verify SDK output contains total_cost_usd (SDK field name)
+                if jq -e '.[] | select(.type == "result") | .total_cost_usd' "$OUTPUT_FILE" > /dev/null 2>&1; then
+                  echo "✅ SDK output contains total_cost_usd field"
+                else
+                  echo "❌ SDK output missing total_cost_usd field"
+                  exit 1
+                fi
+                echo "Content preview:"
+                head -c 500 "$OUTPUT_FILE"
+              else
+                echo "❌ Output is not valid JSON"
+                exit 1
+              fi
+            else
+              echo "❌ Execution log file is empty"
+              exit 1
+            fi
+          else
+            echo "❌ Execution log file not found"
+            exit 1
+          fi
--- a/.github/workflows/test-custom-executables.yml
+++ b/.github/workflows/test-custom-executables.yml
@ -1,9 +1,11 @@
 name: Test Custom Executables

 on:
+  push:
+    branches:
+      - main
  pull_request:
  workflow_dispatch:
-  workflow_call:

 jobs:
  test-custom-executables:
--- a/.github/workflows/test-mcp-servers.yml
+++ b/.github/workflows/test-mcp-servers.yml
@ -1,9 +1,11 @@
 name: Test MCP Servers

 on:
+  push:
+    branches: [main]
  pull_request:
+    branches: [main]
  workflow_dispatch:
-  workflow_call:

 jobs:
  test-mcp-integration:
--- a/.github/workflows/test-settings.yml
+++ b/.github/workflows/test-settings.yml
@ -1,9 +1,11 @@
 name: Test Settings Feature

 on:
+  push:
+    branches:
+      - main
  pull_request:
  workflow_dispatch:
-  workflow_call:

 jobs:
  test-settings-inline-allow:
--- a/.github/workflows/test-structured-output.yml
+++ b/.github/workflows/test-structured-output.yml
@ -1,9 +1,11 @@
 name: Test Structured Outputs

 on:
+  push:
+    branches:
+      - main
  pull_request:
  workflow_dispatch:
-  workflow_call:

 permissions:
  contents: read
--- a/CLAUDE.md
+++ b/CLAUDE.md
@ -1,44 +1,136 @@
 # CLAUDE.md

-## Commands
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+
+## Development Tools
+
+- Runtime: Bun 1.2.11
+- TypeScript with strict configuration
+
+## Common Development Tasks
+
+### Available npm/bun scripts from package.json:

 ```bash
-bun test                # Run tests
-bun run typecheck       # TypeScript type checking
-bun run format          # Format with prettier
-bun run format:check    # Check formatting
+# Test
+bun test
+
+# Formatting
+bun run format          # Format code with prettier
+bun run format:check    # Check code formatting
+
+# Type checking
+bun run typecheck       # Run TypeScript type checker
 ```

-## What This Is
+## Architecture Overview

-A GitHub Action that lets Claude respond to `@claude` mentions on issues/PRs (tag mode) or run tasks via `prompt` input (agent mode). Mode is auto-detected: if `prompt` is provided, it's agent mode; if triggered by a comment/issue event with `@claude`, it's tag mode. See `src/modes/detector.ts`.
+This is a GitHub Action that enables Claude to interact with GitHub PRs and issues. The action operates in two main phases:

-## How It Runs
+### Phase 1: Preparation (`src/entrypoints/prepare.ts`)

-Single entrypoint: `src/entrypoints/run.ts` orchestrates everything — prepare (auth, permissions, trigger check, branch/comment creation), install Claude Code CLI, execute Claude via `base-action/` functions (imported directly, not subprocess), then cleanup (update tracking comment, write step summary). SSH signing cleanup and token revocation are separate `always()` steps in `action.yml`.
+1. **Authentication Setup**: Establishes GitHub token via OIDC or GitHub App
+2. **Permission Validation**: Verifies actor has write permissions
+3. **Trigger Detection**: Uses mode-specific logic to determine if Claude should respond
+4. **Context Creation**: Prepares GitHub context and initial tracking comment

-`base-action/` is also published standalone as `@anthropic-ai/claude-code-base-action`. Don't break its public API. It reads config from `INPUT_`-prefixed env vars (set by `action.yml`), not from action inputs directly.
+### Phase 2: Execution (`base-action/`)

-## Key Concepts
+The `base-action/` directory contains the core Claude Code execution logic, which serves a dual purpose:

-**Auth priority**: `github_token` input (user-provided) > GitHub App OIDC token (default). The `claude_code_oauth_token` and `anthropic_api_key` are for the Claude API, not GitHub. Token setup lives in `src/github/token.ts`.
+- **Standalone Action**: Published separately as `@anthropic-ai/claude-code-base-action` for direct use
+- **Inner Logic**: Used internally by this GitHub Action after preparation phase completes

-**Mode lifecycle**: `detectMode()` in `src/modes/detector.ts` picks the mode name ("tag" or "agent"). Trigger checking and prepare dispatch are inlined in `run.ts`: tag mode calls `prepareTagMode()` from `src/modes/tag/`, agent mode calls `prepareAgentMode()` from `src/modes/agent/`.
+Execution steps:

-**Prompt construction**: Tag mode's `prepareTagMode()` builds the prompt by fetching GitHub data (`src/github/data/fetcher.ts`), formatting it as markdown (`src/github/data/formatter.ts`), and writing it to a temp file via `createPrompt()`. Agent mode writes the user's prompt directly. The prompt includes issue/PR body, comments, diff, and CI status. This is the most important part of the action — it's what Claude sees.
+1. **MCP Server Setup**: Installs and configures GitHub MCP server for tool access
+2. **Prompt Generation**: Creates context-rich prompts from GitHub data
+3. **Claude Integration**: Executes via multiple providers (Anthropic API, AWS Bedrock, Google Vertex AI)
+4. **Result Processing**: Updates comments and creates branches/PRs as needed

-## Things That Will Bite You
+### Key Architectural Components

- **Strict TypeScript**: `noUnusedLocals` and `noUnusedParameters` are enabled. Typecheck will fail on unused variables.
- **Discriminated unions for GitHub context**: `GitHubContext` is a union type — call `isEntityContext(context)` before accessing entity-specific fields like `context.issue` or `context.pullRequest`.
- **Token lifecycle matters**: The GitHub App token is obtained early and revoked in a separate `always()` step in `action.yml`. If you move token revocation into `run.ts`, it won't run if the process crashes. Same for SSH signing cleanup.
- **Error phase attribution**: The catch block in `run.ts` uses `prepareCompleted` to distinguish prepare failures from execution failures. The tracking comment shows different messages for each.
- **`action.yml` outputs reference step IDs**: Outputs like `execution_file`, `branch_name`, `github_token` reference `steps.run.outputs.*`. If you rename the step ID, update the outputs section too.
- **Integration testing** happens in a separate repo (`install-test`), not here. The tests in this repo are unit tests.
+#### Mode System (`src/modes/`)
+
+- **Tag Mode** (`tag/`): Responds to `@claude` mentions and issue assignments
+- **Agent Mode** (`agent/`): Direct execution when explicit prompt is provided
+- Extensible registry pattern in `modes/registry.ts`
+
+#### GitHub Integration (`src/github/`)
+
+- **Context Parsing** (`context.ts`): Unified GitHub event handling
+- **Data Fetching** (`data/fetcher.ts`): Retrieves PR/issue data via GraphQL/REST
+- **Data Formatting** (`data/formatter.ts`): Converts GitHub data to Claude-readable format
+- **Branch Operations** (`operations/branch.ts`): Handles branch creation and cleanup
+- **Comment Management** (`operations/comments/`): Creates and updates tracking comments
+
+#### MCP Server Integration (`src/mcp/`)
+
+- **GitHub Actions Server** (`github-actions-server.ts`): Workflow and CI access
+- **GitHub Comment Server** (`github-comment-server.ts`): Comment operations
+- **GitHub File Operations** (`github-file-ops-server.ts`): File system access
+- Auto-installation and configuration in `install-mcp-server.ts`
+
+#### Authentication & Security (`src/github/`)
+
+- **Token Management** (`token.ts`): OIDC token exchange and GitHub App authentication
+- **Permission Validation** (`validation/permissions.ts`): Write access verification
+- **Actor Validation** (`validation/actor.ts`): Human vs bot detection
+
+### Project Structure
+
+```
+src/
+├── entrypoints/           # Action entry points
+│   ├── prepare.ts         # Main preparation logic
+│   ├── update-comment-link.ts  # Post-execution comment updates
+│   └── format-turns.ts    # Claude conversation formatting
+├── github/               # GitHub integration layer
+│   ├── api/              # REST/GraphQL clients
+│   ├── data/             # Data fetching and formatting
+│   ├── operations/       # Branch, comment, git operations
+│   ├── validation/       # Permission and trigger validation
+│   └── utils/            # Image downloading, sanitization
+├── modes/                # Execution modes
+│   ├── tag/              # @claude mention mode
+│   ├── agent/            # Automation mode
+│   └── registry.ts       # Mode selection logic
+├── mcp/                  # MCP server implementations
+├── prepare/              # Preparation orchestration
+└── utils/                # Shared utilities
+```
+
+## Important Implementation Notes
+
+### Authentication Flow
+
+- Uses GitHub OIDC token exchange for secure authentication
+- Supports custom GitHub Apps via `APP_ID` and `APP_PRIVATE_KEY`
+- Falls back to official Claude GitHub App if no custom app provided
+
+### MCP Server Architecture
+
+- Each MCP server has specific GitHub API access patterns
+- Servers are auto-installed in `~/.claude/mcp/github-{type}-server/`
+- Configuration merged with user-provided MCP config via `mcp_config` input
+
+### Mode System Design
+
+- Modes implement `Mode` interface with `shouldTrigger()` and `prepare()` methods
+- Registry validates mode compatibility with GitHub event types
+- Agent mode triggers when explicit prompt is provided
+
+### Comment Threading
+
+- Single tracking comment updated throughout execution
+- Progress indicated via dynamic checkboxes
+- Links to job runs and created branches/PRs
+- Sticky comment option for consolidated PR comments

 ## Code Conventions

- Runtime is Bun, not Node. Use `bun test`, not `jest`.
- `moduleResolution: "bundler"` — imports don't need `.js` extensions.
- GitHub API calls should use retry logic (`src/utils/retry.ts`).
- MCP servers are auto-installed at runtime to `~/.claude/mcp/github-{type}-server/`.
+- Use Bun-specific TypeScript configuration with `moduleResolution: "bundler"`
+- Strict TypeScript with `noUnusedLocals` and `noUnusedParameters` enabled
+- Prefer explicit error handling with detailed error messages
+- Use discriminated unions for GitHub context types
+- Implement retry logic for GitHub API operations via `utils/retry.ts`
--- a/action.yml
+++ b/action.yml
@ -23,33 +23,12 @@ inputs:
    description: "The prefix to use for Claude branches (defaults to 'claude/', use 'claude-' for dash format)"
    required: false
    default: "claude/"
-  branch_name_template:
-    description: "Template for branch naming. Available variables: {{prefix}}, {{entityType}}, {{entityNumber}}, {{timestamp}}, {{sha}}, {{label}}, {{description}}. {{label}} will be first label from the issue/PR, or {{entityType}} as a fallback. {{description}} will be the first 5 words of the issue/PR title in kebab-case. Default: '{{prefix}}{{entityType}}-{{entityNumber}}-{{timestamp}}'"
-    required: false
-    default: ""
  allowed_bots:
-    description: "Comma-separated list of allowed bot usernames, or '*' to allow all bots. Empty string (default) allows no bots. WARNING: On public repos with '*', external Apps may be able to invoke this action with prompts they control. See docs/security.md."
+    description: "Comma-separated list of allowed bot usernames, or '*' to allow all bots. Empty string (default) allows no bots."
    required: false
    default: ""
  allowed_non_write_users:
-    description: |
-      Comma-separated list of usernames to allow without write permissions, or '*' to allow all users.
-      Only works when github_token input is provided. WARNING: Use with extreme caution - this
-      bypasses security checks and should only be used for workflows with very limited permissions
-      (e.g., issue labeling).
-
-      SECURITY: Processing untrusted content exposes the workflow to prompt injection. When this
-      input is set, Claude does a best-effort scrub of Anthropic, cloud, and GitHub Actions secrets
-      from subprocess environments. This reduces but does not eliminate prompt injection risk -
-      only use for workflows with very limited permissions and validate all outputs.
-    required: false
-    default: ""
-  include_comments_by_actor:
-    description: "Comma-separated list of actor usernames to INCLUDE in comments. Supports wildcards: '*[bot]' matches all bots, 'dependabot[bot]' matches specific bot. Empty (default) includes all actors."
-    required: false
-    default: ""
-  exclude_comments_by_actor:
-    description: "Comma-separated list of actor usernames to EXCLUDE from comments. Supports wildcards: '*[bot]' matches all bots, 'renovate[bot]' matches specific bot. Empty (default) excludes none. If actor is in both lists, exclusion takes priority."
+    description: "Comma-separated list of usernames to allow without write permissions, or '*' to allow all users. Only works when github_token input is provided. WARNING: Use with extreme caution - this bypasses security checks and should only be used for workflows with very limited permissions (e.g., issue labeling)."
    required: false
    default: ""

@ -98,18 +77,10 @@ inputs:
    description: "Use just one comment to deliver issue/PR comments"
    required: false
    default: "false"
-  classify_inline_comments:
-    description: "Buffer inline comments without confirmed=true and classify them (real review vs test/probe) before posting after the session ends. Set to 'false' to post all inline comments immediately (pre-buffering behavior)."
-    required: false
-    default: "true"
  use_commit_signing:
    description: "Enable commit signing using GitHub's commit signature verification. When false, Claude uses standard git commands"
    required: false
    default: "false"
-  ssh_signing_key:
-    description: "SSH private key for signing commits. When provided, git will be configured to use SSH signing. Takes precedence over use_commit_signing."
-    required: false
-    default: ""
  bot_id:
    description: "GitHub user ID to use for git operations (defaults to Claude's bot ID)"
    required: false
@ -122,10 +93,6 @@ inputs:
    description: "Force tag mode with tracking comments for pull_request and issue events. Only applicable to pull_request (opened, synchronize, ready_for_review, reopened) and issue (opened, edited, labeled, assigned) events."
    required: false
    default: "false"
-  include_fix_links:
-    description: "Include 'Fix this' links in PR code review feedback that open Claude Code with context to fix the identified issue"
-    required: false
-    default: "true"
  path_to_claude_code_executable:
    description: "Optional path to a custom Claude Code executable. If provided, skips automatic installation and uses this executable instead. WARNING: Using an older version may cause problems if the action begins taking advantage of new Claude Code features. This input is typically not needed unless you're debugging something specific or have unique needs in your environment."
    required: false
@ -134,10 +101,6 @@ inputs:
    description: "Optional path to a custom Bun executable. If provided, skips automatic Bun installation and uses this executable instead. WARNING: Using an incompatible version may cause problems if the action requires specific Bun features. This input is typically not needed unless you're debugging something specific or have unique needs in your environment."
    required: false
    default: ""
-  display_report:
-    description: "Whether to display the Claude Code Report in GitHub Step Summary. Set to 'false' to disable when using custom formatting solutions. WARNING: This outputs Claude-authored content in the GitHub Step Summary. This should only be used in cases where the action is used solely with trusted input."
-    required: false
-    default: "false"
  show_full_output:
    description: "Show full JSON output from Claude Code. WARNING: This outputs ALL Claude messages including tool execution results which may contain secrets, API keys, or other sensitive information. These logs are publicly visible in GitHub Actions. Only enable for debugging in non-sensitive environments."
    required: false
@ -154,29 +117,28 @@ inputs:
 outputs:
  execution_file:
    description: "Path to the Claude Code execution output file"
-    value: ${{ steps.run.outputs.execution_file }}
+    value: ${{ steps.claude-code.outputs.execution_file }}
  branch_name:
    description: "The branch created by Claude Code for this execution"
-    value: ${{ steps.run.outputs.branch_name }}
+    value: ${{ steps.prepare.outputs.CLAUDE_BRANCH }}
  github_token:
    description: "The GitHub token used by the action (Claude App token if available)"
-    value: ${{ steps.run.outputs.github_token }}
+    value: ${{ steps.prepare.outputs.github_token }}
  structured_output:
    description: "JSON string containing all structured output fields when --json-schema is provided in claude_args. Use fromJSON() to parse: fromJSON(steps.id.outputs.structured_output).field_name"
-    value: ${{ steps.run.outputs.structured_output }}
+    value: ${{ steps.claude-code.outputs.structured_output }}
  session_id:
    description: "The Claude Code session ID that can be used with --resume to continue this conversation"
-    value: ${{ steps.run.outputs.session_id }}
+    value: ${{ steps.claude-code.outputs.session_id }}

 runs:
  using: "composite"
  steps:
    - name: Install Bun
      if: inputs.path_to_bun_executable == ''
-      uses: oven-sh/setup-bun@0c5077e51419868618aeaa5fe8019c62421857d6 # https://github.com/oven-sh/setup-bun/releases/tag/v2.2.0
+      uses: oven-sh/setup-bun@735343b667d3e6f658f44d0eca948eb6282f2b76 # https://github.com/oven-sh/setup-bun/releases/tag/v2.0.2
      with:
-        bun-version: 1.3.6
-        token: ${{ inputs.github_token || github.token }}
+        bun-version: 1.2.11

    - name: Setup Custom Bun Path
      if: inputs.path_to_bun_executable != ''
@ -193,60 +155,14 @@ runs:
      shell: bash
      run: |
        cd ${GITHUB_ACTION_PATH}
-        bun install --production
+        bun install

-    - name: Install subprocess isolation dependencies
-      # Install subprocess isolation dependencies when processing content from non-write users.
-      # Best-effort: skips on non-Linux or when sudo/apt unavailable (self-hosted runners).
-      if: ${{ inputs.allowed_non_write_users != '' && runner.os == 'Linux' }}
-      continue-on-error: true
+    - name: Prepare action
+      id: prepare
      shell: bash
      run: |
-        if [ "${CLAUDE_CODE_SUBPROCESS_ENV_SCRUB:-}" = "0" ]; then
-          echo "Subprocess isolation opted out via CLAUDE_CODE_SUBPROCESS_ENV_SCRUB=0"
-          exit 0
-        fi
-        if command -v apt-get >/dev/null && command -v sudo >/dev/null; then
-          for i in 1 2 3; do
-            sudo apt-get update -qq && sudo apt-get install -y --no-install-recommends bubblewrap socat && break
-            echo "apt-get attempt $i failed, retrying..."
-            sleep 5
-          done
-        fi
-        # Ubuntu 24.04+ restricts unprivileged user namespaces via AppArmor.
-        # The sysctl doesn't exist on older kernels — that's fine.
-        if [ -f /proc/sys/kernel/apparmor_restrict_unprivileged_userns ] && command -v sudo >/dev/null; then
-          sudo sysctl -w kernel.apparmor_restrict_unprivileged_userns=0
-        fi
-
-    - name: Pin bun binary for post-steps
-      if: ${{ inputs.allowed_non_write_users != '' }}
-      continue-on-error: true
-      shell: bash
-      run: |
-        # Keep a copy of the bun binary alongside the action's own files so
-        # post-steps use the same version that was on PATH at action start.
-        mkdir -p "$GITHUB_ACTION_PATH/bin"
-        cp "$(command -v bun)" "$GITHUB_ACTION_PATH/bin/bun"
-
-    - name: Prepend system bin dirs to PATH
-      if: ${{ inputs.allowed_non_write_users != '' && runner.os != 'Windows' }}
-      continue-on-error: true
-      shell: /bin/bash --noprofile --norc -e -o pipefail {0}
-      run: |
-        echo "/usr/bin" >> "$GITHUB_PATH"
-        echo "/bin" >> "$GITHUB_PATH"
-
-    - name: Run Claude Code Action
-      id: run
-      shell: bash
-      run: |
-        bun --no-env-file \
-          --config="${GITHUB_ACTION_PATH}/bunfig.toml" \
-          --tsconfig-override="${GITHUB_ACTION_PATH}/tsconfig.json" \
-          run ${GITHUB_ACTION_PATH}/src/entrypoints/run.ts
+        bun run ${GITHUB_ACTION_PATH}/src/entrypoints/prepare.ts
      env:
-        # Prepare inputs
        MODE: ${{ inputs.mode }}
        PROMPT: ${{ inputs.prompt }}
        TRIGGER_PHRASE: ${{ inputs.trigger_phrase }}
@ -254,42 +170,96 @@ runs:
        LABEL_TRIGGER: ${{ inputs.label_trigger }}
        BASE_BRANCH: ${{ inputs.base_branch }}
        BRANCH_PREFIX: ${{ inputs.branch_prefix }}
-        BRANCH_NAME_TEMPLATE: ${{ inputs.branch_name_template }}
        OVERRIDE_GITHUB_TOKEN: ${{ inputs.github_token }}
        ALLOWED_BOTS: ${{ inputs.allowed_bots }}
        ALLOWED_NON_WRITE_USERS: ${{ inputs.allowed_non_write_users }}
-        CLAUDE_CODE_SUBPROCESS_ENV_SCRUB: ${{ env.CLAUDE_CODE_SUBPROCESS_ENV_SCRUB || (inputs.allowed_non_write_users != '' && '1') || '' }}
-        CLAUDE_CODE_SCRIPT_CAPS: ${{ env.CLAUDE_CODE_SCRIPT_CAPS || '' }}
-        INCLUDE_COMMENTS_BY_ACTOR: ${{ inputs.include_comments_by_actor }}
-        EXCLUDE_COMMENTS_BY_ACTOR: ${{ inputs.exclude_comments_by_actor }}
        GITHUB_RUN_ID: ${{ github.run_id }}
        USE_STICKY_COMMENT: ${{ inputs.use_sticky_comment }}
-        CLASSIFY_INLINE_COMMENTS: ${{ inputs.classify_inline_comments }}
        DEFAULT_WORKFLOW_TOKEN: ${{ github.token }}
        USE_COMMIT_SIGNING: ${{ inputs.use_commit_signing }}
-        SSH_SIGNING_KEY: ${{ inputs.ssh_signing_key }}
        BOT_ID: ${{ inputs.bot_id }}
        BOT_NAME: ${{ inputs.bot_name }}
        TRACK_PROGRESS: ${{ inputs.track_progress }}
-        INCLUDE_FIX_LINKS: ${{ inputs.include_fix_links }}
        ADDITIONAL_PERMISSIONS: ${{ inputs.additional_permissions }}
        CLAUDE_ARGS: ${{ inputs.claude_args }}
        ALL_INPUTS: ${{ toJson(inputs) }}

+    - name: Install Base Action Dependencies
+      if: steps.prepare.outputs.contains_trigger == 'true'
+      shell: bash
+      env:
+        PATH_TO_CLAUDE_CODE_EXECUTABLE: ${{ inputs.path_to_claude_code_executable }}
+      run: |
+        echo "Installing base-action dependencies..."
+        cd ${GITHUB_ACTION_PATH}/base-action
+        bun install
+        echo "Base-action dependencies installed"
+        cd -
+
+        # Install Claude Code if no custom executable is provided
+        if [ -z "$PATH_TO_CLAUDE_CODE_EXECUTABLE" ]; then
+          CLAUDE_CODE_VERSION="2.0.69"
+          echo "Installing Claude Code v${CLAUDE_CODE_VERSION}..."
+          for attempt in 1 2 3; do
+            echo "Installation attempt $attempt..."
+
+            # Clean up stale lock files before retry
+            rm -rf ~/.claude/.locks 2>/dev/null || true
+
+            if command -v timeout &> /dev/null; then
+              timeout 120 bash -c "curl -fsSL https://claude.ai/install.sh | bash -s -- $CLAUDE_CODE_VERSION" && break
+            else
+              curl -fsSL https://claude.ai/install.sh | bash -s -- "$CLAUDE_CODE_VERSION" && break
+            fi
+            if [ $attempt -eq 3 ]; then
+              echo "Failed to install Claude Code after 3 attempts"
+              exit 1
+            fi
+            echo "Installation failed, retrying..."
+            sleep 5
+          done
+
+          # Add to PATH and validate installation
+          echo "$HOME/.local/bin" >> "$GITHUB_PATH"
+          export PATH="$HOME/.local/bin:$PATH"
+          if ! command -v claude &> /dev/null; then
+            echo "Installation failed: claude binary not found in PATH"
+            exit 1
+          fi
+          echo "Claude Code installed successfully"
+        else
+          echo "Using custom Claude Code executable: $PATH_TO_CLAUDE_CODE_EXECUTABLE"
+          # Add the directory containing the custom executable to PATH
+          CLAUDE_DIR=$(dirname "$PATH_TO_CLAUDE_CODE_EXECUTABLE")
+          echo "$CLAUDE_DIR" >> "$GITHUB_PATH"
+        fi
+
+    - name: Run Claude Code
+      id: claude-code
+      if: steps.prepare.outputs.contains_trigger == 'true'
+      shell: bash
+      run: |
+
+        # Run the base-action
+        bun run ${GITHUB_ACTION_PATH}/base-action/src/index.ts
+      env:
        # Base-action inputs
+        CLAUDE_CODE_ACTION: "1"
        INPUT_PROMPT_FILE: ${{ runner.temp }}/claude-prompts/claude-prompt.txt
        INPUT_SETTINGS: ${{ inputs.settings }}
+        INPUT_CLAUDE_ARGS: ${{ steps.prepare.outputs.claude_args }}
        INPUT_EXPERIMENTAL_SLASH_COMMANDS_DIR: ${{ github.action_path }}/slash-commands
+        INPUT_ACTION_INPUTS_PRESENT: ${{ steps.prepare.outputs.action_inputs_present }}
        INPUT_PATH_TO_CLAUDE_CODE_EXECUTABLE: ${{ inputs.path_to_claude_code_executable }}
        INPUT_PATH_TO_BUN_EXECUTABLE: ${{ inputs.path_to_bun_executable }}
        INPUT_SHOW_FULL_OUTPUT: ${{ inputs.show_full_output }}
-        DISPLAY_REPORT: ${{ inputs.display_report }}
        INPUT_PLUGINS: ${{ inputs.plugins }}
        INPUT_PLUGIN_MARKETPLACES: ${{ inputs.plugin_marketplaces }}
-        PATH_TO_CLAUDE_CODE_EXECUTABLE: ${{ inputs.path_to_claude_code_executable }}

        # Model configuration
+        GITHUB_TOKEN: ${{ steps.prepare.outputs.GITHUB_TOKEN }}
        NODE_VERSION: ${{ env.NODE_VERSION }}
+        DETAILED_PERMISSION_MESSAGES: "1"

        # Provider configuration
        ANTHROPIC_API_KEY: ${{ inputs.anthropic_api_key }}
@ -326,87 +296,55 @@ runs:
        ANTHROPIC_DEFAULT_HAIKU_MODEL: ${{ env.ANTHROPIC_DEFAULT_HAIKU_MODEL }}
        ANTHROPIC_DEFAULT_OPUS_MODEL: ${{ env.ANTHROPIC_DEFAULT_OPUS_MODEL }}

-        # MCP configuration — these env vars are read directly from process.env by the
-        # Claude CLI subprocess. They must be listed explicitly here because this step's
-        # env: block shadows the calling workflow's job-level env vars (GitHub Actions
-        # composite action behavior). Set these in your workflow's job-level env: or via
-        # a prior step that writes to $GITHUB_ENV.
-        MCP_TIMEOUT: ${{ env.MCP_TIMEOUT }}
-        MCP_TOOL_TIMEOUT: ${{ env.MCP_TOOL_TIMEOUT }}
-        MAX_MCP_OUTPUT_TOKENS: ${{ env.MAX_MCP_OUTPUT_TOKENS }}
-
-        # Telemetry configuration
-        CLAUDE_CODE_ENABLE_TELEMETRY: ${{ env.CLAUDE_CODE_ENABLE_TELEMETRY }}
-        OTEL_METRICS_EXPORTER: ${{ env.OTEL_METRICS_EXPORTER }}
-        OTEL_LOGS_EXPORTER: ${{ env.OTEL_LOGS_EXPORTER }}
-        OTEL_EXPORTER_OTLP_PROTOCOL: ${{ env.OTEL_EXPORTER_OTLP_PROTOCOL }}
-        OTEL_EXPORTER_OTLP_ENDPOINT: ${{ env.OTEL_EXPORTER_OTLP_ENDPOINT }}
-        OTEL_EXPORTER_OTLP_HEADERS: ${{ env.OTEL_EXPORTER_OTLP_HEADERS }}
-        OTEL_METRIC_EXPORT_INTERVAL: ${{ env.OTEL_METRIC_EXPORT_INTERVAL }}
-        OTEL_LOGS_EXPORT_INTERVAL: ${{ env.OTEL_LOGS_EXPORT_INTERVAL }}
-        OTEL_RESOURCE_ATTRIBUTES: ${{ env.OTEL_RESOURCE_ATTRIBUTES }}
-
-    - name: Re-prepend system bin dirs to PATH
-      if: ${{ always() && inputs.allowed_non_write_users != '' && runner.os != 'Windows' }}
-      continue-on-error: true
-      shell: /bin/bash --noprofile --norc -e -o pipefail {0}
-      env:
-        BASH_ENV: ""
-        LD_PRELOAD: ""
-        LD_LIBRARY_PATH: ""
-        NODE_OPTIONS: ""
-        DYLD_INSERT_LIBRARIES: ""
-        DYLD_PRELOAD: ""
-        DYLD_LIBRARY_PATH: ""
-        DYLD_FRAMEWORK_PATH: ""
-      run: |
-        echo "/usr/bin" >> "$GITHUB_PATH"
-        echo "/bin" >> "$GITHUB_PATH"
-        {
-          echo "BASH_ENV="
-          echo "LD_PRELOAD="
-          echo "LD_LIBRARY_PATH="
-          echo "DYLD_INSERT_LIBRARIES="
-          echo "DYLD_PRELOAD="
-          echo "DYLD_LIBRARY_PATH="
-          echo "DYLD_FRAMEWORK_PATH="
-        } >> "$GITHUB_ENV"
-
-    - name: Cleanup SSH signing key
-      if: always() && inputs.ssh_signing_key != ''
+    - name: Update comment with job link
+      if: steps.prepare.outputs.contains_trigger == 'true' && steps.prepare.outputs.claude_comment_id && always()
      shell: bash
      run: |
-        BUN_BIN="${GITHUB_ACTION_PATH}/bin/bun"
-        [ -x "$BUN_BIN" ] || BUN_BIN="bun"
-        "$BUN_BIN" --no-env-file \
-          --config="${GITHUB_ACTION_PATH}/bunfig.toml" \
-          --tsconfig-override="${GITHUB_ACTION_PATH}/tsconfig.json" \
-          run ${GITHUB_ACTION_PATH}/src/entrypoints/cleanup-ssh-signing.ts
-
-    - name: Post buffered inline comments
-      if: always() && inputs.classify_inline_comments != 'false'
-      shell: bash
+        bun run ${GITHUB_ACTION_PATH}/src/entrypoints/update-comment-link.ts
      env:
-        GITHUB_TOKEN: ${{ steps.run.outputs.github_token || inputs.github_token || github.token }}
-        REPO_OWNER: ${{ github.event.repository.owner.login }}
-        REPO_NAME: ${{ github.event.repository.name }}
-        PR_NUMBER: ${{ github.event.pull_request.number || github.event.issue.number }}
-        ANTHROPIC_API_KEY: ${{ inputs.anthropic_api_key }}
+        REPOSITORY: ${{ github.repository }}
+        PR_NUMBER: ${{ github.event.issue.number || github.event.pull_request.number }}
+        CLAUDE_COMMENT_ID: ${{ steps.prepare.outputs.claude_comment_id }}
+        GITHUB_RUN_ID: ${{ github.run_id }}
+        GITHUB_TOKEN: ${{ steps.prepare.outputs.GITHUB_TOKEN }}
+        GITHUB_EVENT_NAME: ${{ github.event_name }}
+        TRIGGER_COMMENT_ID: ${{ github.event.comment.id }}
+        CLAUDE_BRANCH: ${{ steps.prepare.outputs.CLAUDE_BRANCH }}
+        IS_PR: ${{ github.event.issue.pull_request != null || github.event_name == 'pull_request_target' || github.event_name == 'pull_request_review_comment' }}
+        BASE_BRANCH: ${{ steps.prepare.outputs.BASE_BRANCH }}
+        CLAUDE_SUCCESS: ${{ steps.claude-code.outputs.conclusion == 'success' }}
+        OUTPUT_FILE: ${{ steps.claude-code.outputs.execution_file || '' }}
+        TRIGGER_USERNAME: ${{ github.event.comment.user.login || github.event.issue.user.login || github.event.pull_request.user.login || github.event.sender.login || github.triggering_actor || github.actor || '' }}
+        PREPARE_SUCCESS: ${{ steps.prepare.outcome == 'success' }}
+        PREPARE_ERROR: ${{ steps.prepare.outputs.prepare_error || '' }}
+        USE_STICKY_COMMENT: ${{ inputs.use_sticky_comment }}
+        USE_COMMIT_SIGNING: ${{ inputs.use_commit_signing }}
+        TRACK_PROGRESS: ${{ inputs.track_progress }}
+
+    - name: Display Claude Code Report
+      if: steps.prepare.outputs.contains_trigger == 'true' && steps.claude-code.outputs.execution_file != ''
+      shell: bash
      run: |
-        BUN_BIN="${GITHUB_ACTION_PATH}/bin/bun"
-        [ -x "$BUN_BIN" ] || BUN_BIN="bun"
-        "$BUN_BIN" --no-env-file \
-          --config="${GITHUB_ACTION_PATH}/bunfig.toml" \
-          --tsconfig-override="${GITHUB_ACTION_PATH}/tsconfig.json" \
-          run ${GITHUB_ACTION_PATH}/src/entrypoints/post-buffered-inline-comments.ts
+        # Try to format the turns, but if it fails, dump the raw JSON
+        if bun run ${{ github.action_path }}/src/entrypoints/format-turns.ts "${{ steps.claude-code.outputs.execution_file }}" >> $GITHUB_STEP_SUMMARY 2>/dev/null; then
+          echo "Successfully formatted Claude Code report"
+        else
+          echo "## Claude Code Report (Raw Output)" >> $GITHUB_STEP_SUMMARY
+          echo "" >> $GITHUB_STEP_SUMMARY
+          echo "Failed to format output (please report). Here's the raw JSON:" >> $GITHUB_STEP_SUMMARY
+          echo "" >> $GITHUB_STEP_SUMMARY
+          echo '```json' >> $GITHUB_STEP_SUMMARY
+          cat "${{ steps.claude-code.outputs.execution_file }}" >> $GITHUB_STEP_SUMMARY
+          echo '```' >> $GITHUB_STEP_SUMMARY
+        fi

    - name: Revoke app token
-      if: always() && inputs.github_token == '' && steps.run.outputs.github_token != '' && steps.run.outputs.skipped_due_to_workflow_validation_mismatch != 'true'
+      if: always() && inputs.github_token == '' && steps.prepare.outputs.skipped_due_to_workflow_validation_mismatch != 'true'
      shell: bash
      run: |
        curl -L \
          -X DELETE \
          -H "Accept: application/vnd.github+json" \
-          -H "Authorization: Bearer ${{ steps.run.outputs.github_token }}" \
+          -H "Authorization: Bearer ${{ steps.prepare.outputs.GITHUB_TOKEN }}" \
          -H "X-GitHub-Api-Version: 2022-11-28" \
          ${GITHUB_API_URL:-https://api.github.com}/installation/token
--- a/base-action/CLAUDE.md
+++ b/base-action/CLAUDE.md
@ -27,6 +27,7 @@ This is a GitHub Action that allows running Claude Code within GitHub workflows.
 ### Key Design Patterns

 - Uses Bun runtime for development and execution
+- Named pipes for IPC between prompt input and Claude process
 - JSON streaming output format for execution logs
 - Composite action pattern to orchestrate multiple steps
 - Provider-agnostic design supporting Anthropic API, AWS Bedrock, and Google Vertex AI
@ -53,6 +54,7 @@ This is a GitHub Action that allows running Claude Code within GitHub workflows.

 ## Important Technical Details

+- Uses `mkfifo` to create named pipes for prompt input
 - Outputs execution logs as JSON to `/tmp/claude-execution-output.json`
 - Timeout enforcement via `timeout` command wrapper
 - Strict TypeScript configuration with Bun-specific settings
--- a/base-action/README.md
+++ b/base-action/README.md
@ -4,14 +4,6 @@ This GitHub Action allows you to run [Claude Code](https://www.anthropic.com/cla

 For simply tagging @claude in issues and PRs out of the box, [check out the Claude Code action and GitHub app](https://github.com/anthropics/claude-code-action).

-## Trust model
-
-This action is a thin wrapper that installs and runs Claude Code with the inputs you provide. It does **not** enforce any trust boundaries on its own. Running this action in a directory is equivalent to running Claude Code in that directory — Claude reads project-level configuration (`.claude/`, `CLAUDE.md`, `.mcp.json`, etc.) from the working directory, and the action's own setup steps run from there as well.
-
-**The caller is responsible for ensuring the working directory and prompt are trusted.** If your workflow processes untrusted input (issues, fork pull requests, external comments), use [`anthropics/claude-code-action`](https://github.com/anthropics/claude-code-action) instead — it provides actor permission checks, restores project configuration from the base ref in PR contexts, and is the supported path for those scenarios.
-
-See [Claude Code's security documentation](https://docs.anthropic.com/en/docs/claude-code/security) and the [GitHub Actions guidance on `pull_request_target`](https://securitylab.github.com/research/github-actions-preventing-pwn-requests/) for background.
-
 ## Usage

 Add the following to your workflow file:
@ -347,7 +339,7 @@ jobs:
    runs-on: ubuntu-latest
    steps:
      - name: Checkout code
-        uses: actions/checkout@v6
+        uses: actions/checkout@v5
        with:
          fetch-depth: 0

--- a/base-action/action.yml
+++ b/base-action/action.yml
@ -97,9 +97,9 @@ runs:

    - name: Install Bun
      if: inputs.path_to_bun_executable == ''
-      uses: oven-sh/setup-bun@0c5077e51419868618aeaa5fe8019c62421857d6 # https://github.com/oven-sh/setup-bun/releases/tag/v2.2.0
+      uses: oven-sh/setup-bun@735343b667d3e6f658f44d0eca948eb6282f2b76 # https://github.com/oven-sh/setup-bun/releases/tag/v2.0.2
      with:
-        bun-version: 1.3.6
+        bun-version: 1.2.11

    - name: Setup Custom Bun Path
      if: inputs.path_to_bun_executable != ''
@ -116,7 +116,7 @@ runs:
      shell: bash
      run: |
        cd ${GITHUB_ACTION_PATH}
-        bun install --production
+        bun install

    - name: Install Claude Code
      shell: bash
@ -124,13 +124,16 @@ runs:
        PATH_TO_CLAUDE_CODE_EXECUTABLE: ${{ inputs.path_to_claude_code_executable }}
      run: |
        if [ -z "$PATH_TO_CLAUDE_CODE_EXECUTABLE" ]; then
-          CLAUDE_CODE_VERSION="2.1.123"
+          CLAUDE_CODE_VERSION="2.0.69"
          echo "Installing Claude Code v${CLAUDE_CODE_VERSION}..."
          for attempt in 1 2 3; do
            echo "Installation attempt $attempt..."
+
+            # Clean up stale lock files before retry
+            rm -rf ~/.claude/.locks 2>/dev/null || true
+
            if command -v timeout &> /dev/null; then
-              # Use --foreground to kill entire process group on timeout, --kill-after to send SIGKILL if SIGTERM fails
-              timeout --foreground --kill-after=10 120 bash -c "curl -fsSL https://claude.ai/install.sh | bash -s -- $CLAUDE_CODE_VERSION" && break
+              timeout 120 bash -c "curl -fsSL https://claude.ai/install.sh | bash -s -- $CLAUDE_CODE_VERSION" && break
            else
              curl -fsSL https://claude.ai/install.sh | bash -s -- "$CLAUDE_CODE_VERSION" && break
            fi
@ -141,6 +144,14 @@ runs:
            echo "Installation failed, retrying..."
            sleep 5
          done
+
+          # Add to PATH and validate installation
+          echo "$HOME/.local/bin" >> "$GITHUB_PATH"
+          export PATH="$HOME/.local/bin:$PATH"
+          if ! command -v claude &> /dev/null; then
+            echo "Installation failed: claude binary not found in PATH"
+            exit 1
+          fi
          echo "Claude Code installed successfully"
        else
          echo "Using custom Claude Code executable: $PATH_TO_CLAUDE_CODE_EXECUTABLE"
@ -202,14 +213,3 @@ runs:
        ANTHROPIC_DEFAULT_SONNET_MODEL: ${{ env.ANTHROPIC_DEFAULT_SONNET_MODEL }}
        ANTHROPIC_DEFAULT_HAIKU_MODEL: ${{ env.ANTHROPIC_DEFAULT_HAIKU_MODEL }}
        ANTHROPIC_DEFAULT_OPUS_MODEL: ${{ env.ANTHROPIC_DEFAULT_OPUS_MODEL }}
-
-        # Telemetry configuration
-        CLAUDE_CODE_ENABLE_TELEMETRY: ${{ env.CLAUDE_CODE_ENABLE_TELEMETRY }}
-        OTEL_METRICS_EXPORTER: ${{ env.OTEL_METRICS_EXPORTER }}
-        OTEL_LOGS_EXPORTER: ${{ env.OTEL_LOGS_EXPORTER }}
-        OTEL_EXPORTER_OTLP_PROTOCOL: ${{ env.OTEL_EXPORTER_OTLP_PROTOCOL }}
-        OTEL_EXPORTER_OTLP_ENDPOINT: ${{ env.OTEL_EXPORTER_OTLP_ENDPOINT }}
-        OTEL_EXPORTER_OTLP_HEADERS: ${{ env.OTEL_EXPORTER_OTLP_HEADERS }}
-        OTEL_METRIC_EXPORT_INTERVAL: ${{ env.OTEL_METRIC_EXPORT_INTERVAL }}
-        OTEL_LOGS_EXPORT_INTERVAL: ${{ env.OTEL_LOGS_EXPORT_INTERVAL }}
-        OTEL_RESOURCE_ATTRIBUTES: ${{ env.OTEL_RESOURCE_ATTRIBUTES }}
--- a/base-action/bun.lock
+++ b/base-action/bun.lock
@ -1,12 +1,11 @@
 {
  "lockfileVersion": 1,
-  "configVersion": 0,
  "workspaces": {
    "": {
      "name": "@anthropic-ai/claude-code-base-action",
      "dependencies": {
        "@actions/core": "^1.10.1",
-        "@anthropic-ai/claude-agent-sdk": "^0.2.123",
+        "@anthropic-ai/claude-agent-sdk": "^0.1.52",
        "shell-quote": "^1.8.3",
      },
      "devDependencies": {
@ -27,33 +26,39 @@

    "@actions/io": ["@actions/io@1.1.3", "", {}, "sha512-wi9JjgKLYS7U/z8PPbco+PvTb/nRWjeoFlJ1Qer83k/3C5PHQi28hiVdeE2kHXmIL99mQFawx8qt/JPjZilJ8Q=="],

-    "@anthropic-ai/claude-agent-sdk": ["@anthropic-ai/claude-agent-sdk@0.2.123", "", { "dependencies": { "@anthropic-ai/sdk": "^0.81.0", "@modelcontextprotocol/sdk": "^1.29.0" }, "optionalDependencies": { "@anthropic-ai/claude-agent-sdk-darwin-arm64": "0.2.123", "@anthropic-ai/claude-agent-sdk-darwin-x64": "0.2.123", "@anthropic-ai/claude-agent-sdk-linux-arm64": "0.2.123", "@anthropic-ai/claude-agent-sdk-linux-arm64-musl": "0.2.123", "@anthropic-ai/claude-agent-sdk-linux-x64": "0.2.123", "@anthropic-ai/claude-agent-sdk-linux-x64-musl": "0.2.123", "@anthropic-ai/claude-agent-sdk-win32-arm64": "0.2.123", "@anthropic-ai/claude-agent-sdk-win32-x64": "0.2.123" }, "peerDependencies": { "zod": "^4.0.0" } }, "sha512-a4TysYoR9DBdkM9Uwh4J5ub7TwKmRPe5hFiWh4En+IKC+qkk5UFkxFM22c//cZjYZKynHX0ah2t6LUqb+najYA=="],
-
-    "@anthropic-ai/claude-agent-sdk-darwin-arm64": ["@anthropic-ai/claude-agent-sdk-darwin-arm64@0.2.123", "", { "os": "darwin", "cpu": "arm64" }, "sha512-tYAXCjlXZQklsUs0J//gip3fZQRzhlH5OCgvNXV70qe7A1iiwHqO2KPGvEHV1L+deEKQoMZmTaCOrQpN6zju3w=="],
-
-    "@anthropic-ai/claude-agent-sdk-darwin-x64": ["@anthropic-ai/claude-agent-sdk-darwin-x64@0.2.123", "", { "os": "darwin", "cpu": "x64" }, "sha512-AcUC6sTon6z6HculP87KsAOeTMRLBwpovdhcXUTjXUpo/8nplJ7lBEzWjZCHt8FF1KuN/WBy1Z4bDg/59TQDmA=="],
-
-    "@anthropic-ai/claude-agent-sdk-linux-arm64": ["@anthropic-ai/claude-agent-sdk-linux-arm64@0.2.123", "", { "os": "linux", "cpu": "arm64" }, "sha512-7+GnbcF3/aZ8RJ1WmU/ogtPsOpknBAoUPer90MvZuFYBLPT9iI/U7f24gjrOHuYdcbDA5n7jFlhcfIO26F5DJQ=="],
-
-    "@anthropic-ai/claude-agent-sdk-linux-arm64-musl": ["@anthropic-ai/claude-agent-sdk-linux-arm64-musl@0.2.123", "", { "os": "linux", "cpu": "arm64" }, "sha512-bYgRiaf2q+yVbGAoUluuhqrEW1zexL34+3HDmK9DneKXa2K2EJpw4M6Sq4XoBD/JezGaemoAP78Xv/M/QUS1OQ=="],
-
-    "@anthropic-ai/claude-agent-sdk-linux-x64": ["@anthropic-ai/claude-agent-sdk-linux-x64@0.2.123", "", { "os": "linux", "cpu": "x64" }, "sha512-Xi+Rwk8uP5vWEnawJOlsk179fr0ATLl5J90MlbLj+puKaX5svEq8ljS+P3zq6zHTJeKh9GKLzPf7bc5YJKwcew=="],
-
-    "@anthropic-ai/claude-agent-sdk-linux-x64-musl": ["@anthropic-ai/claude-agent-sdk-linux-x64-musl@0.2.123", "", { "os": "linux", "cpu": "x64" }, "sha512-IX95lFKhmmndY/YPfWPsVV+C3rLYJmuuq5wCS53p6jYIkCMxH1iGfhBGF1EUWcXO4Uc8yqXFmQ3aaxMzOOPrwA=="],
-
-    "@anthropic-ai/claude-agent-sdk-win32-arm64": ["@anthropic-ai/claude-agent-sdk-win32-arm64@0.2.123", "", { "os": "win32", "cpu": "arm64" }, "sha512-WDZmAQG1rOiqNLZlSXaCjSWmqJvLk2io+vFQWWqSy2b5HCk9pa3PadLiaLztiihyk81wPhH9Q/44kOxdyfEGMw=="],
-
-    "@anthropic-ai/claude-agent-sdk-win32-x64": ["@anthropic-ai/claude-agent-sdk-win32-x64@0.2.123", "", { "os": "win32", "cpu": "x64" }, "sha512-588xrd1i6d4kXQ6FqwL+cgBiN4evRQSi5DCtPa02CZ3VEbuVQBeFlyPlD8tfWtNNeGZ4NM8kjPNNzZz5omezPA=="],
-
-    "@anthropic-ai/sdk": ["@anthropic-ai/sdk@0.81.0", "", { "dependencies": { "json-schema-to-ts": "^3.1.1" }, "peerDependencies": { "zod": "^3.25.0 || ^4.0.0" }, "optionalPeers": ["zod"], "bin": { "anthropic-ai-sdk": "bin/cli" } }, "sha512-D4K5PvEV6wPiRtVlVsJHIUhHAmOZ6IT/I9rKlTf84gR7GyyAurPJK7z9BOf/AZqC5d1DhYQGJNKRmV+q8dGhgw=="],
-
-    "@babel/runtime": ["@babel/runtime@7.29.2", "", {}, "sha512-JiDShH45zKHWyGe4ZNVRrCjBz8Nh9TMmZG1kh4QTK8hCBTWBi8Da+i7s1fJw7/lYpM4ccepSNfqzZ/QvABBi5g=="],
+    "@anthropic-ai/claude-agent-sdk": ["@anthropic-ai/claude-agent-sdk@0.1.52", "", { "optionalDependencies": { "@img/sharp-darwin-arm64": "^0.33.5", "@img/sharp-darwin-x64": "^0.33.5", "@img/sharp-linux-arm": "^0.33.5", "@img/sharp-linux-arm64": "^0.33.5", "@img/sharp-linux-x64": "^0.33.5", "@img/sharp-linuxmusl-arm64": "^0.33.5", "@img/sharp-linuxmusl-x64": "^0.33.5", "@img/sharp-win32-x64": "^0.33.5" }, "peerDependencies": { "zod": "^3.24.1" } }, "sha512-yF8N05+9NRbqYA/h39jQ726HTQFrdXXp7pEfDNKIJ2c4FdWvEjxBA/8ciZIebN6/PyvGDcbEp3yq2Co4rNpg6A=="],

    "@fastify/busboy": ["@fastify/busboy@2.1.1", "", {}, "sha512-vBZP4NlzfOlerQTnba4aqZoMhE/a9HY7HRqoOPaETQcSQuWEIyZMHGfVu6w9wGtGK5fED5qRs2DteVCjOH60sA=="],

-    "@hono/node-server": ["@hono/node-server@1.19.11", "", { "peerDependencies": { "hono": "^4" } }, "sha512-dr8/3zEaB+p0D2n/IUrlPF1HZm586qgJNXK1a9fhg/PzdtkK7Ksd5l312tJX2yBuALqDYBlG20QEbayqPyxn+g=="],
+    "@img/sharp-darwin-arm64": ["@img/sharp-darwin-arm64@0.33.5", "", { "optionalDependencies": { "@img/sharp-libvips-darwin-arm64": "1.0.4" }, "os": "darwin", "cpu": "arm64" }, "sha512-UT4p+iz/2H4twwAoLCqfA9UH5pI6DggwKEGuaPy7nCVQ8ZsiY5PIcrRvD1DzuY3qYL07NtIQcWnBSY/heikIFQ=="],

-    "@modelcontextprotocol/sdk": ["@modelcontextprotocol/sdk@1.29.0", "", { "dependencies": { "@hono/node-server": "^1.19.9", "ajv": "^8.17.1", "ajv-formats": "^3.0.1", "content-type": "^1.0.5", "cors": "^2.8.5", "cross-spawn": "^7.0.5", "eventsource": "^3.0.2", "eventsource-parser": "^3.0.0", "express": "^5.2.1", "express-rate-limit": "^8.2.1", "hono": "^4.11.4", "jose": "^6.1.3", "json-schema-typed": "^8.0.2", "pkce-challenge": "^5.0.0", "raw-body": "^3.0.0", "zod": "^3.25 || ^4.0", "zod-to-json-schema": "^3.25.1" }, "peerDependencies": { "@cfworker/json-schema": "^4.1.1" }, "optionalPeers": ["@cfworker/json-schema"] }, "sha512-zo37mZA9hJWpULgkRpowewez1y6ML5GsXJPY8FI0tBBCd77HEvza4jDqRKOXgHNn867PVGCyTdzqpz0izu5ZjQ=="],
+    "@img/sharp-darwin-x64": ["@img/sharp-darwin-x64@0.33.5", "", { "optionalDependencies": { "@img/sharp-libvips-darwin-x64": "1.0.4" }, "os": "darwin", "cpu": "x64" }, "sha512-fyHac4jIc1ANYGRDxtiqelIbdWkIuQaI84Mv45KvGRRxSAa7o7d1ZKAOBaYbnepLC1WqxfpimdeWfvqqSGwR2Q=="],
+
+    "@img/sharp-libvips-darwin-arm64": ["@img/sharp-libvips-darwin-arm64@1.0.4", "", { "os": "darwin", "cpu": "arm64" }, "sha512-XblONe153h0O2zuFfTAbQYAX2JhYmDHeWikp1LM9Hul9gVPjFY427k6dFEcOL72O01QxQsWi761svJ/ev9xEDg=="],
+
+    "@img/sharp-libvips-darwin-x64": ["@img/sharp-libvips-darwin-x64@1.0.4", "", { "os": "darwin", "cpu": "x64" }, "sha512-xnGR8YuZYfJGmWPvmlunFaWJsb9T/AO2ykoP3Fz/0X5XV2aoYBPkX6xqCQvUTKKiLddarLaxpzNe+b1hjeWHAQ=="],
+
+    "@img/sharp-libvips-linux-arm": ["@img/sharp-libvips-linux-arm@1.0.5", "", { "os": "linux", "cpu": "arm" }, "sha512-gvcC4ACAOPRNATg/ov8/MnbxFDJqf/pDePbBnuBDcjsI8PssmjoKMAz4LtLaVi+OnSb5FK/yIOamqDwGmXW32g=="],
+
+    "@img/sharp-libvips-linux-arm64": ["@img/sharp-libvips-linux-arm64@1.0.4", "", { "os": "linux", "cpu": "arm64" }, "sha512-9B+taZ8DlyyqzZQnoeIvDVR/2F4EbMepXMc/NdVbkzsJbzkUjhXv/70GQJ7tdLA4YJgNP25zukcxpX2/SueNrA=="],
+
+    "@img/sharp-libvips-linux-x64": ["@img/sharp-libvips-linux-x64@1.0.4", "", { "os": "linux", "cpu": "x64" }, "sha512-MmWmQ3iPFZr0Iev+BAgVMb3ZyC4KeFc3jFxnNbEPas60e1cIfevbtuyf9nDGIzOaW9PdnDciJm+wFFaTlj5xYw=="],
+
+    "@img/sharp-libvips-linuxmusl-arm64": ["@img/sharp-libvips-linuxmusl-arm64@1.0.4", "", { "os": "linux", "cpu": "arm64" }, "sha512-9Ti+BbTYDcsbp4wfYib8Ctm1ilkugkA/uscUn6UXK1ldpC1JjiXbLfFZtRlBhjPZ5o1NCLiDbg8fhUPKStHoTA=="],
+
+    "@img/sharp-libvips-linuxmusl-x64": ["@img/sharp-libvips-linuxmusl-x64@1.0.4", "", { "os": "linux", "cpu": "x64" }, "sha512-viYN1KX9m+/hGkJtvYYp+CCLgnJXwiQB39damAO7WMdKWlIhmYTfHjwSbQeUK/20vY154mwezd9HflVFM1wVSw=="],
+
+    "@img/sharp-linux-arm": ["@img/sharp-linux-arm@0.33.5", "", { "optionalDependencies": { "@img/sharp-libvips-linux-arm": "1.0.5" }, "os": "linux", "cpu": "arm" }, "sha512-JTS1eldqZbJxjvKaAkxhZmBqPRGmxgu+qFKSInv8moZ2AmT5Yib3EQ1c6gp493HvrvV8QgdOXdyaIBrhvFhBMQ=="],
+
+    "@img/sharp-linux-arm64": ["@img/sharp-linux-arm64@0.33.5", "", { "optionalDependencies": { "@img/sharp-libvips-linux-arm64": "1.0.4" }, "os": "linux", "cpu": "arm64" }, "sha512-JMVv+AMRyGOHtO1RFBiJy/MBsgz0x4AWrT6QoEVVTyh1E39TrCUpTRI7mx9VksGX4awWASxqCYLCV4wBZHAYxA=="],
+
+    "@img/sharp-linux-x64": ["@img/sharp-linux-x64@0.33.5", "", { "optionalDependencies": { "@img/sharp-libvips-linux-x64": "1.0.4" }, "os": "linux", "cpu": "x64" }, "sha512-opC+Ok5pRNAzuvq1AG0ar+1owsu842/Ab+4qvU879ippJBHvyY5n2mxF1izXqkPYlGuP/M556uh53jRLJmzTWA=="],
+
+    "@img/sharp-linuxmusl-arm64": ["@img/sharp-linuxmusl-arm64@0.33.5", "", { "optionalDependencies": { "@img/sharp-libvips-linuxmusl-arm64": "1.0.4" }, "os": "linux", "cpu": "arm64" }, "sha512-XrHMZwGQGvJg2V/oRSUfSAfjfPxO+4DkiRh6p2AFjLQztWUuY/o8Mq0eMQVIY7HJ1CDQUJlxGGZRw1a5bqmd1g=="],
+
+    "@img/sharp-linuxmusl-x64": ["@img/sharp-linuxmusl-x64@0.33.5", "", { "optionalDependencies": { "@img/sharp-libvips-linuxmusl-x64": "1.0.4" }, "os": "linux", "cpu": "x64" }, "sha512-WT+d/cgqKkkKySYmqoZ8y3pxx7lx9vVejxW/W4DOFMYVSkErR+w7mf2u8m/y4+xHe7yY9DAXQMWQhpnMuFfScw=="],
+
+    "@img/sharp-win32-x64": ["@img/sharp-win32-x64@0.33.5", "", { "os": "win32", "cpu": "x64" }, "sha512-MpY/o8/8kj+EcnxwvrP4aTJSWw/aZ7JIGR4aBeZkZw5B7/Jn+tY9/VNwtcoGmdT7GfggGIU4kygOMSbYnOrAbg=="],

    "@types/bun": ["@types/bun@1.2.19", "", { "dependencies": { "bun-types": "1.2.19" } }, "sha512-d9ZCmrH3CJ2uYKXQIUuZ/pUnTqIvLDS0SK7pFmbx8ma+ziH/FRMoAq5bYpRG7y+w1gl+HgyNZbtqgMq4W4e2Lg=="],

@ -63,202 +68,22 @@

    "@types/shell-quote": ["@types/shell-quote@1.7.5", "", {}, "sha512-+UE8GAGRPbJVQDdxi16dgadcBfQ+KG2vgZhV1+3A1XmHbmwcdwhCUwIdy+d3pAGrbvgRoVSjeI9vOWyq376Yzw=="],

-    "accepts": ["accepts@2.0.0", "", { "dependencies": { "mime-types": "^3.0.0", "negotiator": "^1.0.0" } }, "sha512-5cvg6CtKwfgdmVqY1WIiXKc3Q1bkRqGLi+2W/6ao+6Y7gu/RCwRuAhGEzh5B4KlszSuTLgZYuqFqo5bImjNKng=="],
-
-    "ajv": ["ajv@8.18.0", "", { "dependencies": { "fast-deep-equal": "^3.1.3", "fast-uri": "^3.0.1", "json-schema-traverse": "^1.0.0", "require-from-string": "^2.0.2" } }, "sha512-PlXPeEWMXMZ7sPYOHqmDyCJzcfNrUr3fGNKtezX14ykXOEIvyK81d+qydx89KY5O71FKMPaQ2vBfBFI5NHR63A=="],
-
-    "ajv-formats": ["ajv-formats@3.0.1", "", { "dependencies": { "ajv": "^8.0.0" } }, "sha512-8iUql50EUR+uUcdRQ3HDqa6EVyo3docL8g5WJ3FNcWmu62IbkGUue/pEyLBW8VGKKucTPgqeks4fIU1DA4yowQ=="],
-
-    "body-parser": ["body-parser@2.2.2", "", { "dependencies": { "bytes": "^3.1.2", "content-type": "^1.0.5", "debug": "^4.4.3", "http-errors": "^2.0.0", "iconv-lite": "^0.7.0", "on-finished": "^2.4.1", "qs": "^6.14.1", "raw-body": "^3.0.1", "type-is": "^2.0.1" } }, "sha512-oP5VkATKlNwcgvxi0vM0p/D3n2C3EReYVX+DNYs5TjZFn/oQt2j+4sVJtSMr18pdRr8wjTcBl6LoV+FUwzPmNA=="],
-
    "bun-types": ["bun-types@1.2.19", "", { "dependencies": { "@types/node": "*" }, "peerDependencies": { "@types/react": "^19" } }, "sha512-uAOTaZSPuYsWIXRpj7o56Let0g/wjihKCkeRqUBhlLVM/Bt+Fj9xTo+LhC1OV1XDaGkz4hNC80et5xgy+9KTHQ=="],

-    "bytes": ["bytes@3.1.2", "", {}, "sha512-/Nf7TyzTx6S3yRJObOAV7956r8cr2+Oj8AC5dt8wSP3BQAoeX58NoHyCU8P8zGkNXStjTSi6fzO6F0pBdcYbEg=="],
-
-    "call-bind-apply-helpers": ["call-bind-apply-helpers@1.0.2", "", { "dependencies": { "es-errors": "^1.3.0", "function-bind": "^1.1.2" } }, "sha512-Sp1ablJ0ivDkSzjcaJdxEunN5/XvksFJ2sMBFfq6x0ryhQV/2b/KwFe21cMpmHtPOSij8K99/wSfoEuTObmuMQ=="],
-
-    "call-bound": ["call-bound@1.0.4", "", { "dependencies": { "call-bind-apply-helpers": "^1.0.2", "get-intrinsic": "^1.3.0" } }, "sha512-+ys997U96po4Kx/ABpBCqhA9EuxJaQWDQg7295H4hBphv3IZg0boBKuwYpt4YXp6MZ5AmZQnU/tyMTlRpaSejg=="],
-
-    "content-disposition": ["content-disposition@1.0.1", "", {}, "sha512-oIXISMynqSqm241k6kcQ5UwttDILMK4BiurCfGEREw6+X9jkkpEe5T9FZaApyLGGOnFuyMWZpdolTXMtvEJ08Q=="],
-
-    "content-type": ["content-type@1.0.5", "", {}, "sha512-nTjqfcBFEipKdXCv4YDQWCfmcLZKm81ldF0pAopTvyrFGVbcR6P/VAAd5G7N+0tTr8QqiU0tFadD6FK4NtJwOA=="],
-
-    "cookie": ["cookie@0.7.2", "", {}, "sha512-yki5XnKuf750l50uGTllt6kKILY4nQ1eNIQatoXEByZ5dWgnKqbnqmTrBE5B4N7lrMJKQ2ytWMiTO2o0v6Ew/w=="],
-
-    "cookie-signature": ["cookie-signature@1.2.2", "", {}, "sha512-D76uU73ulSXrD1UXF4KE2TMxVVwhsnCgfAyTg9k8P6KGZjlXKrOLe4dJQKI3Bxi5wjesZoFXJWElNWBjPZMbhg=="],
-
-    "cors": ["cors@2.8.6", "", { "dependencies": { "object-assign": "^4", "vary": "^1" } }, "sha512-tJtZBBHA6vjIAaF6EnIaq6laBBP9aq/Y3ouVJjEfoHbRBcHBAHYcMh/w8LDrk2PvIMMq8gmopa5D4V8RmbrxGw=="],
-
-    "cross-spawn": ["cross-spawn@7.0.6", "", { "dependencies": { "path-key": "^3.1.0", "shebang-command": "^2.0.0", "which": "^2.0.1" } }, "sha512-uV2QOWP2nWzsy2aMp8aRibhi9dlzF5Hgh5SHaB9OiTGEyDTiJJyx0uy51QXdyWbtAHNua4XJzUKca3OzKUd3vA=="],
-
    "csstype": ["csstype@3.1.3", "", {}, "sha512-M1uQkMl8rQK/szD0LNhtqxIPLpimGm8sOBwU7lLnCpSbTyY3yeU1Vc7l4KT5zT4s/yOxHH5O7tIuuLOCnLADRw=="],

-    "debug": ["debug@4.4.3", "", { "dependencies": { "ms": "^2.1.3" } }, "sha512-RGwwWnwQvkVfavKVt22FGLw+xYSdzARwm0ru6DhTVA3umU5hZc28V3kO4stgYryrTlLpuvgI9GiijltAjNbcqA=="],
-
-    "depd": ["depd@2.0.0", "", {}, "sha512-g7nH6P6dyDioJogAAGprGpCtVImJhpPk/roCzdb3fIh61/s/nPsfR6onyMwkCAR/OlC3yBC0lESvUoQEAssIrw=="],
-
-    "dunder-proto": ["dunder-proto@1.0.1", "", { "dependencies": { "call-bind-apply-helpers": "^1.0.1", "es-errors": "^1.3.0", "gopd": "^1.2.0" } }, "sha512-KIN/nDJBQRcXw0MLVhZE9iQHmG68qAVIBg9CqmUYjmQIhgij9U5MFvrqkUL5FbtyyzZuOeOt0zdeRe4UY7ct+A=="],
-
-    "ee-first": ["ee-first@1.1.1", "", {}, "sha512-WMwm9LhRUo+WUaRN+vRuETqG89IgZphVSNkdFgeb6sS/E4OrDIN7t48CAewSHXc6C8lefD8KKfr5vY61brQlow=="],
-
-    "encodeurl": ["encodeurl@2.0.0", "", {}, "sha512-Q0n9HRi4m6JuGIV1eFlmvJB7ZEVxu93IrMyiMsGC0lrMJMWzRgx6WGquyfQgZVb31vhGgXnfmPNNXmxnOkRBrg=="],
-
-    "es-define-property": ["es-define-property@1.0.1", "", {}, "sha512-e3nRfgfUZ4rNGL232gUgX06QNyyez04KdjFrF+LTRoOXmrOgFKDg4BCdsjW8EnT69eqdYGmRpJwiPVYNrCaW3g=="],
-
-    "es-errors": ["es-errors@1.3.0", "", {}, "sha512-Zf5H2Kxt2xjTvbJvP2ZWLEICxA6j+hAmMzIlypy4xcBg1vKVnx89Wy0GbS+kf5cwCVFFzdCFh2XSCFNULS6csw=="],
-
-    "es-object-atoms": ["es-object-atoms@1.1.1", "", { "dependencies": { "es-errors": "^1.3.0" } }, "sha512-FGgH2h8zKNim9ljj7dankFPcICIK9Cp5bm+c2gQSYePhpaG5+esrLODihIorn+Pe6FGJzWhXQotPv73jTaldXA=="],
-
-    "escape-html": ["escape-html@1.0.3", "", {}, "sha512-NiSupZ4OeuGwr68lGIeym/ksIZMJodUGOSCZ/FSnTxcrekbvqrgdUxlJOMpijaKZVjAJrWrGs/6Jy8OMuyj9ow=="],
-
-    "etag": ["etag@1.8.1", "", {}, "sha512-aIL5Fx7mawVa300al2BnEE4iNvo1qETxLrPI/o05L7z6go7fCw1J6EQmbK4FmJ2AS7kgVF/KEZWufBfdClMcPg=="],
-
-    "eventsource": ["eventsource@3.0.7", "", { "dependencies": { "eventsource-parser": "^3.0.1" } }, "sha512-CRT1WTyuQoD771GW56XEZFQ/ZoSfWid1alKGDYMmkt2yl8UXrVR4pspqWNEcqKvVIzg6PAltWjxcSSPrboA4iA=="],
-
-    "eventsource-parser": ["eventsource-parser@3.0.6", "", {}, "sha512-Vo1ab+QXPzZ4tCa8SwIHJFaSzy4R6SHf7BY79rFBDf0idraZWAkYrDjDj8uWaSm3S2TK+hJ7/t1CEmZ7jXw+pg=="],
-
-    "express": ["express@5.2.1", "", { "dependencies": { "accepts": "^2.0.0", "body-parser": "^2.2.1", "content-disposition": "^1.0.0", "content-type": "^1.0.5", "cookie": "^0.7.1", "cookie-signature": "^1.2.1", "debug": "^4.4.0", "depd": "^2.0.0", "encodeurl": "^2.0.0", "escape-html": "^1.0.3", "etag": "^1.8.1", "finalhandler": "^2.1.0", "fresh": "^2.0.0", "http-errors": "^2.0.0", "merge-descriptors": "^2.0.0", "mime-types": "^3.0.0", "on-finished": "^2.4.1", "once": "^1.4.0", "parseurl": "^1.3.3", "proxy-addr": "^2.0.7", "qs": "^6.14.0", "range-parser": "^1.2.1", "router": "^2.2.0", "send": "^1.1.0", "serve-static": "^2.2.0", "statuses": "^2.0.1", "type-is": "^2.0.1", "vary": "^1.1.2" } }, "sha512-hIS4idWWai69NezIdRt2xFVofaF4j+6INOpJlVOLDO8zXGpUVEVzIYk12UUi2JzjEzWL3IOAxcTubgz9Po0yXw=="],
-
-    "express-rate-limit": ["express-rate-limit@8.3.1", "", { "dependencies": { "ip-address": "10.1.0" }, "peerDependencies": { "express": ">= 4.11" } }, "sha512-D1dKN+cmyPWuvB+G2SREQDzPY1agpBIcTa9sJxOPMCNeH3gwzhqJRDWCXW3gg0y//+LQ/8j52JbMROWyrKdMdw=="],
-
-    "fast-deep-equal": ["fast-deep-equal@3.1.3", "", {}, "sha512-f3qQ9oQy9j2AhBe/H9VC91wLmKBCCU/gDOnKNAYG5hswO7BLKj09Hc5HYNz9cGI++xlpDCIgDaitVs03ATR84Q=="],
-
-    "fast-uri": ["fast-uri@3.1.0", "", {}, "sha512-iPeeDKJSWf4IEOasVVrknXpaBV0IApz/gp7S2bb7Z4Lljbl2MGJRqInZiUrQwV16cpzw/D3S5j5Julj/gT52AA=="],
-
-    "finalhandler": ["finalhandler@2.1.1", "", { "dependencies": { "debug": "^4.4.0", "encodeurl": "^2.0.0", "escape-html": "^1.0.3", "on-finished": "^2.4.1", "parseurl": "^1.3.3", "statuses": "^2.0.1" } }, "sha512-S8KoZgRZN+a5rNwqTxlZZePjT/4cnm0ROV70LedRHZ0p8u9fRID0hJUZQpkKLzro8LfmC8sx23bY6tVNxv8pQA=="],
-
-    "forwarded": ["forwarded@0.2.0", "", {}, "sha512-buRG0fpBtRHSTCOASe6hD258tEubFoRLb4ZNA6NxMVHNw2gOcwHo9wyablzMzOA5z9xA9L1KNjk/Nt6MT9aYow=="],
-
-    "fresh": ["fresh@2.0.0", "", {}, "sha512-Rx/WycZ60HOaqLKAi6cHRKKI7zxWbJ31MhntmtwMoaTeF7XFH9hhBp8vITaMidfljRQ6eYWCKkaTK+ykVJHP2A=="],
-
-    "function-bind": ["function-bind@1.1.2", "", {}, "sha512-7XHNxH7qX9xG5mIwxkhumTox/MIRNcOgDrxWsMt2pAr23WHp6MrRlN7FBSFpCpr+oVO0F744iUgR82nJMfG2SA=="],
-
-    "get-intrinsic": ["get-intrinsic@1.3.0", "", { "dependencies": { "call-bind-apply-helpers": "^1.0.2", "es-define-property": "^1.0.1", "es-errors": "^1.3.0", "es-object-atoms": "^1.1.1", "function-bind": "^1.1.2", "get-proto": "^1.0.1", "gopd": "^1.2.0", "has-symbols": "^1.1.0", "hasown": "^2.0.2", "math-intrinsics": "^1.1.0" } }, "sha512-9fSjSaos/fRIVIp+xSJlE6lfwhES7LNtKaCBIamHsjr2na1BiABJPo0mOjjz8GJDURarmCPGqaiVg5mfjb98CQ=="],
-
-    "get-proto": ["get-proto@1.0.1", "", { "dependencies": { "dunder-proto": "^1.0.1", "es-object-atoms": "^1.0.0" } }, "sha512-sTSfBjoXBp89JvIKIefqw7U2CCebsc74kiY6awiGogKtoSGbgjYE/G/+l9sF3MWFPNc9IcoOC4ODfKHfxFmp0g=="],
-
-    "gopd": ["gopd@1.2.0", "", {}, "sha512-ZUKRh6/kUFoAiTAtTYPZJ3hw9wNxx+BIBOijnlG9PnrJsCcSjs1wyyD6vJpaYtgnzDrKYRSqf3OO6Rfa93xsRg=="],
-
-    "has-symbols": ["has-symbols@1.1.0", "", {}, "sha512-1cDNdwJ2Jaohmb3sg4OmKaMBwuC48sYni5HUw2DvsC8LjGTLK9h+eb1X6RyuOHe4hT0ULCW68iomhjUoKUqlPQ=="],
-
-    "hasown": ["hasown@2.0.2", "", { "dependencies": { "function-bind": "^1.1.2" } }, "sha512-0hJU9SCPvmMzIBdZFqNPXWa6dqh7WdH0cII9y+CyS8rG3nL48Bclra9HmKhVVUHyPWNH5Y7xDwAB7bfgSjkUMQ=="],
-
-    "hono": ["hono@4.12.9", "", {}, "sha512-wy3T8Zm2bsEvxKZM5w21VdHDDcwVS1yUFFY6i8UobSsKfFceT7TOwhbhfKsDyx7tYQlmRM5FLpIuYvNFyjctiA=="],
-
-    "http-errors": ["http-errors@2.0.1", "", { "dependencies": { "depd": "~2.0.0", "inherits": "~2.0.4", "setprototypeof": "~1.2.0", "statuses": "~2.0.2", "toidentifier": "~1.0.1" } }, "sha512-4FbRdAX+bSdmo4AUFuS0WNiPz8NgFt+r8ThgNWmlrjQjt1Q7ZR9+zTlce2859x4KSXrwIsaeTqDoKQmtP8pLmQ=="],
-
-    "iconv-lite": ["iconv-lite@0.7.2", "", { "dependencies": { "safer-buffer": ">= 2.1.2 < 3.0.0" } }, "sha512-im9DjEDQ55s9fL4EYzOAv0yMqmMBSZp6G0VvFyTMPKWxiSBHUj9NW/qqLmXUwXrrM7AvqSlTCfvqRb0cM8yYqw=="],
-
-    "inherits": ["inherits@2.0.4", "", {}, "sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ=="],
-
-    "ip-address": ["ip-address@10.1.0", "", {}, "sha512-XXADHxXmvT9+CRxhXg56LJovE+bmWnEWB78LB83VZTprKTmaC5QfruXocxzTZ2Kl0DNwKuBdlIhjL8LeY8Sf8Q=="],
-
-    "ipaddr.js": ["ipaddr.js@1.9.1", "", {}, "sha512-0KI/607xoxSToH7GjN1FfSbLoU0+btTicjsQSWQlh/hZykN8KpmMf7uYwPW3R+akZ6R/w18ZlXSHBYXiYUPO3g=="],
-
-    "is-promise": ["is-promise@4.0.0", "", {}, "sha512-hvpoI6korhJMnej285dSg6nu1+e6uxs7zG3BYAm5byqDsgJNWwxzM6z6iZiAgQR4TJ30JmBTOwqZUw3WlyH3AQ=="],
-
-    "isexe": ["isexe@2.0.0", "", {}, "sha512-RHxMLp9lnKHGHRng9QFhRCMbYAcVpn69smSGcq3f36xjgVVWThj4qqLbTLlq7Ssj8B+fIQ1EuCEGI2lKsyQeIw=="],
-
-    "jose": ["jose@6.2.2", "", {}, "sha512-d7kPDd34KO/YnzaDOlikGpOurfF0ByC2sEV4cANCtdqLlTfBlw2p14O/5d/zv40gJPbIQxfES3nSx1/oYNyuZQ=="],
-
-    "json-schema-to-ts": ["json-schema-to-ts@3.1.1", "", { "dependencies": { "@babel/runtime": "^7.18.3", "ts-algebra": "^2.0.0" } }, "sha512-+DWg8jCJG2TEnpy7kOm/7/AxaYoaRbjVB4LFZLySZlWn8exGs3A4OLJR966cVvU26N7X9TWxl+Jsw7dzAqKT6g=="],
-
-    "json-schema-traverse": ["json-schema-traverse@1.0.0", "", {}, "sha512-NM8/P9n3XjXhIZn1lLhkFaACTOURQXjWhV4BA/RnOv8xvgqtqpAX9IO4mRQxSx1Rlo4tqzeqb0sOlruaOy3dug=="],
-
-    "json-schema-typed": ["json-schema-typed@8.0.2", "", {}, "sha512-fQhoXdcvc3V28x7C7BMs4P5+kNlgUURe2jmUT1T//oBRMDrqy1QPelJimwZGo7Hg9VPV3EQV5Bnq4hbFy2vetA=="],
-
-    "math-intrinsics": ["math-intrinsics@1.1.0", "", {}, "sha512-/IXtbwEk5HTPyEwyKX6hGkYXxM9nbj64B+ilVJnC/R6B0pH5G4V3b0pVbL7DBj4tkhBAppbQUlf6F6Xl9LHu1g=="],
-
-    "media-typer": ["media-typer@1.1.0", "", {}, "sha512-aisnrDP4GNe06UcKFnV5bfMNPBUw4jsLGaWwWfnH3v02GnBuXX2MCVn5RbrWo0j3pczUilYblq7fQ7Nw2t5XKw=="],
-
-    "merge-descriptors": ["merge-descriptors@2.0.0", "", {}, "sha512-Snk314V5ayFLhp3fkUREub6WtjBfPdCPY1Ln8/8munuLuiYhsABgBVWsozAG+MWMbVEvcdcpbi9R7ww22l9Q3g=="],
-
-    "mime-db": ["mime-db@1.54.0", "", {}, "sha512-aU5EJuIN2WDemCcAp2vFBfp/m4EAhWJnUNSSw0ixs7/kXbd6Pg64EmwJkNdFhB8aWt1sH2CTXrLxo/iAGV3oPQ=="],
-
-    "mime-types": ["mime-types@3.0.2", "", { "dependencies": { "mime-db": "^1.54.0" } }, "sha512-Lbgzdk0h4juoQ9fCKXW4by0UJqj+nOOrI9MJ1sSj4nI8aI2eo1qmvQEie4VD1glsS250n15LsWsYtCugiStS5A=="],
-
-    "ms": ["ms@2.1.3", "", {}, "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA=="],
-
-    "negotiator": ["negotiator@1.0.0", "", {}, "sha512-8Ofs/AUQh8MaEcrlq5xOX0CQ9ypTF5dl78mjlMNfOK08fzpgTHQRQPBxcPlEtIw0yRpws+Zo/3r+5WRby7u3Gg=="],
-
-    "object-assign": ["object-assign@4.1.1", "", {}, "sha512-rJgTQnkUnH1sFw8yT6VSU3zD3sWmu6sZhIseY8VX+GRu3P6F7Fu+JNDoXfklElbLJSnc3FUQHVe4cU5hj+BcUg=="],
-
-    "object-inspect": ["object-inspect@1.13.4", "", {}, "sha512-W67iLl4J2EXEGTbfeHCffrjDfitvLANg0UlX3wFUUSTx92KXRFegMHUVgSqE+wvhAbi4WqjGg9czysTV2Epbew=="],
-
-    "on-finished": ["on-finished@2.4.1", "", { "dependencies": { "ee-first": "1.1.1" } }, "sha512-oVlzkg3ENAhCk2zdv7IJwd/QUD4z2RxRwpkcGY8psCVcCYZNq4wYnVWALHM+brtuJjePWiYF/ClmuDr8Ch5+kg=="],
-
-    "once": ["once@1.4.0", "", { "dependencies": { "wrappy": "1" } }, "sha512-lNaJgI+2Q5URQBkccEKHTQOPaXdUxnZZElQTZY0MFUAuaEqe1E+Nyvgdz/aIyNi6Z9MzO5dv1H8n58/GELp3+w=="],
-
-    "parseurl": ["parseurl@1.3.3", "", {}, "sha512-CiyeOxFT/JZyN5m0z9PfXw4SCBJ6Sygz1Dpl0wqjlhDEGGBP1GnsUVEL0p63hoG1fcj3fHynXi9NYO4nWOL+qQ=="],
-
-    "path-key": ["path-key@3.1.1", "", {}, "sha512-ojmeN0qd+y0jszEtoY48r0Peq5dwMEkIlCOu6Q5f41lfkswXuKtYrhgoTpLnyIcHm24Uhqx+5Tqm2InSwLhE6Q=="],
-
-    "path-to-regexp": ["path-to-regexp@8.4.0", "", {}, "sha512-PuseHIvAnz3bjrM2rGJtSgo1zjgxapTLZ7x2pjhzWwlp4SJQgK3f3iZIQwkpEnBaKz6seKBADpM4B4ySkuYypg=="],
-
-    "pkce-challenge": ["pkce-challenge@5.0.1", "", {}, "sha512-wQ0b/W4Fr01qtpHlqSqspcj3EhBvimsdh0KlHhH8HRZnMsEa0ea2fTULOXOS9ccQr3om+GcGRk4e+isrZWV8qQ=="],
-
    "prettier": ["prettier@3.5.3", "", { "bin": { "prettier": "bin/prettier.cjs" } }, "sha512-QQtaxnoDJeAkDvDKWCLiwIXkTgRhwYDEQCghU9Z6q03iyek/rxRh/2lC3HB7P8sWT2xC/y5JDctPLBIGzHKbhw=="],

-    "proxy-addr": ["proxy-addr@2.0.7", "", { "dependencies": { "forwarded": "0.2.0", "ipaddr.js": "1.9.1" } }, "sha512-llQsMLSUDUPT44jdrU/O37qlnifitDP+ZwrmmZcoSKyLKvtZxpyV0n2/bD/N4tBAAZ/gJEdZU7KMraoK1+XYAg=="],
-
-    "qs": ["qs@6.15.0", "", { "dependencies": { "side-channel": "^1.1.0" } }, "sha512-mAZTtNCeetKMH+pSjrb76NAM8V9a05I9aBZOHztWy/UqcJdQYNsf59vrRKWnojAT9Y+GbIvoTBC++CPHqpDBhQ=="],
-
-    "range-parser": ["range-parser@1.2.1", "", {}, "sha512-Hrgsx+orqoygnmhFbKaHE6c296J+HTAQXoxEF6gNupROmmGJRoyzfG3ccAveqCBrwr/2yxQ5BVd/GTl5agOwSg=="],
-
-    "raw-body": ["raw-body@3.0.2", "", { "dependencies": { "bytes": "~3.1.2", "http-errors": "~2.0.1", "iconv-lite": "~0.7.0", "unpipe": "~1.0.0" } }, "sha512-K5zQjDllxWkf7Z5xJdV0/B0WTNqx6vxG70zJE4N0kBs4LovmEYWJzQGxC9bS9RAKu3bgM40lrd5zoLJ12MQ5BA=="],
-
-    "require-from-string": ["require-from-string@2.0.2", "", {}, "sha512-Xf0nWe6RseziFMu+Ap9biiUbmplq6S9/p+7w7YXP/JBHhrUDDUhwa+vANyubuqfZWTveU//DYVGsDG7RKL/vEw=="],
-
-    "router": ["router@2.2.0", "", { "dependencies": { "debug": "^4.4.0", "depd": "^2.0.0", "is-promise": "^4.0.0", "parseurl": "^1.3.3", "path-to-regexp": "^8.0.0" } }, "sha512-nLTrUKm2UyiL7rlhapu/Zl45FwNgkZGaCpZbIHajDYgwlJCOzLSk+cIPAnsEqV955GjILJnKbdQC1nVPz+gAYQ=="],
-
-    "safer-buffer": ["safer-buffer@2.1.2", "", {}, "sha512-YZo3K82SD7Riyi0E1EQPojLz7kpepnSQI9IyPbHHg1XXXevb5dJI7tpyN2ADxGcQbHG7vcyRHk0cbwqcQriUtg=="],
-
-    "send": ["send@1.2.1", "", { "dependencies": { "debug": "^4.4.3", "encodeurl": "^2.0.0", "escape-html": "^1.0.3", "etag": "^1.8.1", "fresh": "^2.0.0", "http-errors": "^2.0.1", "mime-types": "^3.0.2", "ms": "^2.1.3", "on-finished": "^2.4.1", "range-parser": "^1.2.1", "statuses": "^2.0.2" } }, "sha512-1gnZf7DFcoIcajTjTwjwuDjzuz4PPcY2StKPlsGAQ1+YH20IRVrBaXSWmdjowTJ6u8Rc01PoYOGHXfP1mYcZNQ=="],
-
-    "serve-static": ["serve-static@2.2.1", "", { "dependencies": { "encodeurl": "^2.0.0", "escape-html": "^1.0.3", "parseurl": "^1.3.3", "send": "^1.2.0" } }, "sha512-xRXBn0pPqQTVQiC8wyQrKs2MOlX24zQ0POGaj0kultvoOCstBQM5yvOhAVSUwOMjQtTvsPWoNCHfPGwaaQJhTw=="],
-
-    "setprototypeof": ["setprototypeof@1.2.0", "", {}, "sha512-E5LDX7Wrp85Kil5bhZv46j8jOeboKq5JMmYM3gVGdGH8xFpPWXUMsNrlODCrkoxMEeNi/XZIwuRvY4XNwYMJpw=="],
-
-    "shebang-command": ["shebang-command@2.0.0", "", { "dependencies": { "shebang-regex": "^3.0.0" } }, "sha512-kHxr2zZpYtdmrN1qDjrrX/Z1rR1kG8Dx+gkpK1G4eXmvXswmcE1hTWBWYUzlraYw1/yZp6YuDY77YtvbN0dmDA=="],
-
-    "shebang-regex": ["shebang-regex@3.0.0", "", {}, "sha512-7++dFhtcx3353uBaq8DDR4NuxBetBzC7ZQOhmTQInHEd6bSrXdiEyzCvG07Z44UYdLShWUyXt5M/yhz8ekcb1A=="],
-
    "shell-quote": ["shell-quote@1.8.3", "", {}, "sha512-ObmnIF4hXNg1BqhnHmgbDETF8dLPCggZWBjkQfhZpbszZnYur5DUljTcCHii5LC3J5E0yeO/1LIMyH+UvHQgyw=="],

-    "side-channel": ["side-channel@1.1.0", "", { "dependencies": { "es-errors": "^1.3.0", "object-inspect": "^1.13.3", "side-channel-list": "^1.0.0", "side-channel-map": "^1.0.1", "side-channel-weakmap": "^1.0.2" } }, "sha512-ZX99e6tRweoUXqR+VBrslhda51Nh5MTQwou5tnUDgbtyM0dBgmhEDtWGP/xbKn6hqfPRHujUNwz5fy/wbbhnpw=="],
-
-    "side-channel-list": ["side-channel-list@1.0.0", "", { "dependencies": { "es-errors": "^1.3.0", "object-inspect": "^1.13.3" } }, "sha512-FCLHtRD/gnpCiCHEiJLOwdmFP+wzCmDEkc9y7NsYxeF4u7Btsn1ZuwgwJGxImImHicJArLP4R0yX4c2KCrMrTA=="],
-
-    "side-channel-map": ["side-channel-map@1.0.1", "", { "dependencies": { "call-bound": "^1.0.2", "es-errors": "^1.3.0", "get-intrinsic": "^1.2.5", "object-inspect": "^1.13.3" } }, "sha512-VCjCNfgMsby3tTdo02nbjtM/ewra6jPHmpThenkTYh8pG9ucZ/1P8So4u4FGBek/BjpOVsDCMoLA/iuBKIFXRA=="],
-
-    "side-channel-weakmap": ["side-channel-weakmap@1.0.2", "", { "dependencies": { "call-bound": "^1.0.2", "es-errors": "^1.3.0", "get-intrinsic": "^1.2.5", "object-inspect": "^1.13.3", "side-channel-map": "^1.0.1" } }, "sha512-WPS/HvHQTYnHisLo9McqBHOJk2FkHO/tlpvldyrnem4aeQp4hai3gythswg6p01oSoTl58rcpiFAjF2br2Ak2A=="],
-
-    "statuses": ["statuses@2.0.2", "", {}, "sha512-DvEy55V3DB7uknRo+4iOGT5fP1slR8wQohVdknigZPMpMstaKJQWhwiYBACJE3Ul2pTnATihhBYnRhZQHGBiRw=="],
-
-    "toidentifier": ["toidentifier@1.0.1", "", {}, "sha512-o5sSPKEkg/DIQNmH43V0/uerLrpzVedkUh8tGNvaeXpfpuwjKenlSox/2O/BTlZUtEe+JG7s5YhEz608PlAHRA=="],
-
-    "ts-algebra": ["ts-algebra@2.0.0", "", {}, "sha512-FPAhNPFMrkwz76P7cdjdmiShwMynZYN6SgOujD1urY4oNm80Ou9oMdmbR45LotcKOXoy7wSmHkRFE6Mxbrhefw=="],
-
    "tunnel": ["tunnel@0.0.6", "", {}, "sha512-1h/Lnq9yajKY2PEbBadPXj3VxsDDu844OnaAo52UVmIzIvwwtBPIuNvkjuzBlTWpfJyUbG3ez0KSBibQkj4ojg=="],

-    "type-is": ["type-is@2.0.1", "", { "dependencies": { "content-type": "^1.0.5", "media-typer": "^1.1.0", "mime-types": "^3.0.0" } }, "sha512-OZs6gsjF4vMp32qrCbiVSkrFmXtG/AZhY3t0iAMrMBiAZyV9oALtXO8hsrHbMXF9x6L3grlFuwW2oAz7cav+Gw=="],
-
    "typescript": ["typescript@5.8.3", "", { "bin": { "tsc": "bin/tsc", "tsserver": "bin/tsserver" } }, "sha512-p1diW6TqL9L07nNxvRMM7hMMw4c5XOo/1ibL4aAIGmSAt9slTE1Xgw5KWuof2uTOvCg9BY7ZRi+GaF+7sfgPeQ=="],

    "undici": ["undici@5.29.0", "", { "dependencies": { "@fastify/busboy": "^2.0.0" } }, "sha512-raqeBD6NQK4SkWhQzeYKd1KmIG6dllBOTt55Rmkt4HtI9mwdWtJljnrXjAFUBLTSN67HWrOIZ3EPF4kjUw80Bg=="],

    "undici-types": ["undici-types@6.21.0", "", {}, "sha512-iwDZqg0QAGrg9Rav5H4n0M64c3mkR59cJ6wQp+7C4nI0gsmExaedaYLNO44eT4AtBBwjbTiGPMlt2Md0T9H9JQ=="],

-    "unpipe": ["unpipe@1.0.0", "", {}, "sha512-pjy2bYhSsufwWlKwPc+l3cN7+wuJlK6uz0YdJEOlQDbl6jo/YlPi4mb8agUkVC8BF7V8NuzeyPNqRksA3hztKQ=="],
-
-    "vary": ["vary@1.1.2", "", {}, "sha512-BNGbWLfd0eUPabhkXUVm0j8uuvREyTh5ovRa/dyow/BqAbZJyC+5fU+IzQOzmAKzYqYRAISoRhdQr3eIZ/PXqg=="],
-
-    "which": ["which@2.0.2", "", { "dependencies": { "isexe": "^2.0.0" }, "bin": { "node-which": "./bin/node-which" } }, "sha512-BLI3Tl1TW3Pvl70l3yq3Y64i+awpwXqsGBYWkkqMtnbXgrMD+yj7rhW0kuEDxzJaYXGjEW5ogapKNMEKNMjibA=="],
-
-    "wrappy": ["wrappy@1.0.2", "", {}, "sha512-l4Sp/DRseor9wL6EvV2+TuQn63dMkPjZ/sp9XkghTEbV9KlPS1xUsZ3u7/IQO4wxtcFB4bgpQPRcR3QCvezPcQ=="],
-
    "zod": ["zod@3.25.76", "", {}, "sha512-gzUt/qt81nXsFGKIFcC3YnfEAx5NkunCfnDlvuBSSFS02bcXu4Lmea0AFIUwbLWxWPx3d9p8S5QoaujKcNQxcQ=="],
-
-    "zod-to-json-schema": ["zod-to-json-schema@3.25.2", "", { "peerDependencies": { "zod": "^3.25.28 || ^4" } }, "sha512-O/PgfnpT1xKSDeQYSCfRI5Gy3hPf91mKVDuYLUHZJMiDFptvP41MSnWofm8dnCm0256ZNfZIM7DSzuSMAFnjHA=="],
  }
 }
--- a/base-action/package.json
+++ b/base-action/package.json
@ -11,7 +11,7 @@
  },
  "dependencies": {
    "@actions/core": "^1.10.1",
-    "@anthropic-ai/claude-agent-sdk": "^0.2.123",
+    "@anthropic-ai/claude-agent-sdk": "^0.1.52",
    "shell-quote": "^1.8.3"
  },
  "devDependencies": {
--- a/base-action/src/index.ts
+++ b/base-action/src/index.ts
@ -11,14 +11,6 @@ async function run() {
  try {
    validateEnvironmentVariables();

-    // The composite action's "Install Claude Code" step writes the binary to
-    // ~/.local/bin/claude. Pass that path explicitly so the Agent SDK doesn't
-    // fall back to its bundled platform package, which bun may resolve to the
-    // wrong libc variant on Linux.
-    const claudeExecutable =
-      process.env.INPUT_PATH_TO_CLAUDE_CODE_EXECUTABLE ||
-      `${process.env.HOME}/.local/bin/claude`;
-
    await setupClaudeCodeSettings(
      process.env.INPUT_SETTINGS,
      undefined, // homeDir
@ -28,7 +20,7 @@ async function run() {
    await installPlugins(
      process.env.INPUT_PLUGIN_MARKETPLACES,
      process.env.INPUT_PLUGINS,
-      claudeExecutable,
+      process.env.INPUT_PATH_TO_CLAUDE_CODE_EXECUTABLE,
    );

    const promptConfig = await preparePrompt({
@ -36,7 +28,7 @@ async function run() {
      promptFile: process.env.INPUT_PROMPT_FILE || "",
    });

-    const result = await runClaude(promptConfig.path, {
+    await runClaude(promptConfig.path, {
      claudeArgs: process.env.INPUT_CLAUDE_ARGS,
      allowedTools: process.env.INPUT_ALLOWED_TOOLS,
      disallowedTools: process.env.INPUT_DISALLOWED_TOOLS,
@ -44,23 +36,13 @@ async function run() {
      mcpConfig: process.env.INPUT_MCP_CONFIG,
      systemPrompt: process.env.INPUT_SYSTEM_PROMPT,
      appendSystemPrompt: process.env.INPUT_APPEND_SYSTEM_PROMPT,
+      claudeEnv: process.env.INPUT_CLAUDE_ENV,
      fallbackModel: process.env.INPUT_FALLBACK_MODEL,
      model: process.env.ANTHROPIC_MODEL,
-      pathToClaudeCodeExecutable: claudeExecutable,
+      pathToClaudeCodeExecutable:
+        process.env.INPUT_PATH_TO_CLAUDE_CODE_EXECUTABLE,
      showFullOutput: process.env.INPUT_SHOW_FULL_OUTPUT,
    });
-
-    // Set outputs for the standalone base-action
-    core.setOutput("conclusion", result.conclusion);
-    if (result.executionFile) {
-      core.setOutput("execution_file", result.executionFile);
-    }
-    if (result.sessionId) {
-      core.setOutput("session_id", result.sessionId);
-    }
-    if (result.structuredOutput) {
-      core.setOutput("structured_output", result.structuredOutput);
-    }
  } catch (error) {
    core.setFailed(`Action failed with error: ${error}`);
    core.setOutput("conclusion", "failure");
--- a/base-action/src/install-plugins.ts
+++ b/base-action/src/install-plugins.ts
@ -8,47 +8,26 @@ const MARKETPLACE_URL_REGEX =
  /^https:\/\/[a-zA-Z0-9\-._~:/?#[\]@!$&'()*+,;=%]+\.git$/;

 /**
- * Checks if a marketplace input is a local path (not a URL)
- * @param input - The marketplace input to check
- * @returns true if the input is a local path, false if it's a URL
+ * Validates a marketplace URL for security issues
+ * @param url - The marketplace URL to validate
+ * @throws {Error} If the URL is invalid
 */
-function isLocalPath(input: string): boolean {
-  // Local paths start with ./, ../, /, or a drive letter (Windows)
-  return (
-    input.startsWith("./") ||
-    input.startsWith("../") ||
-    input.startsWith("/") ||
-    /^[a-zA-Z]:[\\\/]/.test(input)
-  );
-}
-
-/**
- * Validates a marketplace URL or local path
- * @param input - The marketplace URL or local path to validate
- * @throws {Error} If the input is invalid
- */
-function validateMarketplaceInput(input: string): void {
-  const normalized = input.trim();
+function validateMarketplaceUrl(url: string): void {
+  const normalized = url.trim();

  if (!normalized) {
-    throw new Error("Marketplace URL or path cannot be empty");
+    throw new Error("Marketplace URL cannot be empty");
  }

-  // Local paths are passed directly to Claude Code which handles them
-  if (isLocalPath(normalized)) {
-    return;
-  }
-
-  // Validate as URL
  if (!MARKETPLACE_URL_REGEX.test(normalized)) {
-    throw new Error(`Invalid marketplace URL format: ${input}`);
+    throw new Error(`Invalid marketplace URL format: ${url}`);
  }

  // Additional check for valid URL structure
  try {
    new URL(normalized);
  } catch {
-    throw new Error(`Invalid marketplace URL: ${input}`);
+    throw new Error(`Invalid marketplace URL: ${url}`);
  }
 }

@ -76,9 +55,9 @@ function validatePluginName(pluginName: string): void {
 }

 /**
- * Parse a newline-separated list of marketplace URLs or local paths and return an array of validated entries
- * @param marketplaces - Newline-separated list of marketplace Git URLs or local paths
- * @returns Array of validated marketplace URLs or paths (empty array if none provided)
+ * Parse a newline-separated list of marketplace URLs and return an array of validated URLs
+ * @param marketplaces - Newline-separated list of marketplace Git URLs
+ * @returns Array of validated marketplace URLs (empty array if none provided)
 */
 function parseMarketplaces(marketplaces?: string): string[] {
  const trimmed = marketplaces?.trim();
@ -87,14 +66,14 @@ function parseMarketplaces(marketplaces?: string): string[] {
    return [];
  }

-  // Split by newline and process each entry
+  // Split by newline and process each URL
  return trimmed
    .split("\n")
-    .map((entry) => entry.trim())
-    .filter((entry) => {
-      if (entry.length === 0) return false;
+    .map((url) => url.trim())
+    .filter((url) => {
+      if (url.length === 0) return false;

-      validateMarketplaceInput(entry);
+      validateMarketplaceUrl(url);
      return true;
    });
 }
@ -184,26 +163,26 @@ async function installPlugin(
 /**
 * Adds a Claude Code plugin marketplace
 * @param claudeExecutable - Path to the Claude executable
- * @param marketplace - The marketplace Git URL or local path to add
+ * @param marketplaceUrl - The marketplace Git URL to add
 * @returns Promise that resolves when the marketplace add command completes
 * @throws {Error} If the command fails to execute
 */
 async function addMarketplace(
  claudeExecutable: string,
-  marketplace: string,
+  marketplaceUrl: string,
 ): Promise<void> {
-  console.log(`Adding marketplace: ${marketplace}`);
+  console.log(`Adding marketplace: ${marketplaceUrl}`);

  return executeClaudeCommand(
    claudeExecutable,
-    ["plugin", "marketplace", "add", marketplace],
-    `Failed to add marketplace '${marketplace}'`,
+    ["plugin", "marketplace", "add", marketplaceUrl],
+    `Failed to add marketplace '${marketplaceUrl}'`,
  );
 }

 /**
 * Installs Claude Code plugins from a newline-separated list
- * @param marketplacesInput - Newline-separated list of marketplace Git URLs or local paths
+ * @param marketplacesInput - Newline-separated list of marketplace Git URLs
 * @param pluginsInput - Newline-separated list of plugin names
 * @param claudeExecutable - Path to the Claude executable (defaults to "claude")
 * @returns Promise that resolves when all plugins are installed
--- a/base-action/src/parse-sdk-options.ts
+++ b/base-action/src/parse-sdk-options.ts
@ -12,93 +12,12 @@ export type ParsedSdkOptions = {
 };

 // Flags that should accumulate multiple values instead of overwriting
-// Include both camelCase and hyphenated variants for CLI compatibility
-const ACCUMULATING_FLAGS = new Set([
-  "allowedTools",
-  "allowed-tools",
-  "disallowedTools",
-  "disallowed-tools",
-  "mcp-config",
-]);
-
-// Delimiter used to join accumulated flag values
-const ACCUMULATE_DELIMITER = "\x00";
-
-type McpConfig = {
-  mcpServers?: Record<string, unknown>;
-};
-
-/**
- * Merge multiple MCP config values into a single config.
- * Each config can be a JSON string or a file path.
- * For JSON strings, mcpServers objects are merged.
- * For file paths, they are kept as-is (user's file takes precedence and is used last).
- */
-function mergeMcpConfigs(configValues: string[]): string {
-  const merged: McpConfig = { mcpServers: {} };
-  let lastFilePath: string | null = null;
-
-  for (const config of configValues) {
-    const trimmed = config.trim();
-    if (!trimmed) continue;
-
-    // Check if it's a JSON string (starts with {) or a file path
-    if (trimmed.startsWith("{")) {
-      try {
-        const parsed = JSON.parse(trimmed) as McpConfig;
-        if (parsed.mcpServers) {
-          Object.assign(merged.mcpServers!, parsed.mcpServers);
-        }
-      } catch {
-        // If JSON parsing fails, treat as file path
-        lastFilePath = trimmed;
-      }
-    } else {
-      // It's a file path - store it to handle separately
-      lastFilePath = trimmed;
-    }
-  }
-
-  // If we have file paths, we need to keep the merged JSON and let the file
-  // be handled separately. Since we can only return one value, merge what we can.
-  // If there's a file path, we need a different approach - read the file at runtime.
-  // For now, if there's a file path, we'll stringify the merged config.
-  // The action prepends its config as JSON, so we can safely merge inline JSON configs.
-
-  // If no inline configs were found (all file paths), return the last file path
-  if (Object.keys(merged.mcpServers!).length === 0 && lastFilePath) {
-    return lastFilePath;
-  }
-
-  // Note: If user passes a file path, we cannot merge it at parse time since
-  // we don't have access to the file system here. The action's built-in MCP
-  // servers are always passed as inline JSON, so they will be merged.
-  // If user also passes inline JSON, it will be merged.
-  // If user passes a file path, they should ensure it includes all needed servers.
-
-  return JSON.stringify(merged);
-}
-
-/**
- * Strip comment lines from a shell argument string.
- * Lines whose first non-whitespace character is `#` are removed entirely.
- * Inline `#` within a line (e.g. inside a quoted value) is left untouched
- * because shell-quote handles quoting — we only need to remove full comment lines
- * before shell-quote sees them.
- */
-function stripShellComments(input: string): string {
-  return input
-    .split("\n")
-    .filter((line) => !line.trim().startsWith("#"))
-    .join("\n");
-}
+const ACCUMULATING_FLAGS = new Set(["allowedTools", "disallowedTools"]);

 /**
 * Parse claudeArgs string into extraArgs record for SDK pass-through
 * The SDK/CLI will handle --mcp-config, --json-schema, etc.
- * For allowedTools and disallowedTools, multiple occurrences are accumulated (null-char joined).
- * Accumulating flags also consume all consecutive non-flag values
- * (e.g., --allowed-tools "Tool1" "Tool2" "Tool3" captures all three).
+ * For allowedTools and disallowedTools, multiple occurrences are accumulated (comma-joined).
 */
 function parseClaudeArgsToExtraArgs(
  claudeArgs?: string,
@ -106,7 +25,7 @@ function parseClaudeArgsToExtraArgs(
  if (!claudeArgs?.trim()) return {};

  const result: Record<string, string | null> = {};
-  const args = parseShellArgs(stripShellComments(claudeArgs)).filter(
+  const args = parseShellArgs(claudeArgs).filter(
    (arg): arg is string => typeof arg === "string",
  );

@ -118,25 +37,13 @@ function parseClaudeArgsToExtraArgs(

      // Check if next arg is a value (not another flag)
      if (nextArg && !nextArg.startsWith("--")) {
-        // For accumulating flags, consume all consecutive non-flag values
-        // This handles: --allowed-tools "Tool1" "Tool2" "Tool3"
-        if (ACCUMULATING_FLAGS.has(flag)) {
-          const values: string[] = [];
-          while (i + 1 < args.length && !args[i + 1]?.startsWith("--")) {
-            i++;
-            values.push(args[i]!);
-          }
-          const joinedValues = values.join(ACCUMULATE_DELIMITER);
-          if (result[flag]) {
-            result[flag] =
-              `${result[flag]}${ACCUMULATE_DELIMITER}${joinedValues}`;
-          } else {
-            result[flag] = joinedValues;
-          }
+        // For accumulating flags, join multiple values with commas
+        if (ACCUMULATING_FLAGS.has(flag) && result[flag]) {
+          result[flag] = `${result[flag]},${nextArg}`;
        } else {
          result[flag] = nextArg;
-          i++; // Skip the value
        }
+        i++; // Skip the value
      } else {
        result[flag] = null; // Boolean flag
      }
@ -161,23 +68,12 @@ export function parseSdkOptions(options: ClaudeOptions): ParsedSdkOptions {
  // Detect if --json-schema is present (for hasJsonSchema flag)
  const hasJsonSchema = "json-schema" in extraArgs;

-  // Extract and merge allowedTools from all sources:
+  // Extract and merge allowedTools from both sources:
  // 1. From extraArgs (parsed from claudeArgs - contains tag mode's tools)
-  //    - Check both camelCase (--allowedTools) and hyphenated (--allowed-tools) variants
  // 2. From options.allowedTools (direct input - may be undefined)
  // This prevents duplicate flags being overwritten when claudeArgs contains --allowedTools
-  const allowedToolsValues = [
-    extraArgs["allowedTools"],
-    extraArgs["allowed-tools"],
-  ]
-    .filter(Boolean)
-    .join(ACCUMULATE_DELIMITER);
-  const extraArgsAllowedTools = allowedToolsValues
-    ? allowedToolsValues
-        .split(ACCUMULATE_DELIMITER)
-        .flatMap((v) => v.split(","))
-        .map((t) => t.trim())
-        .filter(Boolean)
+  const extraArgsAllowedTools = extraArgs["allowedTools"]
+    ? extraArgs["allowedTools"].split(",").map((t) => t.trim())
    : [];
  const directAllowedTools = options.allowedTools
    ? options.allowedTools.split(",").map((t) => t.trim())
@ -186,21 +82,10 @@ export function parseSdkOptions(options: ClaudeOptions): ParsedSdkOptions {
    ...new Set([...extraArgsAllowedTools, ...directAllowedTools]),
  ];
  delete extraArgs["allowedTools"];
-  delete extraArgs["allowed-tools"];

-  // Same for disallowedTools - check both camelCase and hyphenated variants
-  const disallowedToolsValues = [
-    extraArgs["disallowedTools"],
-    extraArgs["disallowed-tools"],
-  ]
-    .filter(Boolean)
-    .join(ACCUMULATE_DELIMITER);
-  const extraArgsDisallowedTools = disallowedToolsValues
-    ? disallowedToolsValues
-        .split(ACCUMULATE_DELIMITER)
-        .flatMap((v) => v.split(","))
-        .map((t) => t.trim())
-        .filter(Boolean)
+  // Same for disallowedTools
+  const extraArgsDisallowedTools = extraArgs["disallowedTools"]
+    ? extraArgs["disallowedTools"].split(",").map((t) => t.trim())
    : [];
  const directDisallowedTools = options.disallowedTools
    ? options.disallowedTools.split(",").map((t) => t.trim())
@ -209,31 +94,12 @@ export function parseSdkOptions(options: ClaudeOptions): ParsedSdkOptions {
    ...new Set([...extraArgsDisallowedTools, ...directDisallowedTools]),
  ];
  delete extraArgs["disallowedTools"];
-  delete extraArgs["disallowed-tools"];
-
-  // Merge multiple --mcp-config values by combining their mcpServers objects
-  // The action prepends its config (github_comment, github_ci, etc.) as inline JSON,
-  // and users may provide their own config as inline JSON or file path
-  if (extraArgs["mcp-config"]) {
-    const mcpConfigValues = extraArgs["mcp-config"].split(ACCUMULATE_DELIMITER);
-    if (mcpConfigValues.length > 1) {
-      extraArgs["mcp-config"] = mergeMcpConfigs(mcpConfigValues);
-    }
-  }

  // Build custom environment
  const env: Record<string, string | undefined> = { ...process.env };
  if (process.env.INPUT_ACTION_INPUTS_PRESENT) {
    env.GITHUB_ACTION_INPUTS = process.env.INPUT_ACTION_INPUTS_PRESENT;
  }
-  // Set the entrypoint for Claude Code to identify this as the GitHub Action
-  env.CLAUDE_CODE_ENTRYPOINT = "claude-code-github-action";
-
-  // Remove OIDC token request variables so Claude cannot mint new tokens.
-  // These are only needed by the action itself (via @actions/core.getIDToken()),
-  // not by the Claude session.
-  delete env.ACTIONS_ID_TOKEN_REQUEST_URL;
-  delete env.ACTIONS_ID_TOKEN_REQUEST_TOKEN;

  // Build system prompt option - default to claude_code preset
  let systemPrompt: SdkOptions["systemPrompt"];
@ -271,18 +137,10 @@ export function parseSdkOptions(options: ClaudeOptions): ParsedSdkOptions {
    extraArgs,
    env,

-    // Load settings from sources - prefer user's --setting-sources if provided, otherwise use all sources
-    // This ensures users can override the default behavior (e.g., --setting-sources user to avoid in-repo configs)
-    settingSources: extraArgs["setting-sources"]
-      ? (extraArgs["setting-sources"].split(
-          ",",
-        ) as SdkOptions["settingSources"])
-      : ["user", "project", "local"],
+    // Load settings from all sources to pick up CLI-installed plugins, CLAUDE.md, etc.
+    settingSources: ["user", "project", "local"],
  };

-  // Remove setting-sources from extraArgs to avoid passing it twice
-  delete extraArgs["setting-sources"];
-
  return {
    sdkOptions,
    showFullOutput,
--- a/base-action/src/run-claude-sdk.ts
+++ b/base-action/src/run-claude-sdk.ts
@ -1,88 +1,14 @@
 import * as core from "@actions/core";
-import { readFile, writeFile, access } from "fs/promises";
-import { dirname, join } from "path";
+import { readFile, writeFile } from "fs/promises";
 import { query } from "@anthropic-ai/claude-agent-sdk";
 import type {
  SDKMessage,
  SDKResultMessage,
-  SDKUserMessage,
 } from "@anthropic-ai/claude-agent-sdk";
 import type { ParsedSdkOptions } from "./parse-sdk-options";

-export type ClaudeRunResult = {
-  executionFile?: string;
-  sessionId?: string;
-  conclusion: "success" | "failure";
-  structuredOutput?: string;
-};
-
 const EXECUTION_FILE = `${process.env.RUNNER_TEMP}/claude-execution-output.json`;

-/** Filename for the user request file, written by prompt generation */
-const USER_REQUEST_FILENAME = "claude-user-request.txt";
-
-/**
- * Check if a file exists
- */
-async function fileExists(path: string): Promise<boolean> {
-  try {
-    await access(path);
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-/**
- * Creates a prompt configuration for the SDK.
- * If a user request file exists alongside the prompt file, returns a multi-block
- * SDKUserMessage that enables slash command processing in the CLI.
- * Otherwise, returns the prompt as a simple string.
- */
-async function createPromptConfig(
-  promptPath: string,
-  showFullOutput: boolean,
-): Promise<string | AsyncIterable<SDKUserMessage>> {
-  const promptContent = await readFile(promptPath, "utf-8");
-
-  // Check for user request file in the same directory
-  const userRequestPath = join(dirname(promptPath), USER_REQUEST_FILENAME);
-  const hasUserRequest = await fileExists(userRequestPath);
-
-  if (!hasUserRequest) {
-    // No user request file - use simple string prompt
-    return promptContent;
-  }
-
-  // User request file exists - create multi-block message
-  const userRequest = await readFile(userRequestPath, "utf-8");
-  if (showFullOutput) {
-    console.log("Using multi-block message with user request:", userRequest);
-  } else {
-    console.log("Using multi-block message with user request (content hidden)");
-  }
-
-  // Create an async generator that yields a single multi-block message
-  // The context/instructions go first, then the user's actual request last
-  // This allows the CLI to detect and process slash commands in the user request
-  async function* createMultiBlockMessage(): AsyncGenerator<SDKUserMessage> {
-    yield {
-      type: "user",
-      session_id: "",
-      message: {
-        role: "user",
-        content: [
-          { type: "text", text: promptContent }, // Instructions + GitHub context
-          { type: "text", text: userRequest }, // User's request (may be a slash command)
-        ],
-      },
-      parent_tool_use_id: null,
-    };
-  }
-
-  return createMultiBlockMessage();
-}
-
 /**
 * Sanitizes SDK output to match CLI sanitization behavior
 */
@ -119,7 +45,7 @@ function sanitizeSdkOutput(
        duration_ms: resultMsg.duration_ms,
        num_turns: resultMsg.num_turns,
        total_cost_usd: resultMsg.total_cost_usd,
-        permission_denials_count: resultMsg.permission_denials?.length ?? 0,
+        permission_denials: resultMsg.permission_denials,
      },
      null,
      2,
@ -136,9 +62,8 @@ function sanitizeSdkOutput(
 export async function runClaudeWithSdk(
  promptPath: string,
  { sdkOptions, showFullOutput, hasJsonSchema }: ParsedSdkOptions,
-): Promise<ClaudeRunResult> {
-  // Create prompt configuration - may be a string or multi-block message
-  const prompt = await createPromptConfig(promptPath, showFullOutput);
+): Promise<void> {
+  const prompt = await readFile(promptPath, "utf-8");

  if (!showFullOutput) {
    console.log(
@ -151,7 +76,7 @@ export async function runClaudeWithSdk(

  console.log(`Running Claude with prompt from file: ${promptPath}`);
  // Log SDK options without env (which could contain sensitive data)
-  const { env, extraArgs, ...optionsToLog } = sdkOptions;
+  const { env, ...optionsToLog } = sdkOptions;
  console.log("SDK options:", JSON.stringify(optionsToLog, null, 2));

  const messages: SDKMessage[] = [];
@ -172,38 +97,27 @@ export async function runClaudeWithSdk(
    }
  } catch (error) {
    console.error("SDK execution error:", error);
-    throw new Error(`SDK execution error: ${error}`);
+    core.setOutput("conclusion", "failure");
+    process.exit(1);
  }

-  const result: ClaudeRunResult = {
-    conclusion: "failure",
-  };
-
  // Write execution file
  try {
    await writeFile(EXECUTION_FILE, JSON.stringify(messages, null, 2));
    console.log(`Log saved to ${EXECUTION_FILE}`);
-    result.executionFile = EXECUTION_FILE;
+    core.setOutput("execution_file", EXECUTION_FILE);
  } catch (error) {
    core.warning(`Failed to write execution file: ${error}`);
  }

-  // Extract session_id from system.init message
-  const initMessage = messages.find(
-    (m) => m.type === "system" && "subtype" in m && m.subtype === "init",
-  );
-  if (initMessage && "session_id" in initMessage && initMessage.session_id) {
-    result.sessionId = initMessage.session_id as string;
-    core.info(`Set session_id: ${result.sessionId}`);
-  }
-
  if (!resultMessage) {
+    core.setOutput("conclusion", "failure");
    core.error("No result message received from Claude");
-    throw new Error("No result message received from Claude");
+    process.exit(1);
  }

  const isSuccess = resultMessage.subtype === "success";
-  result.conclusion = isSuccess ? "success" : "failure";
+  core.setOutput("conclusion", isSuccess ? "success" : "failure");

  // Handle structured output
  if (hasJsonSchema) {
@ -212,7 +126,10 @@ export async function runClaudeWithSdk(
      "structured_output" in resultMessage &&
      resultMessage.structured_output
    ) {
-      result.structuredOutput = JSON.stringify(resultMessage.structured_output);
+      const structuredOutputJson = JSON.stringify(
+        resultMessage.structured_output,
+      );
+      core.setOutput("structured_output", structuredOutputJson);
      core.info(
        `Set structured_output with ${Object.keys(resultMessage.structured_output as object).length} field(s)`,
      );
@ -220,10 +137,8 @@ export async function runClaudeWithSdk(
      core.setFailed(
        `--json-schema was provided but Claude did not return structured_output. Result subtype: ${resultMessage.subtype}`,
      );
-      result.conclusion = "failure";
-      throw new Error(
-        `--json-schema was provided but Claude did not return structured_output. Result subtype: ${resultMessage.subtype}`,
-      );
+      core.setOutput("conclusion", "failure");
+      process.exit(1);
    }
  }

@ -231,14 +146,6 @@ export async function runClaudeWithSdk(
    if ("errors" in resultMessage && resultMessage.errors) {
      core.error(`Execution failed: ${resultMessage.errors.join(", ")}`);
    }
-    throw new Error(
-      `Claude execution failed: ${
-        "errors" in resultMessage && resultMessage.errors
-          ? resultMessage.errors.join(", ")
-          : "unknown error"
-      }`,
-    );
+    process.exit(1);
  }
-
-  return result;
 }
--- a/base-action/src/run-claude.ts
+++ b/base-action/src/run-claude.ts
@ -1,7 +1,72 @@
+import * as core from "@actions/core";
+import { exec } from "child_process";
+import { promisify } from "util";
+import { unlink, writeFile, stat, readFile } from "fs/promises";
+import { createWriteStream } from "fs";
+import { spawn } from "child_process";
+import { parse as parseShellArgs } from "shell-quote";
 import { runClaudeWithSdk } from "./run-claude-sdk";
-import type { ClaudeRunResult } from "./run-claude-sdk";
 import { parseSdkOptions } from "./parse-sdk-options";

+const execAsync = promisify(exec);
+
+const PIPE_PATH = `${process.env.RUNNER_TEMP}/claude_prompt_pipe`;
+const EXECUTION_FILE = `${process.env.RUNNER_TEMP}/claude-execution-output.json`;
+const BASE_ARGS = ["--verbose", "--output-format", "stream-json"];
+
+/**
+ * Sanitizes JSON output to remove sensitive information when full output is disabled
+ * Returns a safe summary message or null if the message should be completely suppressed
+ */
+function sanitizeJsonOutput(
+  jsonObj: any,
+  showFullOutput: boolean,
+): string | null {
+  if (showFullOutput) {
+    // In full output mode, return the full JSON
+    return JSON.stringify(jsonObj, null, 2);
+  }
+
+  // In non-full-output mode, provide minimal safe output
+  const type = jsonObj.type;
+  const subtype = jsonObj.subtype;
+
+  // System initialization - safe to show
+  if (type === "system" && subtype === "init") {
+    return JSON.stringify(
+      {
+        type: "system",
+        subtype: "init",
+        message: "Claude Code initialized",
+        model: jsonObj.model || "unknown",
+      },
+      null,
+      2,
+    );
+  }
+
+  // Result messages - Always show the final result
+  if (type === "result") {
+    // These messages contain the final result and should always be visible
+    return JSON.stringify(
+      {
+        type: "result",
+        subtype: jsonObj.subtype,
+        is_error: jsonObj.is_error,
+        duration_ms: jsonObj.duration_ms,
+        num_turns: jsonObj.num_turns,
+        total_cost_usd: jsonObj.total_cost_usd,
+        permission_denials: jsonObj.permission_denials,
+      },
+      null,
+      2,
+    );
+  }
+
+  // For any other message types, suppress completely in non-full-output mode
+  return null;
+}
+
 export type ClaudeOptions = {
  claudeArgs?: string;
  model?: string;
@ -12,14 +77,363 @@ export type ClaudeOptions = {
  mcpConfig?: string;
  systemPrompt?: string;
  appendSystemPrompt?: string;
+  claudeEnv?: string;
  fallbackModel?: string;
  showFullOutput?: string;
 };

-export async function runClaude(
+type PreparedConfig = {
+  claudeArgs: string[];
+  promptPath: string;
+  env: Record<string, string>;
+};
+
+export function prepareRunConfig(
  promptPath: string,
  options: ClaudeOptions,
-): Promise<ClaudeRunResult> {
-  const parsedOptions = parseSdkOptions(options);
-  return runClaudeWithSdk(promptPath, parsedOptions);
+): PreparedConfig {
+  // Build Claude CLI arguments:
+  // 1. Prompt flag (always first)
+  // 2. User's claudeArgs (full control)
+  // 3. BASE_ARGS (always last, cannot be overridden)
+
+  const claudeArgs = ["-p"];
+
+  // Parse and add user's custom Claude arguments
+  if (options.claudeArgs?.trim()) {
+    const parsed = parseShellArgs(options.claudeArgs);
+    const customArgs = parsed.filter(
+      (arg): arg is string => typeof arg === "string",
+    );
+    claudeArgs.push(...customArgs);
+  }
+
+  // BASE_ARGS are always appended last (cannot be overridden)
+  claudeArgs.push(...BASE_ARGS);
+
+  const customEnv: Record<string, string> = {};
+
+  if (process.env.INPUT_ACTION_INPUTS_PRESENT) {
+    customEnv.GITHUB_ACTION_INPUTS = process.env.INPUT_ACTION_INPUTS_PRESENT;
+  }
+
+  return {
+    claudeArgs,
+    promptPath,
+    env: customEnv,
+  };
+}
+
+/**
+ * Parses session_id from execution file and sets GitHub Action output
+ * Exported for testing
+ */
+export async function parseAndSetSessionId(
+  executionFile: string,
+): Promise<void> {
+  try {
+    const content = await readFile(executionFile, "utf-8");
+    const messages = JSON.parse(content) as {
+      type: string;
+      subtype?: string;
+      session_id?: string;
+    }[];
+
+    // Find the system.init message which contains session_id
+    const initMessage = messages.find(
+      (m) => m.type === "system" && m.subtype === "init",
+    );
+
+    if (initMessage?.session_id) {
+      core.setOutput("session_id", initMessage.session_id);
+      core.info(`Set session_id: ${initMessage.session_id}`);
+    }
+  } catch (error) {
+    // Don't fail the action if session_id extraction fails
+    core.warning(`Failed to extract session_id: ${error}`);
+  }
+}
+
+/**
+ * Parses structured_output from execution file and sets GitHub Action outputs
+ * Only runs if --json-schema was explicitly provided in claude_args
+ * Exported for testing
+ */
+export async function parseAndSetStructuredOutputs(
+  executionFile: string,
+): Promise<void> {
+  try {
+    const content = await readFile(executionFile, "utf-8");
+    const messages = JSON.parse(content) as {
+      type: string;
+      structured_output?: Record<string, unknown>;
+    }[];
+
+    // Search backwards - result is typically last or second-to-last message
+    const result = messages.findLast(
+      (m) => m.type === "result" && m.structured_output,
+    );
+
+    if (!result?.structured_output) {
+      throw new Error(
+        `--json-schema was provided but Claude did not return structured_output.\n` +
+          `Found ${messages.length} messages. Result exists: ${!!result}\n`,
+      );
+    }
+
+    // Set the complete structured output as a single JSON string
+    // This works around GitHub Actions limitation that composite actions can't have dynamic outputs
+    const structuredOutputJson = JSON.stringify(result.structured_output);
+    core.setOutput("structured_output", structuredOutputJson);
+    core.info(
+      `Set structured_output with ${Object.keys(result.structured_output).length} field(s)`,
+    );
+  } catch (error) {
+    if (error instanceof Error) {
+      throw error; // Preserve original error and stack trace
+    }
+    throw new Error(`Failed to parse structured outputs: ${error}`);
+  }
+}
+
+export async function runClaude(promptPath: string, options: ClaudeOptions) {
+  // Feature flag: use SDK path by default, set USE_AGENT_SDK=false to use CLI
+  const useAgentSdk = process.env.USE_AGENT_SDK !== "false";
+  console.log(
+    `Using ${useAgentSdk ? "Agent SDK" : "CLI"} path (USE_AGENT_SDK=${process.env.USE_AGENT_SDK ?? "unset"})`,
+  );
+
+  if (useAgentSdk) {
+    const parsedOptions = parseSdkOptions(options);
+    return runClaudeWithSdk(promptPath, parsedOptions);
+  }
+
+  const config = prepareRunConfig(promptPath, options);
+
+  // Detect if --json-schema is present in claude args
+  const hasJsonSchema = options.claudeArgs?.includes("--json-schema") ?? false;
+
+  // Create a named pipe
+  try {
+    await unlink(PIPE_PATH);
+  } catch (e) {
+    // Ignore if file doesn't exist
+  }
+
+  // Create the named pipe
+  await execAsync(`mkfifo "${PIPE_PATH}"`);
+
+  // Log prompt file size
+  let promptSize = "unknown";
+  try {
+    const stats = await stat(config.promptPath);
+    promptSize = stats.size.toString();
+  } catch (e) {
+    // Ignore error
+  }
+
+  console.log(`Prompt file size: ${promptSize} bytes`);
+
+  // Log custom environment variables if any
+  const customEnvKeys = Object.keys(config.env).filter(
+    (key) => key !== "CLAUDE_ACTION_INPUTS_PRESENT",
+  );
+  if (customEnvKeys.length > 0) {
+    console.log(`Custom environment variables: ${customEnvKeys.join(", ")}`);
+  }
+
+  // Log custom arguments if any
+  if (options.claudeArgs && options.claudeArgs.trim() !== "") {
+    console.log(`Custom Claude arguments: ${options.claudeArgs}`);
+  }
+
+  // Output to console
+  console.log(`Running Claude with prompt from file: ${config.promptPath}`);
+  console.log(`Full command: claude ${config.claudeArgs.join(" ")}`);
+
+  // Start sending prompt to pipe in background
+  const catProcess = spawn("cat", [config.promptPath], {
+    stdio: ["ignore", "pipe", "inherit"],
+  });
+  const pipeStream = createWriteStream(PIPE_PATH);
+  catProcess.stdout.pipe(pipeStream);
+
+  catProcess.on("error", (error) => {
+    console.error("Error reading prompt file:", error);
+    pipeStream.destroy();
+  });
+
+  // Use custom executable path if provided, otherwise default to "claude"
+  const claudeExecutable = options.pathToClaudeCodeExecutable || "claude";
+
+  const claudeProcess = spawn(claudeExecutable, config.claudeArgs, {
+    stdio: ["pipe", "pipe", "inherit"],
+    env: {
+      ...process.env,
+      ...config.env,
+    },
+  });
+
+  // Handle Claude process errors
+  claudeProcess.on("error", (error) => {
+    console.error("Error spawning Claude process:", error);
+    pipeStream.destroy();
+  });
+
+  // Determine if full output should be shown
+  // Show full output if explicitly set to "true" OR if GitHub Actions debug mode is enabled
+  const isDebugMode = process.env.ACTIONS_STEP_DEBUG === "true";
+  let showFullOutput = options.showFullOutput === "true" || isDebugMode;
+
+  if (isDebugMode && options.showFullOutput !== "false") {
+    console.log("Debug mode detected - showing full output");
+    showFullOutput = true;
+  } else if (!showFullOutput) {
+    console.log("Running Claude Code (full output hidden for security)...");
+    console.log(
+      "Rerun in debug mode or enable `show_full_output: true` in your workflow file for full output.",
+    );
+  }
+
+  // Capture output for parsing execution metrics
+  let output = "";
+  claudeProcess.stdout.on("data", (data) => {
+    const text = data.toString();
+
+    // Try to parse as JSON and handle based on verbose setting
+    const lines = text.split("\n");
+    lines.forEach((line: string, index: number) => {
+      if (line.trim() === "") return;
+
+      try {
+        // Check if this line is a JSON object
+        const parsed = JSON.parse(line);
+        const sanitizedOutput = sanitizeJsonOutput(parsed, showFullOutput);
+
+        if (sanitizedOutput) {
+          process.stdout.write(sanitizedOutput);
+          if (index < lines.length - 1 || text.endsWith("\n")) {
+            process.stdout.write("\n");
+          }
+        }
+      } catch (e) {
+        // Not a JSON object
+        if (showFullOutput) {
+          // In full output mode, print as is
+          process.stdout.write(line);
+          if (index < lines.length - 1 || text.endsWith("\n")) {
+            process.stdout.write("\n");
+          }
+        }
+        // In non-full-output mode, suppress non-JSON output
+      }
+    });
+
+    output += text;
+  });
+
+  // Handle stdout errors
+  claudeProcess.stdout.on("error", (error) => {
+    console.error("Error reading Claude stdout:", error);
+  });
+
+  // Pipe from named pipe to Claude
+  const pipeProcess = spawn("cat", [PIPE_PATH]);
+  pipeProcess.stdout.pipe(claudeProcess.stdin);
+
+  // Handle pipe process errors
+  pipeProcess.on("error", (error) => {
+    console.error("Error reading from named pipe:", error);
+    claudeProcess.kill("SIGTERM");
+  });
+
+  // Wait for Claude to finish
+  const exitCode = await new Promise<number>((resolve) => {
+    claudeProcess.on("close", (code) => {
+      resolve(code || 0);
+    });
+
+    claudeProcess.on("error", (error) => {
+      console.error("Claude process error:", error);
+      resolve(1);
+    });
+  });
+
+  // Clean up processes
+  try {
+    catProcess.kill("SIGTERM");
+  } catch (e) {
+    // Process may already be dead
+  }
+  try {
+    pipeProcess.kill("SIGTERM");
+  } catch (e) {
+    // Process may already be dead
+  }
+
+  // Clean up pipe file
+  try {
+    await unlink(PIPE_PATH);
+  } catch (e) {
+    // Ignore errors during cleanup
+  }
+
+  // Set conclusion based on exit code
+  if (exitCode === 0) {
+    // Try to process the output and save execution metrics
+    try {
+      await writeFile("output.txt", output);
+
+      // Process output.txt into JSON and save to execution file
+      // Increase maxBuffer from Node.js default of 1MB to 10MB to handle large Claude outputs
+      const { stdout: jsonOutput } = await execAsync("jq -s '.' output.txt", {
+        maxBuffer: 10 * 1024 * 1024,
+      });
+      await writeFile(EXECUTION_FILE, jsonOutput);
+
+      console.log(`Log saved to ${EXECUTION_FILE}`);
+    } catch (e) {
+      core.warning(`Failed to process output for execution metrics: ${e}`);
+    }
+
+    core.setOutput("execution_file", EXECUTION_FILE);
+
+    // Extract and set session_id
+    await parseAndSetSessionId(EXECUTION_FILE);
+
+    // Parse and set structured outputs only if user provided --json-schema in claude_args
+    if (hasJsonSchema) {
+      try {
+        await parseAndSetStructuredOutputs(EXECUTION_FILE);
+      } catch (error) {
+        const errorMessage =
+          error instanceof Error ? error.message : String(error);
+        core.setFailed(errorMessage);
+        core.setOutput("conclusion", "failure");
+        process.exit(1);
+      }
+    }
+
+    // Set conclusion to success if we reached here
+    core.setOutput("conclusion", "success");
+  } else {
+    core.setOutput("conclusion", "failure");
+
+    // Still try to save execution file if we have output
+    if (output) {
+      try {
+        await writeFile("output.txt", output);
+        // Increase maxBuffer from Node.js default of 1MB to 10MB to handle large Claude outputs
+        const { stdout: jsonOutput } = await execAsync("jq -s '.' output.txt", {
+          maxBuffer: 10 * 1024 * 1024,
+        });
+        await writeFile(EXECUTION_FILE, jsonOutput);
+        core.setOutput("execution_file", EXECUTION_FILE);
+      } catch (e) {
+        // Ignore errors when processing output during failure
+      }
+    }
+
+    process.exit(exitCode);
+  }
 }
--- a/base-action/test/install-plugins.test.ts
+++ b/base-action/test/install-plugins.test.ts
@ -596,111 +596,4 @@ describe("installPlugins", () => {
      { stdio: "inherit" },
    );
  });
-
-  // Local marketplace path tests
-  test("should accept local marketplace path with ./", async () => {
-    const spy = createMockSpawn();
-    await installPlugins("./my-local-marketplace", "test-plugin");
-
-    expect(spy).toHaveBeenCalledTimes(2);
-    expect(spy).toHaveBeenNthCalledWith(
-      1,
-      "claude",
-      ["plugin", "marketplace", "add", "./my-local-marketplace"],
-      { stdio: "inherit" },
-    );
-    expect(spy).toHaveBeenNthCalledWith(
-      2,
-      "claude",
-      ["plugin", "install", "test-plugin"],
-      { stdio: "inherit" },
-    );
-  });
-
-  test("should accept local marketplace path with absolute Unix path", async () => {
-    const spy = createMockSpawn();
-    await installPlugins("/home/user/my-marketplace", "test-plugin");
-
-    expect(spy).toHaveBeenCalledTimes(2);
-    expect(spy).toHaveBeenNthCalledWith(
-      1,
-      "claude",
-      ["plugin", "marketplace", "add", "/home/user/my-marketplace"],
-      { stdio: "inherit" },
-    );
-  });
-
-  test("should accept local marketplace path with Windows absolute path", async () => {
-    const spy = createMockSpawn();
-    await installPlugins("C:\\Users\\user\\marketplace", "test-plugin");
-
-    expect(spy).toHaveBeenCalledTimes(2);
-    expect(spy).toHaveBeenNthCalledWith(
-      1,
-      "claude",
-      ["plugin", "marketplace", "add", "C:\\Users\\user\\marketplace"],
-      { stdio: "inherit" },
-    );
-  });
-
-  test("should accept mixed local and remote marketplaces", async () => {
-    const spy = createMockSpawn();
-    await installPlugins(
-      "./local-marketplace\nhttps://github.com/user/remote.git",
-      "test-plugin",
-    );
-
-    expect(spy).toHaveBeenCalledTimes(3);
-    expect(spy).toHaveBeenNthCalledWith(
-      1,
-      "claude",
-      ["plugin", "marketplace", "add", "./local-marketplace"],
-      { stdio: "inherit" },
-    );
-    expect(spy).toHaveBeenNthCalledWith(
-      2,
-      "claude",
-      ["plugin", "marketplace", "add", "https://github.com/user/remote.git"],
-      { stdio: "inherit" },
-    );
-  });
-
-  test("should accept local path with ../ (parent directory)", async () => {
-    const spy = createMockSpawn();
-    await installPlugins("../shared-plugins/marketplace", "test-plugin");
-
-    expect(spy).toHaveBeenCalledTimes(2);
-    expect(spy).toHaveBeenNthCalledWith(
-      1,
-      "claude",
-      ["plugin", "marketplace", "add", "../shared-plugins/marketplace"],
-      { stdio: "inherit" },
-    );
-  });
-
-  test("should accept local path with nested directories", async () => {
-    const spy = createMockSpawn();
-    await installPlugins("./plugins/my-org/my-marketplace", "test-plugin");
-
-    expect(spy).toHaveBeenCalledTimes(2);
-    expect(spy).toHaveBeenNthCalledWith(
-      1,
-      "claude",
-      ["plugin", "marketplace", "add", "./plugins/my-org/my-marketplace"],
-      { stdio: "inherit" },
-    );
-  });
-
-  test("should accept local path with dots in directory name", async () => {
-    const spy = createMockSpawn();
-    await installPlugins("./my.plugin.marketplace", "test-plugin");
-
-    expect(spy).toHaveBeenCalledTimes(2);
-    expect(spy).toHaveBeenNthCalledWith(
-      1,
-      "claude",
-      ["plugin", "marketplace", "add", "./my.plugin.marketplace"],
-      { stdio: "inherit" },
-    );
-  });
 });
--- a/base-action/test/mcp-test/package.json
+++ b/base-action/test/mcp-test/package.json
@ -2,6 +2,6 @@
  "name": "mcp-test",
  "version": "1.0.0",
  "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.24.0"
+    "@modelcontextprotocol/sdk": "^1.11.0"
  }
 }
--- a/base-action/test/parse-sdk-options.test.ts
+++ b/base-action/test/parse-sdk-options.test.ts
@ -108,48 +108,6 @@ describe("parseSdkOptions", () => {
      expect(result.sdkOptions.extraArgs?.["allowedTools"]).toBeUndefined();
      expect(result.sdkOptions.extraArgs?.["model"]).toBe("claude-3-5-sonnet");
    });
-
-    test("should handle hyphenated --allowed-tools flag", () => {
-      const options: ClaudeOptions = {
-        claudeArgs: '--allowed-tools "Edit,Read,Write"',
-      };
-
-      const result = parseSdkOptions(options);
-
-      expect(result.sdkOptions.allowedTools).toEqual(["Edit", "Read", "Write"]);
-      expect(result.sdkOptions.extraArgs?.["allowed-tools"]).toBeUndefined();
-    });
-
-    test("should accumulate multiple --allowed-tools flags (hyphenated)", () => {
-      // This is the exact scenario from issue #746
-      const options: ClaudeOptions = {
-        claudeArgs:
-          '--allowed-tools "Bash(git log:*)" "Bash(git diff:*)" "Bash(git fetch:*)" "Bash(gh pr:*)"',
-      };
-
-      const result = parseSdkOptions(options);
-
-      expect(result.sdkOptions.allowedTools).toEqual([
-        "Bash(git log:*)",
-        "Bash(git diff:*)",
-        "Bash(git fetch:*)",
-        "Bash(gh pr:*)",
-      ]);
-    });
-
-    test("should handle mixed camelCase and hyphenated allowedTools flags", () => {
-      const options: ClaudeOptions = {
-        claudeArgs: '--allowedTools "Edit,Read" --allowed-tools "Write,Glob"',
-      };
-
-      const result = parseSdkOptions(options);
-
-      // Both should be merged - note: order depends on which key is found first
-      expect(result.sdkOptions.allowedTools).toContain("Edit");
-      expect(result.sdkOptions.allowedTools).toContain("Read");
-      expect(result.sdkOptions.allowedTools).toContain("Write");
-      expect(result.sdkOptions.allowedTools).toContain("Glob");
-    });
  });

  describe("disallowedTools merging", () => {
@ -176,129 +134,19 @@ describe("parseSdkOptions", () => {
    });
  });

-  describe("mcp-config merging", () => {
-    test("should pass through single mcp-config in extraArgs", () => {
-      const options: ClaudeOptions = {
-        claudeArgs: `--mcp-config '{"mcpServers":{"server1":{"command":"cmd1"}}}'`,
-      };
-
-      const result = parseSdkOptions(options);
-
-      expect(result.sdkOptions.extraArgs?.["mcp-config"]).toBe(
-        '{"mcpServers":{"server1":{"command":"cmd1"}}}',
-      );
-    });
-
-    test("should merge multiple mcp-config flags with inline JSON", () => {
-      // Simulates action prepending its config, then user providing their own
-      const options: ClaudeOptions = {
-        claudeArgs: `--mcp-config '{"mcpServers":{"github_comment":{"command":"node","args":["server.js"]}}}' --mcp-config '{"mcpServers":{"user_server":{"command":"custom","args":["run"]}}}'`,
-      };
-
-      const result = parseSdkOptions(options);
-
-      const mcpConfig = JSON.parse(
-        result.sdkOptions.extraArgs?.["mcp-config"] as string,
-      );
-      expect(mcpConfig.mcpServers).toHaveProperty("github_comment");
-      expect(mcpConfig.mcpServers).toHaveProperty("user_server");
-      expect(mcpConfig.mcpServers.github_comment.command).toBe("node");
-      expect(mcpConfig.mcpServers.user_server.command).toBe("custom");
-    });
-
-    test("should merge three mcp-config flags", () => {
-      const options: ClaudeOptions = {
-        claudeArgs: `--mcp-config '{"mcpServers":{"server1":{"command":"cmd1"}}}' --mcp-config '{"mcpServers":{"server2":{"command":"cmd2"}}}' --mcp-config '{"mcpServers":{"server3":{"command":"cmd3"}}}'`,
-      };
-
-      const result = parseSdkOptions(options);
-
-      const mcpConfig = JSON.parse(
-        result.sdkOptions.extraArgs?.["mcp-config"] as string,
-      );
-      expect(mcpConfig.mcpServers).toHaveProperty("server1");
-      expect(mcpConfig.mcpServers).toHaveProperty("server2");
-      expect(mcpConfig.mcpServers).toHaveProperty("server3");
-    });
-
-    test("should handle mcp-config file path when no inline JSON exists", () => {
-      const options: ClaudeOptions = {
-        claudeArgs: `--mcp-config /tmp/user-mcp-config.json`,
-      };
-
-      const result = parseSdkOptions(options);
-
-      expect(result.sdkOptions.extraArgs?.["mcp-config"]).toBe(
-        "/tmp/user-mcp-config.json",
-      );
-    });
-
-    test("should merge inline JSON configs when file path is also present", () => {
-      // When action provides inline JSON and user provides a file path,
-      // the inline JSON configs should be merged (file paths cannot be merged at parse time)
-      const options: ClaudeOptions = {
-        claudeArgs: `--mcp-config '{"mcpServers":{"github_comment":{"command":"node"}}}' --mcp-config '{"mcpServers":{"github_ci":{"command":"node"}}}' --mcp-config /tmp/user-config.json`,
-      };
-
-      const result = parseSdkOptions(options);
-
-      // The inline JSON configs should be merged
-      const mcpConfig = JSON.parse(
-        result.sdkOptions.extraArgs?.["mcp-config"] as string,
-      );
-      expect(mcpConfig.mcpServers).toHaveProperty("github_comment");
-      expect(mcpConfig.mcpServers).toHaveProperty("github_ci");
-    });
-
-    test("should handle mcp-config with other flags", () => {
-      const options: ClaudeOptions = {
-        claudeArgs: `--mcp-config '{"mcpServers":{"server1":{}}}' --model claude-3-5-sonnet --mcp-config '{"mcpServers":{"server2":{}}}'`,
-      };
-
-      const result = parseSdkOptions(options);
-
-      const mcpConfig = JSON.parse(
-        result.sdkOptions.extraArgs?.["mcp-config"] as string,
-      );
-      expect(mcpConfig.mcpServers).toHaveProperty("server1");
-      expect(mcpConfig.mcpServers).toHaveProperty("server2");
-      expect(result.sdkOptions.extraArgs?.["model"]).toBe("claude-3-5-sonnet");
-    });
-
-    test("should handle real-world scenario: action config + user config", () => {
-      // This is the exact scenario from the bug report
-      const actionConfig = JSON.stringify({
-        mcpServers: {
-          github_comment: {
-            command: "node",
-            args: ["github-comment-server.js"],
-          },
-          github_ci: { command: "node", args: ["github-ci-server.js"] },
-        },
-      });
-      const userConfig = JSON.stringify({
-        mcpServers: {
-          my_custom_server: { command: "python", args: ["server.py"] },
-        },
-      });
-
-      const options: ClaudeOptions = {
-        claudeArgs: `--mcp-config '${actionConfig}' --mcp-config '${userConfig}'`,
-      };
-
-      const result = parseSdkOptions(options);
-
-      const mcpConfig = JSON.parse(
-        result.sdkOptions.extraArgs?.["mcp-config"] as string,
-      );
-      // All servers should be present
-      expect(mcpConfig.mcpServers).toHaveProperty("github_comment");
-      expect(mcpConfig.mcpServers).toHaveProperty("github_ci");
-      expect(mcpConfig.mcpServers).toHaveProperty("my_custom_server");
-    });
-  });
-
  describe("other extraArgs passthrough", () => {
+    test("should pass through mcp-config in extraArgs", () => {
+      const options: ClaudeOptions = {
+        claudeArgs: `--mcp-config '{"mcpServers":{}}' --allowedTools "Edit"`,
+      };
+
+      const result = parseSdkOptions(options);
+
+      expect(result.sdkOptions.extraArgs?.["mcp-config"]).toBe(
+        '{"mcpServers":{}}',
+      );
+    });
+
    test("should pass through json-schema in extraArgs", () => {
      const options: ClaudeOptions = {
        claudeArgs: `--json-schema '{"type":"object"}'`,
@ -312,114 +160,4 @@ describe("parseSdkOptions", () => {
      expect(result.hasJsonSchema).toBe(true);
    });
  });
-
-  describe("shell comment stripping", () => {
-    test("should parse flags before and after a comment line", () => {
-      const options: ClaudeOptions = {
-        claudeArgs: "--model 'claude-haiku'\n# comment\n--allowed-tools 'Edit'",
-      };
-
-      const result = parseSdkOptions(options);
-
-      expect(result.sdkOptions.extraArgs?.["model"]).toBe("claude-haiku");
-      expect(result.sdkOptions.allowedTools).toEqual(["Edit"]);
-    });
-
-    test("should parse flags correctly when no comments are present", () => {
-      const options: ClaudeOptions = {
-        claudeArgs: "--model 'claude-haiku'",
-      };
-
-      const result = parseSdkOptions(options);
-
-      expect(result.sdkOptions.extraArgs?.["model"]).toBe("claude-haiku");
-    });
-
-    test("should not strip inline # that appears inside a quoted value", () => {
-      const options: ClaudeOptions = {
-        claudeArgs: "--model 'claude-haiku' --prompt 'use color #ff0000'",
-      };
-
-      const result = parseSdkOptions(options);
-
-      expect(result.sdkOptions.extraArgs?.["model"]).toBe("claude-haiku");
-      expect(result.sdkOptions.extraArgs?.["prompt"]).toBe("use color #ff0000");
-    });
-  });
-
-  describe("environment variables passthrough", () => {
-    test("should include OTEL environment variables in sdkOptions.env", () => {
-      // Set up test environment variables
-      const originalEnv = { ...process.env };
-      process.env.CLAUDE_CODE_ENABLE_TELEMETRY = "1";
-      process.env.OTEL_METRICS_EXPORTER = "otlp";
-      process.env.OTEL_LOGS_EXPORTER = "otlp";
-      process.env.OTEL_EXPORTER_OTLP_PROTOCOL = "http/json";
-      process.env.OTEL_EXPORTER_OTLP_ENDPOINT = "https://example.com";
-      process.env.OTEL_EXPORTER_OTLP_HEADERS =
-        "Authorization=Bearer test-token";
-      process.env.OTEL_METRIC_EXPORT_INTERVAL = "10000";
-      process.env.OTEL_LOGS_EXPORT_INTERVAL = "5000";
-      process.env.OTEL_RESOURCE_ATTRIBUTES = "department=test";
-
-      try {
-        const options: ClaudeOptions = {};
-        const result = parseSdkOptions(options);
-
-        // Verify OTEL env vars are passed through to sdkOptions.env
-        expect(result.sdkOptions.env?.CLAUDE_CODE_ENABLE_TELEMETRY).toBe("1");
-        expect(result.sdkOptions.env?.OTEL_METRICS_EXPORTER).toBe("otlp");
-        expect(result.sdkOptions.env?.OTEL_LOGS_EXPORTER).toBe("otlp");
-        expect(result.sdkOptions.env?.OTEL_EXPORTER_OTLP_PROTOCOL).toBe(
-          "http/json",
-        );
-        expect(result.sdkOptions.env?.OTEL_EXPORTER_OTLP_ENDPOINT).toBe(
-          "https://example.com",
-        );
-        expect(result.sdkOptions.env?.OTEL_EXPORTER_OTLP_HEADERS).toBe(
-          "Authorization=Bearer test-token",
-        );
-        expect(result.sdkOptions.env?.OTEL_METRIC_EXPORT_INTERVAL).toBe(
-          "10000",
-        );
-        expect(result.sdkOptions.env?.OTEL_LOGS_EXPORT_INTERVAL).toBe("5000");
-        expect(result.sdkOptions.env?.OTEL_RESOURCE_ATTRIBUTES).toBe(
-          "department=test",
-        );
-      } finally {
-        // Restore original environment
-        process.env = originalEnv;
-      }
-    });
-
-    test("should set CLAUDE_CODE_ENTRYPOINT in sdkOptions.env", () => {
-      const options: ClaudeOptions = {};
-      const result = parseSdkOptions(options);
-
-      expect(result.sdkOptions.env?.CLAUDE_CODE_ENTRYPOINT).toBe(
-        "claude-code-github-action",
-      );
-    });
-
-    test("should strip ACTIONS_ID_TOKEN_REQUEST_URL and ACTIONS_ID_TOKEN_REQUEST_TOKEN from env", () => {
-      const originalEnv = { ...process.env };
-      process.env.ACTIONS_ID_TOKEN_REQUEST_URL =
-        "https://token.actions.githubusercontent.com";
-      process.env.ACTIONS_ID_TOKEN_REQUEST_TOKEN = "secret-token-value";
-
-      try {
-        const options: ClaudeOptions = {};
-        const result = parseSdkOptions(options);
-
-        expect(
-          result.sdkOptions.env?.ACTIONS_ID_TOKEN_REQUEST_URL,
-        ).toBeUndefined();
-        expect(
-          result.sdkOptions.env?.ACTIONS_ID_TOKEN_REQUEST_TOKEN,
-        ).toBeUndefined();
-      } finally {
-        process.env = originalEnv;
-      }
-    });
-  });
 });
--- a/base-action/test/run-claude.test.ts
+++ b/base-action/test/run-claude.test.ts
@ -0,0 +1,96 @@
+#!/usr/bin/env bun
+
+import { describe, test, expect } from "bun:test";
+import { prepareRunConfig, type ClaudeOptions } from "../src/run-claude";
+
+describe("prepareRunConfig", () => {
+  test("should prepare config with basic arguments", () => {
+    const options: ClaudeOptions = {};
+    const prepared = prepareRunConfig("/tmp/test-prompt.txt", options);
+
+    expect(prepared.claudeArgs).toEqual([
+      "-p",
+      "--verbose",
+      "--output-format",
+      "stream-json",
+    ]);
+  });
+
+  test("should include promptPath", () => {
+    const options: ClaudeOptions = {};
+    const prepared = prepareRunConfig("/tmp/test-prompt.txt", options);
+
+    expect(prepared.promptPath).toBe("/tmp/test-prompt.txt");
+  });
+
+  test("should use provided prompt path", () => {
+    const options: ClaudeOptions = {};
+    const prepared = prepareRunConfig("/custom/prompt/path.txt", options);
+
+    expect(prepared.promptPath).toBe("/custom/prompt/path.txt");
+  });
+
+  describe("claudeArgs handling", () => {
+    test("should parse and include custom claude arguments", () => {
+      const options: ClaudeOptions = {
+        claudeArgs: "--max-turns 10 --model claude-3-opus-20240229",
+      };
+      const prepared = prepareRunConfig("/tmp/test-prompt.txt", options);
+
+      expect(prepared.claudeArgs).toEqual([
+        "-p",
+        "--max-turns",
+        "10",
+        "--model",
+        "claude-3-opus-20240229",
+        "--verbose",
+        "--output-format",
+        "stream-json",
+      ]);
+    });
+
+    test("should handle empty claudeArgs", () => {
+      const options: ClaudeOptions = {
+        claudeArgs: "",
+      };
+      const prepared = prepareRunConfig("/tmp/test-prompt.txt", options);
+
+      expect(prepared.claudeArgs).toEqual([
+        "-p",
+        "--verbose",
+        "--output-format",
+        "stream-json",
+      ]);
+    });
+
+    test("should handle claudeArgs with quoted strings", () => {
+      const options: ClaudeOptions = {
+        claudeArgs: '--system-prompt "You are a helpful assistant"',
+      };
+      const prepared = prepareRunConfig("/tmp/test-prompt.txt", options);
+
+      expect(prepared.claudeArgs).toEqual([
+        "-p",
+        "--system-prompt",
+        "You are a helpful assistant",
+        "--verbose",
+        "--output-format",
+        "stream-json",
+      ]);
+    });
+
+    test("should include json-schema flag when provided", () => {
+      const options: ClaudeOptions = {
+        claudeArgs:
+          '--json-schema \'{"type":"object","properties":{"result":{"type":"boolean"}}}\'',
+      };
+
+      const prepared = prepareRunConfig("/tmp/test-prompt.txt", options);
+
+      expect(prepared.claudeArgs).toContain("--json-schema");
+      expect(prepared.claudeArgs).toContain(
+        '{"type":"object","properties":{"result":{"type":"boolean"}}}',
+      );
+    });
+  });
+});
--- a/base-action/test/structured-output.test.ts
+++ b/base-action/test/structured-output.test.ts
@ -0,0 +1,227 @@
+#!/usr/bin/env bun
+
+import { describe, test, expect, afterEach, beforeEach, spyOn } from "bun:test";
+import { writeFile, unlink } from "fs/promises";
+import { tmpdir } from "os";
+import { join } from "path";
+import {
+  parseAndSetStructuredOutputs,
+  parseAndSetSessionId,
+} from "../src/run-claude";
+import * as core from "@actions/core";
+
+// Mock execution file path
+const TEST_EXECUTION_FILE = join(tmpdir(), "test-execution-output.json");
+
+// Helper to create mock execution file with structured output
+async function createMockExecutionFile(
+  structuredOutput?: Record<string, unknown>,
+  includeResult: boolean = true,
+): Promise<void> {
+  const messages: any[] = [
+    { type: "system", subtype: "init" },
+    { type: "turn", content: "test" },
+  ];
+
+  if (includeResult) {
+    messages.push({
+      type: "result",
+      cost_usd: 0.01,
+      duration_ms: 1000,
+      structured_output: structuredOutput,
+    });
+  }
+
+  await writeFile(TEST_EXECUTION_FILE, JSON.stringify(messages));
+}
+
+// Spy on core functions
+let setOutputSpy: any;
+let infoSpy: any;
+let warningSpy: any;
+
+beforeEach(() => {
+  setOutputSpy = spyOn(core, "setOutput").mockImplementation(() => {});
+  infoSpy = spyOn(core, "info").mockImplementation(() => {});
+  warningSpy = spyOn(core, "warning").mockImplementation(() => {});
+});
+
+describe("parseAndSetStructuredOutputs", () => {
+  afterEach(async () => {
+    setOutputSpy?.mockRestore();
+    infoSpy?.mockRestore();
+    warningSpy?.mockRestore();
+    try {
+      await unlink(TEST_EXECUTION_FILE);
+    } catch {
+      // Ignore if file doesn't exist
+    }
+  });
+
+  test("should set structured_output with valid data", async () => {
+    await createMockExecutionFile({
+      is_flaky: true,
+      confidence: 0.85,
+      summary: "Test looks flaky",
+    });
+
+    await parseAndSetStructuredOutputs(TEST_EXECUTION_FILE);
+
+    expect(setOutputSpy).toHaveBeenCalledWith(
+      "structured_output",
+      '{"is_flaky":true,"confidence":0.85,"summary":"Test looks flaky"}',
+    );
+    expect(infoSpy).toHaveBeenCalledWith(
+      "Set structured_output with 3 field(s)",
+    );
+  });
+
+  test("should handle arrays and nested objects", async () => {
+    await createMockExecutionFile({
+      items: ["a", "b", "c"],
+      config: { key: "value", nested: { deep: true } },
+    });
+
+    await parseAndSetStructuredOutputs(TEST_EXECUTION_FILE);
+
+    const callArgs = setOutputSpy.mock.calls[0];
+    expect(callArgs[0]).toBe("structured_output");
+    const parsed = JSON.parse(callArgs[1]);
+    expect(parsed).toEqual({
+      items: ["a", "b", "c"],
+      config: { key: "value", nested: { deep: true } },
+    });
+  });
+
+  test("should handle special characters in field names", async () => {
+    await createMockExecutionFile({
+      "test-result": "passed",
+      "item.count": 10,
+      "user@email": "test",
+    });
+
+    await parseAndSetStructuredOutputs(TEST_EXECUTION_FILE);
+
+    const callArgs = setOutputSpy.mock.calls[0];
+    const parsed = JSON.parse(callArgs[1]);
+    expect(parsed["test-result"]).toBe("passed");
+    expect(parsed["item.count"]).toBe(10);
+    expect(parsed["user@email"]).toBe("test");
+  });
+
+  test("should throw error when result exists but structured_output is undefined", async () => {
+    const messages = [
+      { type: "system", subtype: "init" },
+      { type: "result", cost_usd: 0.01, duration_ms: 1000 },
+    ];
+    await writeFile(TEST_EXECUTION_FILE, JSON.stringify(messages));
+
+    await expect(
+      parseAndSetStructuredOutputs(TEST_EXECUTION_FILE),
+    ).rejects.toThrow(
+      "--json-schema was provided but Claude did not return structured_output",
+    );
+  });
+
+  test("should throw error when no result message exists", async () => {
+    const messages = [
+      { type: "system", subtype: "init" },
+      { type: "turn", content: "test" },
+    ];
+    await writeFile(TEST_EXECUTION_FILE, JSON.stringify(messages));
+
+    await expect(
+      parseAndSetStructuredOutputs(TEST_EXECUTION_FILE),
+    ).rejects.toThrow(
+      "--json-schema was provided but Claude did not return structured_output",
+    );
+  });
+
+  test("should throw error with malformed JSON", async () => {
+    await writeFile(TEST_EXECUTION_FILE, "{ invalid json");
+
+    await expect(
+      parseAndSetStructuredOutputs(TEST_EXECUTION_FILE),
+    ).rejects.toThrow();
+  });
+
+  test("should throw error when file does not exist", async () => {
+    await expect(
+      parseAndSetStructuredOutputs("/nonexistent/file.json"),
+    ).rejects.toThrow();
+  });
+
+  test("should handle empty structured_output object", async () => {
+    await createMockExecutionFile({});
+
+    await parseAndSetStructuredOutputs(TEST_EXECUTION_FILE);
+
+    expect(setOutputSpy).toHaveBeenCalledWith("structured_output", "{}");
+    expect(infoSpy).toHaveBeenCalledWith(
+      "Set structured_output with 0 field(s)",
+    );
+  });
+});
+
+describe("parseAndSetSessionId", () => {
+  afterEach(async () => {
+    setOutputSpy?.mockRestore();
+    infoSpy?.mockRestore();
+    warningSpy?.mockRestore();
+    try {
+      await unlink(TEST_EXECUTION_FILE);
+    } catch {
+      // Ignore if file doesn't exist
+    }
+  });
+
+  test("should extract session_id from system.init message", async () => {
+    const messages = [
+      { type: "system", subtype: "init", session_id: "test-session-123" },
+      { type: "result", cost_usd: 0.01 },
+    ];
+    await writeFile(TEST_EXECUTION_FILE, JSON.stringify(messages));
+
+    await parseAndSetSessionId(TEST_EXECUTION_FILE);
+
+    expect(setOutputSpy).toHaveBeenCalledWith("session_id", "test-session-123");
+    expect(infoSpy).toHaveBeenCalledWith("Set session_id: test-session-123");
+  });
+
+  test("should handle missing session_id gracefully", async () => {
+    const messages = [
+      { type: "system", subtype: "init" },
+      { type: "result", cost_usd: 0.01 },
+    ];
+    await writeFile(TEST_EXECUTION_FILE, JSON.stringify(messages));
+
+    await parseAndSetSessionId(TEST_EXECUTION_FILE);
+
+    expect(setOutputSpy).not.toHaveBeenCalled();
+  });
+
+  test("should handle missing system.init message gracefully", async () => {
+    const messages = [{ type: "result", cost_usd: 0.01 }];
+    await writeFile(TEST_EXECUTION_FILE, JSON.stringify(messages));
+
+    await parseAndSetSessionId(TEST_EXECUTION_FILE);
+
+    expect(setOutputSpy).not.toHaveBeenCalled();
+  });
+
+  test("should handle malformed JSON gracefully with warning", async () => {
+    await writeFile(TEST_EXECUTION_FILE, "{ invalid json");
+
+    await parseAndSetSessionId(TEST_EXECUTION_FILE);
+
+    expect(setOutputSpy).not.toHaveBeenCalled();
+    expect(warningSpy).toHaveBeenCalled();
+  });
+
+  test("should handle non-existent file gracefully with warning", async () => {
+    await parseAndSetSessionId("/nonexistent/file.json");
+
+    expect(setOutputSpy).not.toHaveBeenCalled();
+    expect(warningSpy).toHaveBeenCalled();
+  });
+});
--- a/bun.lock
+++ b/bun.lock
@ -1,13 +1,12 @@
 {
  "lockfileVersion": 1,
-  "configVersion": 0,
  "workspaces": {
    "": {
      "name": "@anthropic-ai/claude-code-action",
      "dependencies": {
        "@actions/core": "^1.10.1",
        "@actions/github": "^6.0.1",
-        "@anthropic-ai/claude-agent-sdk": "^0.2.123",
+        "@anthropic-ai/claude-agent-sdk": "^0.1.52",
        "@modelcontextprotocol/sdk": "^1.11.0",
        "@octokit/graphql": "^8.2.2",
        "@octokit/rest": "^21.1.1",
@ -37,31 +36,39 @@

    "@actions/io": ["@actions/io@1.1.3", "", {}, "sha512-wi9JjgKLYS7U/z8PPbco+PvTb/nRWjeoFlJ1Qer83k/3C5PHQi28hiVdeE2kHXmIL99mQFawx8qt/JPjZilJ8Q=="],

-    "@anthropic-ai/claude-agent-sdk": ["@anthropic-ai/claude-agent-sdk@0.2.123", "", { "dependencies": { "@anthropic-ai/sdk": "^0.81.0", "@modelcontextprotocol/sdk": "^1.29.0" }, "optionalDependencies": { "@anthropic-ai/claude-agent-sdk-darwin-arm64": "0.2.123", "@anthropic-ai/claude-agent-sdk-darwin-x64": "0.2.123", "@anthropic-ai/claude-agent-sdk-linux-arm64": "0.2.123", "@anthropic-ai/claude-agent-sdk-linux-arm64-musl": "0.2.123", "@anthropic-ai/claude-agent-sdk-linux-x64": "0.2.123", "@anthropic-ai/claude-agent-sdk-linux-x64-musl": "0.2.123", "@anthropic-ai/claude-agent-sdk-win32-arm64": "0.2.123", "@anthropic-ai/claude-agent-sdk-win32-x64": "0.2.123" }, "peerDependencies": { "zod": "^4.0.0" } }, "sha512-a4TysYoR9DBdkM9Uwh4J5ub7TwKmRPe5hFiWh4En+IKC+qkk5UFkxFM22c//cZjYZKynHX0ah2t6LUqb+najYA=="],
-
-    "@anthropic-ai/claude-agent-sdk-darwin-arm64": ["@anthropic-ai/claude-agent-sdk-darwin-arm64@0.2.123", "", { "os": "darwin", "cpu": "arm64" }, "sha512-tYAXCjlXZQklsUs0J//gip3fZQRzhlH5OCgvNXV70qe7A1iiwHqO2KPGvEHV1L+deEKQoMZmTaCOrQpN6zju3w=="],
-
-    "@anthropic-ai/claude-agent-sdk-darwin-x64": ["@anthropic-ai/claude-agent-sdk-darwin-x64@0.2.123", "", { "os": "darwin", "cpu": "x64" }, "sha512-AcUC6sTon6z6HculP87KsAOeTMRLBwpovdhcXUTjXUpo/8nplJ7lBEzWjZCHt8FF1KuN/WBy1Z4bDg/59TQDmA=="],
-
-    "@anthropic-ai/claude-agent-sdk-linux-arm64": ["@anthropic-ai/claude-agent-sdk-linux-arm64@0.2.123", "", { "os": "linux", "cpu": "arm64" }, "sha512-7+GnbcF3/aZ8RJ1WmU/ogtPsOpknBAoUPer90MvZuFYBLPT9iI/U7f24gjrOHuYdcbDA5n7jFlhcfIO26F5DJQ=="],
-
-    "@anthropic-ai/claude-agent-sdk-linux-arm64-musl": ["@anthropic-ai/claude-agent-sdk-linux-arm64-musl@0.2.123", "", { "os": "linux", "cpu": "arm64" }, "sha512-bYgRiaf2q+yVbGAoUluuhqrEW1zexL34+3HDmK9DneKXa2K2EJpw4M6Sq4XoBD/JezGaemoAP78Xv/M/QUS1OQ=="],
-
-    "@anthropic-ai/claude-agent-sdk-linux-x64": ["@anthropic-ai/claude-agent-sdk-linux-x64@0.2.123", "", { "os": "linux", "cpu": "x64" }, "sha512-Xi+Rwk8uP5vWEnawJOlsk179fr0ATLl5J90MlbLj+puKaX5svEq8ljS+P3zq6zHTJeKh9GKLzPf7bc5YJKwcew=="],
-
-    "@anthropic-ai/claude-agent-sdk-linux-x64-musl": ["@anthropic-ai/claude-agent-sdk-linux-x64-musl@0.2.123", "", { "os": "linux", "cpu": "x64" }, "sha512-IX95lFKhmmndY/YPfWPsVV+C3rLYJmuuq5wCS53p6jYIkCMxH1iGfhBGF1EUWcXO4Uc8yqXFmQ3aaxMzOOPrwA=="],
-
-    "@anthropic-ai/claude-agent-sdk-win32-arm64": ["@anthropic-ai/claude-agent-sdk-win32-arm64@0.2.123", "", { "os": "win32", "cpu": "arm64" }, "sha512-WDZmAQG1rOiqNLZlSXaCjSWmqJvLk2io+vFQWWqSy2b5HCk9pa3PadLiaLztiihyk81wPhH9Q/44kOxdyfEGMw=="],
-
-    "@anthropic-ai/claude-agent-sdk-win32-x64": ["@anthropic-ai/claude-agent-sdk-win32-x64@0.2.123", "", { "os": "win32", "cpu": "x64" }, "sha512-588xrd1i6d4kXQ6FqwL+cgBiN4evRQSi5DCtPa02CZ3VEbuVQBeFlyPlD8tfWtNNeGZ4NM8kjPNNzZz5omezPA=="],
-
-    "@anthropic-ai/sdk": ["@anthropic-ai/sdk@0.81.0", "", { "dependencies": { "json-schema-to-ts": "^3.1.1" }, "peerDependencies": { "zod": "^3.25.0 || ^4.0.0" }, "optionalPeers": ["zod"], "bin": { "anthropic-ai-sdk": "bin/cli" } }, "sha512-D4K5PvEV6wPiRtVlVsJHIUhHAmOZ6IT/I9rKlTf84gR7GyyAurPJK7z9BOf/AZqC5d1DhYQGJNKRmV+q8dGhgw=="],
-
-    "@babel/runtime": ["@babel/runtime@7.29.2", "", {}, "sha512-JiDShH45zKHWyGe4ZNVRrCjBz8Nh9TMmZG1kh4QTK8hCBTWBi8Da+i7s1fJw7/lYpM4ccepSNfqzZ/QvABBi5g=="],
+    "@anthropic-ai/claude-agent-sdk": ["@anthropic-ai/claude-agent-sdk@0.1.52", "", { "optionalDependencies": { "@img/sharp-darwin-arm64": "^0.33.5", "@img/sharp-darwin-x64": "^0.33.5", "@img/sharp-linux-arm": "^0.33.5", "@img/sharp-linux-arm64": "^0.33.5", "@img/sharp-linux-x64": "^0.33.5", "@img/sharp-linuxmusl-arm64": "^0.33.5", "@img/sharp-linuxmusl-x64": "^0.33.5", "@img/sharp-win32-x64": "^0.33.5" }, "peerDependencies": { "zod": "^3.24.1" } }, "sha512-yF8N05+9NRbqYA/h39jQ726HTQFrdXXp7pEfDNKIJ2c4FdWvEjxBA/8ciZIebN6/PyvGDcbEp3yq2Co4rNpg6A=="],

    "@fastify/busboy": ["@fastify/busboy@2.1.1", "", {}, "sha512-vBZP4NlzfOlerQTnba4aqZoMhE/a9HY7HRqoOPaETQcSQuWEIyZMHGfVu6w9wGtGK5fED5qRs2DteVCjOH60sA=="],

-    "@hono/node-server": ["@hono/node-server@1.19.11", "", { "peerDependencies": { "hono": "^4" } }, "sha512-dr8/3zEaB+p0D2n/IUrlPF1HZm586qgJNXK1a9fhg/PzdtkK7Ksd5l312tJX2yBuALqDYBlG20QEbayqPyxn+g=="],
+    "@img/sharp-darwin-arm64": ["@img/sharp-darwin-arm64@0.33.5", "", { "optionalDependencies": { "@img/sharp-libvips-darwin-arm64": "1.0.4" }, "os": "darwin", "cpu": "arm64" }, "sha512-UT4p+iz/2H4twwAoLCqfA9UH5pI6DggwKEGuaPy7nCVQ8ZsiY5PIcrRvD1DzuY3qYL07NtIQcWnBSY/heikIFQ=="],
+
+    "@img/sharp-darwin-x64": ["@img/sharp-darwin-x64@0.33.5", "", { "optionalDependencies": { "@img/sharp-libvips-darwin-x64": "1.0.4" }, "os": "darwin", "cpu": "x64" }, "sha512-fyHac4jIc1ANYGRDxtiqelIbdWkIuQaI84Mv45KvGRRxSAa7o7d1ZKAOBaYbnepLC1WqxfpimdeWfvqqSGwR2Q=="],
+
+    "@img/sharp-libvips-darwin-arm64": ["@img/sharp-libvips-darwin-arm64@1.0.4", "", { "os": "darwin", "cpu": "arm64" }, "sha512-XblONe153h0O2zuFfTAbQYAX2JhYmDHeWikp1LM9Hul9gVPjFY427k6dFEcOL72O01QxQsWi761svJ/ev9xEDg=="],
+
+    "@img/sharp-libvips-darwin-x64": ["@img/sharp-libvips-darwin-x64@1.0.4", "", { "os": "darwin", "cpu": "x64" }, "sha512-xnGR8YuZYfJGmWPvmlunFaWJsb9T/AO2ykoP3Fz/0X5XV2aoYBPkX6xqCQvUTKKiLddarLaxpzNe+b1hjeWHAQ=="],
+
+    "@img/sharp-libvips-linux-arm": ["@img/sharp-libvips-linux-arm@1.0.5", "", { "os": "linux", "cpu": "arm" }, "sha512-gvcC4ACAOPRNATg/ov8/MnbxFDJqf/pDePbBnuBDcjsI8PssmjoKMAz4LtLaVi+OnSb5FK/yIOamqDwGmXW32g=="],
+
+    "@img/sharp-libvips-linux-arm64": ["@img/sharp-libvips-linux-arm64@1.0.4", "", { "os": "linux", "cpu": "arm64" }, "sha512-9B+taZ8DlyyqzZQnoeIvDVR/2F4EbMepXMc/NdVbkzsJbzkUjhXv/70GQJ7tdLA4YJgNP25zukcxpX2/SueNrA=="],
+
+    "@img/sharp-libvips-linux-x64": ["@img/sharp-libvips-linux-x64@1.0.4", "", { "os": "linux", "cpu": "x64" }, "sha512-MmWmQ3iPFZr0Iev+BAgVMb3ZyC4KeFc3jFxnNbEPas60e1cIfevbtuyf9nDGIzOaW9PdnDciJm+wFFaTlj5xYw=="],
+
+    "@img/sharp-libvips-linuxmusl-arm64": ["@img/sharp-libvips-linuxmusl-arm64@1.0.4", "", { "os": "linux", "cpu": "arm64" }, "sha512-9Ti+BbTYDcsbp4wfYib8Ctm1ilkugkA/uscUn6UXK1ldpC1JjiXbLfFZtRlBhjPZ5o1NCLiDbg8fhUPKStHoTA=="],
+
+    "@img/sharp-libvips-linuxmusl-x64": ["@img/sharp-libvips-linuxmusl-x64@1.0.4", "", { "os": "linux", "cpu": "x64" }, "sha512-viYN1KX9m+/hGkJtvYYp+CCLgnJXwiQB39damAO7WMdKWlIhmYTfHjwSbQeUK/20vY154mwezd9HflVFM1wVSw=="],
+
+    "@img/sharp-linux-arm": ["@img/sharp-linux-arm@0.33.5", "", { "optionalDependencies": { "@img/sharp-libvips-linux-arm": "1.0.5" }, "os": "linux", "cpu": "arm" }, "sha512-JTS1eldqZbJxjvKaAkxhZmBqPRGmxgu+qFKSInv8moZ2AmT5Yib3EQ1c6gp493HvrvV8QgdOXdyaIBrhvFhBMQ=="],
+
+    "@img/sharp-linux-arm64": ["@img/sharp-linux-arm64@0.33.5", "", { "optionalDependencies": { "@img/sharp-libvips-linux-arm64": "1.0.4" }, "os": "linux", "cpu": "arm64" }, "sha512-JMVv+AMRyGOHtO1RFBiJy/MBsgz0x4AWrT6QoEVVTyh1E39TrCUpTRI7mx9VksGX4awWASxqCYLCV4wBZHAYxA=="],
+
+    "@img/sharp-linux-x64": ["@img/sharp-linux-x64@0.33.5", "", { "optionalDependencies": { "@img/sharp-libvips-linux-x64": "1.0.4" }, "os": "linux", "cpu": "x64" }, "sha512-opC+Ok5pRNAzuvq1AG0ar+1owsu842/Ab+4qvU879ippJBHvyY5n2mxF1izXqkPYlGuP/M556uh53jRLJmzTWA=="],
+
+    "@img/sharp-linuxmusl-arm64": ["@img/sharp-linuxmusl-arm64@0.33.5", "", { "optionalDependencies": { "@img/sharp-libvips-linuxmusl-arm64": "1.0.4" }, "os": "linux", "cpu": "arm64" }, "sha512-XrHMZwGQGvJg2V/oRSUfSAfjfPxO+4DkiRh6p2AFjLQztWUuY/o8Mq0eMQVIY7HJ1CDQUJlxGGZRw1a5bqmd1g=="],
+
+    "@img/sharp-linuxmusl-x64": ["@img/sharp-linuxmusl-x64@0.33.5", "", { "optionalDependencies": { "@img/sharp-libvips-linuxmusl-x64": "1.0.4" }, "os": "linux", "cpu": "x64" }, "sha512-WT+d/cgqKkkKySYmqoZ8y3pxx7lx9vVejxW/W4DOFMYVSkErR+w7mf2u8m/y4+xHe7yY9DAXQMWQhpnMuFfScw=="],
+
+    "@img/sharp-win32-x64": ["@img/sharp-win32-x64@0.33.5", "", { "os": "win32", "cpu": "x64" }, "sha512-MpY/o8/8kj+EcnxwvrP4aTJSWw/aZ7JIGR4aBeZkZw5B7/Jn+tY9/VNwtcoGmdT7GfggGIU4kygOMSbYnOrAbg=="],

    "@modelcontextprotocol/sdk": ["@modelcontextprotocol/sdk@1.16.0", "", { "dependencies": { "ajv": "^6.12.6", "content-type": "^1.0.5", "cors": "^2.8.5", "cross-spawn": "^7.0.5", "eventsource": "^3.0.2", "eventsource-parser": "^3.0.0", "express": "^5.0.1", "express-rate-limit": "^7.5.0", "pkce-challenge": "^5.0.0", "raw-body": "^3.0.0", "zod": "^3.23.8", "zod-to-json-schema": "^3.24.1" } }, "sha512-8ofX7gkZcLj9H9rSd50mCgm3SSF8C7XoclxJuLoV0Cz3rEQ1tv9MZRYYvJtm9n1BiEQQMzSmE/w2AEkNacLYfg=="],

@ -103,8 +110,6 @@

    "ajv": ["ajv@6.12.6", "", { "dependencies": { "fast-deep-equal": "^3.1.1", "fast-json-stable-stringify": "^2.0.0", "json-schema-traverse": "^0.4.1", "uri-js": "^4.2.2" } }, "sha512-j3fVLgvTo527anyYyJOGTYJbG+vnnQYvE0m5mmkc1TK+nxAppkCLMIL0aZ4dblVCNoGShhm+kzE4ZUykBoMg4g=="],

-    "ajv-formats": ["ajv-formats@3.0.1", "", { "dependencies": { "ajv": "^8.0.0" } }, "sha512-8iUql50EUR+uUcdRQ3HDqa6EVyo3docL8g5WJ3FNcWmu62IbkGUue/pEyLBW8VGKKucTPgqeks4fIU1DA4yowQ=="],
-
    "asynckit": ["asynckit@0.4.0", "", {}, "sha512-Oei9OH4tRh0YqU3GxhX79dM/mwVgvbZJaSNaRk+bshkj0S5cfHcgYakreBjrHwatXKbz+IoIdYLxrKim2MjW0Q=="],

    "before-after-hook": ["before-after-hook@2.2.3", "", {}, "sha512-NzUnlZexiaH/46WDhANlyR2bXRopNg4F/zuSA3OpZnllCUgRaOF2znDioDWrmbNVsuZk6l9pMquQB38cfBZwkQ=="],
@ -175,8 +180,6 @@

    "fast-json-stable-stringify": ["fast-json-stable-stringify@2.1.0", "", {}, "sha512-lhd/wF+Lk98HZoTCtlVraHtfh5XYijIjalXck7saUtuanSDyLMxnHhSXEDJqHxD7msR8D0uCmqlkwjCV8xvwHw=="],

-    "fast-uri": ["fast-uri@3.1.0", "", {}, "sha512-iPeeDKJSWf4IEOasVVrknXpaBV0IApz/gp7S2bb7Z4Lljbl2MGJRqInZiUrQwV16cpzw/D3S5j5Julj/gT52AA=="],
-
    "fetch-blob": ["fetch-blob@3.2.0", "", { "dependencies": { "node-domexception": "^1.0.0", "web-streams-polyfill": "^3.0.3" } }, "sha512-7yAQpD2UMJzLi1Dqv7qFYnPbaPx7ZfFK6PiIxQ4PfkGPyNyl2Ugx+a/umUonmKqjhM4DnfbMvdX6otXq83soQQ=="],

    "finalhandler": ["finalhandler@2.1.0", "", { "dependencies": { "debug": "^4.4.0", "encodeurl": "^2.0.0", "escape-html": "^1.0.3", "on-finished": "^2.4.1", "parseurl": "^1.3.3", "statuses": "^2.0.1" } }, "sha512-/t88Ty3d5JWQbWYgaOGCCYfXRwV1+be02WqYYlL6h0lEiUAMPM8o8qKGO01YIkOHzka2up08wvgYD0mDiI+q3Q=="],
@ -203,30 +206,20 @@

    "hasown": ["hasown@2.0.2", "", { "dependencies": { "function-bind": "^1.1.2" } }, "sha512-0hJU9SCPvmMzIBdZFqNPXWa6dqh7WdH0cII9y+CyS8rG3nL48Bclra9HmKhVVUHyPWNH5Y7xDwAB7bfgSjkUMQ=="],

-    "hono": ["hono@4.12.9", "", {}, "sha512-wy3T8Zm2bsEvxKZM5w21VdHDDcwVS1yUFFY6i8UobSsKfFceT7TOwhbhfKsDyx7tYQlmRM5FLpIuYvNFyjctiA=="],
-
    "http-errors": ["http-errors@2.0.0", "", { "dependencies": { "depd": "2.0.0", "inherits": "2.0.4", "setprototypeof": "1.2.0", "statuses": "2.0.1", "toidentifier": "1.0.1" } }, "sha512-FtwrG/euBzaEjYeRqOgly7G0qviiXoJWnvEH2Z1plBdXgbyjv34pHTSb9zoeHMyDy33+DWy5Wt9Wo+TURtOYSQ=="],

    "iconv-lite": ["iconv-lite@0.6.3", "", { "dependencies": { "safer-buffer": ">= 2.1.2 < 3.0.0" } }, "sha512-4fCk79wshMdzMp2rH06qWrJE4iolqLhCUH+OiuIgU++RB0+94NlDL81atO7GX55uUKueo0txHNtvEyI6D7WdMw=="],

    "inherits": ["inherits@2.0.4", "", {}, "sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ=="],

-    "ip-address": ["ip-address@10.1.0", "", {}, "sha512-XXADHxXmvT9+CRxhXg56LJovE+bmWnEWB78LB83VZTprKTmaC5QfruXocxzTZ2Kl0DNwKuBdlIhjL8LeY8Sf8Q=="],
-
    "ipaddr.js": ["ipaddr.js@1.9.1", "", {}, "sha512-0KI/607xoxSToH7GjN1FfSbLoU0+btTicjsQSWQlh/hZykN8KpmMf7uYwPW3R+akZ6R/w18ZlXSHBYXiYUPO3g=="],

    "is-promise": ["is-promise@4.0.0", "", {}, "sha512-hvpoI6korhJMnej285dSg6nu1+e6uxs7zG3BYAm5byqDsgJNWwxzM6z6iZiAgQR4TJ30JmBTOwqZUw3WlyH3AQ=="],

    "isexe": ["isexe@2.0.0", "", {}, "sha512-RHxMLp9lnKHGHRng9QFhRCMbYAcVpn69smSGcq3f36xjgVVWThj4qqLbTLlq7Ssj8B+fIQ1EuCEGI2lKsyQeIw=="],

-    "jose": ["jose@6.2.2", "", {}, "sha512-d7kPDd34KO/YnzaDOlikGpOurfF0ByC2sEV4cANCtdqLlTfBlw2p14O/5d/zv40gJPbIQxfES3nSx1/oYNyuZQ=="],
-
-    "json-schema-to-ts": ["json-schema-to-ts@3.1.1", "", { "dependencies": { "@babel/runtime": "^7.18.3", "ts-algebra": "^2.0.0" } }, "sha512-+DWg8jCJG2TEnpy7kOm/7/AxaYoaRbjVB4LFZLySZlWn8exGs3A4OLJR966cVvU26N7X9TWxl+Jsw7dzAqKT6g=="],
-
    "json-schema-traverse": ["json-schema-traverse@0.4.1", "", {}, "sha512-xbbCH5dCYU5T8LcEhhuh7HJ88HXuW3qsI3Y0zOZFKfZEHcpWiHU/Jxzk629Brsab/mMiHQti9wMP+845RPe3Vg=="],

-    "json-schema-typed": ["json-schema-typed@8.0.2", "", {}, "sha512-fQhoXdcvc3V28x7C7BMs4P5+kNlgUURe2jmUT1T//oBRMDrqy1QPelJimwZGo7Hg9VPV3EQV5Bnq4hbFy2vetA=="],
-
    "math-intrinsics": ["math-intrinsics@1.1.0", "", {}, "sha512-/IXtbwEk5HTPyEwyKX6hGkYXxM9nbj64B+ilVJnC/R6B0pH5G4V3b0pVbL7DBj4tkhBAppbQUlf6F6Xl9LHu1g=="],

    "media-typer": ["media-typer@1.1.0", "", {}, "sha512-aisnrDP4GNe06UcKFnV5bfMNPBUw4jsLGaWwWfnH3v02GnBuXX2MCVn5RbrWo0j3pczUilYblq7fQ7Nw2t5XKw=="],
@ -273,8 +266,6 @@

    "raw-body": ["raw-body@3.0.0", "", { "dependencies": { "bytes": "3.1.2", "http-errors": "2.0.0", "iconv-lite": "0.6.3", "unpipe": "1.0.0" } }, "sha512-RmkhL8CAyCRPXCE28MMH0z2PNWQBNk2Q09ZdxM9IOOXwxwZbN+qbWaatPkdkWIKL2ZVDImrN/pK5HTRz2PcS4g=="],

-    "require-from-string": ["require-from-string@2.0.2", "", {}, "sha512-Xf0nWe6RseziFMu+Ap9biiUbmplq6S9/p+7w7YXP/JBHhrUDDUhwa+vANyubuqfZWTveU//DYVGsDG7RKL/vEw=="],
-
    "router": ["router@2.2.0", "", { "dependencies": { "debug": "^4.4.0", "depd": "^2.0.0", "is-promise": "^4.0.0", "parseurl": "^1.3.3", "path-to-regexp": "^8.0.0" } }, "sha512-nLTrUKm2UyiL7rlhapu/Zl45FwNgkZGaCpZbIHajDYgwlJCOzLSk+cIPAnsEqV955GjILJnKbdQC1nVPz+gAYQ=="],

    "safe-buffer": ["safe-buffer@5.2.1", "", {}, "sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ=="],
@ -305,8 +296,6 @@

    "toidentifier": ["toidentifier@1.0.1", "", {}, "sha512-o5sSPKEkg/DIQNmH43V0/uerLrpzVedkUh8tGNvaeXpfpuwjKenlSox/2O/BTlZUtEe+JG7s5YhEz608PlAHRA=="],

-    "ts-algebra": ["ts-algebra@2.0.0", "", {}, "sha512-FPAhNPFMrkwz76P7cdjdmiShwMynZYN6SgOujD1urY4oNm80Ou9oMdmbR45LotcKOXoy7wSmHkRFE6Mxbrhefw=="],
-
    "tunnel": ["tunnel@0.0.6", "", {}, "sha512-1h/Lnq9yajKY2PEbBadPXj3VxsDDu844OnaAo52UVmIzIvwwtBPIuNvkjuzBlTWpfJyUbG3ez0KSBibQkj4ojg=="],

    "type-is": ["type-is@2.0.1", "", { "dependencies": { "content-type": "^1.0.5", "media-typer": "^1.1.0", "mime-types": "^3.0.0" } }, "sha512-OZs6gsjF4vMp32qrCbiVSkrFmXtG/AZhY3t0iAMrMBiAZyV9oALtXO8hsrHbMXF9x6L3grlFuwW2oAz7cav+Gw=="],
@ -335,8 +324,6 @@

    "zod-to-json-schema": ["zod-to-json-schema@3.24.6", "", { "peerDependencies": { "zod": "^3.24.1" } }, "sha512-h/z3PKvcTcTetyjl1fkj79MHNEjm+HpD6NXheWjzOekY7kV+lwDYnHw+ivHkijnCSMz1yJaWBD9vu/Fcmk+vEg=="],

-    "@anthropic-ai/claude-agent-sdk/@modelcontextprotocol/sdk": ["@modelcontextprotocol/sdk@1.29.0", "", { "dependencies": { "@hono/node-server": "^1.19.9", "ajv": "^8.17.1", "ajv-formats": "^3.0.1", "content-type": "^1.0.5", "cors": "^2.8.5", "cross-spawn": "^7.0.5", "eventsource": "^3.0.2", "eventsource-parser": "^3.0.0", "express": "^5.2.1", "express-rate-limit": "^8.2.1", "hono": "^4.11.4", "jose": "^6.1.3", "json-schema-typed": "^8.0.2", "pkce-challenge": "^5.0.0", "raw-body": "^3.0.0", "zod": "^3.25 || ^4.0", "zod-to-json-schema": "^3.25.1" }, "peerDependencies": { "@cfworker/json-schema": "^4.1.1" }, "optionalPeers": ["@cfworker/json-schema"] }, "sha512-zo37mZA9hJWpULgkRpowewez1y6ML5GsXJPY8FI0tBBCd77HEvza4jDqRKOXgHNn867PVGCyTdzqpz0izu5ZjQ=="],
-
    "@octokit/core/@octokit/graphql": ["@octokit/graphql@7.1.1", "", { "dependencies": { "@octokit/request": "^8.4.1", "@octokit/types": "^13.0.0", "universal-user-agent": "^6.0.0" } }, "sha512-3mkDltSfcDUoa176nlGoA32RGjeWjl3K7F/BwHwRMJUW/IteSa4bnSV8p2ThNkcIcZU2umkZWxwETSSCJf2Q7g=="],

    "@octokit/core/@octokit/types": ["@octokit/types@13.10.0", "", { "dependencies": { "@octokit/openapi-types": "^24.2.0" } }, "sha512-ifLaO34EbbPj0Xgro4G5lP5asESjwHracYJvVaPIyXMuiuXLlhic3S47cBdTb+jfODkTE5YtGCLt3Ay3+J97sA=="],
@ -369,24 +356,12 @@

    "accepts/mime-types": ["mime-types@3.0.1", "", { "dependencies": { "mime-db": "^1.54.0" } }, "sha512-xRc4oEhT6eaBpU1XF7AjpOFD+xQmXNB5OVKwp4tqCuBpHLS/ZbBDrc07mYTDqVMg6PfxUjjNp85O6Cd2Z/5HWA=="],

-    "ajv-formats/ajv": ["ajv@8.18.0", "", { "dependencies": { "fast-deep-equal": "^3.1.3", "fast-uri": "^3.0.1", "json-schema-traverse": "^1.0.0", "require-from-string": "^2.0.2" } }, "sha512-PlXPeEWMXMZ7sPYOHqmDyCJzcfNrUr3fGNKtezX14ykXOEIvyK81d+qydx89KY5O71FKMPaQ2vBfBFI5NHR63A=="],
-
    "express/mime-types": ["mime-types@3.0.1", "", { "dependencies": { "mime-db": "^1.54.0" } }, "sha512-xRc4oEhT6eaBpU1XF7AjpOFD+xQmXNB5OVKwp4tqCuBpHLS/ZbBDrc07mYTDqVMg6PfxUjjNp85O6Cd2Z/5HWA=="],

    "send/mime-types": ["mime-types@3.0.1", "", { "dependencies": { "mime-db": "^1.54.0" } }, "sha512-xRc4oEhT6eaBpU1XF7AjpOFD+xQmXNB5OVKwp4tqCuBpHLS/ZbBDrc07mYTDqVMg6PfxUjjNp85O6Cd2Z/5HWA=="],

    "type-is/mime-types": ["mime-types@3.0.1", "", { "dependencies": { "mime-db": "^1.54.0" } }, "sha512-xRc4oEhT6eaBpU1XF7AjpOFD+xQmXNB5OVKwp4tqCuBpHLS/ZbBDrc07mYTDqVMg6PfxUjjNp85O6Cd2Z/5HWA=="],

-    "@anthropic-ai/claude-agent-sdk/@modelcontextprotocol/sdk/ajv": ["ajv@8.18.0", "", { "dependencies": { "fast-deep-equal": "^3.1.3", "fast-uri": "^3.0.1", "json-schema-traverse": "^1.0.0", "require-from-string": "^2.0.2" } }, "sha512-PlXPeEWMXMZ7sPYOHqmDyCJzcfNrUr3fGNKtezX14ykXOEIvyK81d+qydx89KY5O71FKMPaQ2vBfBFI5NHR63A=="],
-
-    "@anthropic-ai/claude-agent-sdk/@modelcontextprotocol/sdk/express": ["express@5.2.1", "", { "dependencies": { "accepts": "^2.0.0", "body-parser": "^2.2.1", "content-disposition": "^1.0.0", "content-type": "^1.0.5", "cookie": "^0.7.1", "cookie-signature": "^1.2.1", "debug": "^4.4.0", "depd": "^2.0.0", "encodeurl": "^2.0.0", "escape-html": "^1.0.3", "etag": "^1.8.1", "finalhandler": "^2.1.0", "fresh": "^2.0.0", "http-errors": "^2.0.0", "merge-descriptors": "^2.0.0", "mime-types": "^3.0.0", "on-finished": "^2.4.1", "once": "^1.4.0", "parseurl": "^1.3.3", "proxy-addr": "^2.0.7", "qs": "^6.14.0", "range-parser": "^1.2.1", "router": "^2.2.0", "send": "^1.1.0", "serve-static": "^2.2.0", "statuses": "^2.0.1", "type-is": "^2.0.1", "vary": "^1.1.2" } }, "sha512-hIS4idWWai69NezIdRt2xFVofaF4j+6INOpJlVOLDO8zXGpUVEVzIYk12UUi2JzjEzWL3IOAxcTubgz9Po0yXw=="],
-
-    "@anthropic-ai/claude-agent-sdk/@modelcontextprotocol/sdk/express-rate-limit": ["express-rate-limit@8.3.1", "", { "dependencies": { "ip-address": "10.1.0" }, "peerDependencies": { "express": ">= 4.11" } }, "sha512-D1dKN+cmyPWuvB+G2SREQDzPY1agpBIcTa9sJxOPMCNeH3gwzhqJRDWCXW3gg0y//+LQ/8j52JbMROWyrKdMdw=="],
-
-    "@anthropic-ai/claude-agent-sdk/@modelcontextprotocol/sdk/raw-body": ["raw-body@3.0.2", "", { "dependencies": { "bytes": "~3.1.2", "http-errors": "~2.0.1", "iconv-lite": "~0.7.0", "unpipe": "~1.0.0" } }, "sha512-K5zQjDllxWkf7Z5xJdV0/B0WTNqx6vxG70zJE4N0kBs4LovmEYWJzQGxC9bS9RAKu3bgM40lrd5zoLJ12MQ5BA=="],
-
-    "@anthropic-ai/claude-agent-sdk/@modelcontextprotocol/sdk/zod-to-json-schema": ["zod-to-json-schema@3.25.2", "", { "peerDependencies": { "zod": "^3.25.28 || ^4" } }, "sha512-O/PgfnpT1xKSDeQYSCfRI5Gy3hPf91mKVDuYLUHZJMiDFptvP41MSnWofm8dnCm0256ZNfZIM7DSzuSMAFnjHA=="],
-
    "@octokit/core/@octokit/types/@octokit/openapi-types": ["@octokit/openapi-types@24.2.0", "", {}, "sha512-9sIH3nSUttelJSXUrmGzl7QUBFul0/mB8HRYl3fOlgHbIWG+WnYDXU3v/2zMtAvuzZ/ed00Ei6on975FhBfzrg=="],

    "@octokit/endpoint/@octokit/types/@octokit/openapi-types": ["@octokit/openapi-types@24.2.0", "", {}, "sha512-9sIH3nSUttelJSXUrmGzl7QUBFul0/mB8HRYl3fOlgHbIWG+WnYDXU3v/2zMtAvuzZ/ed00Ei6on975FhBfzrg=="],
@ -425,24 +400,12 @@

    "accepts/mime-types/mime-db": ["mime-db@1.54.0", "", {}, "sha512-aU5EJuIN2WDemCcAp2vFBfp/m4EAhWJnUNSSw0ixs7/kXbd6Pg64EmwJkNdFhB8aWt1sH2CTXrLxo/iAGV3oPQ=="],

-    "ajv-formats/ajv/json-schema-traverse": ["json-schema-traverse@1.0.0", "", {}, "sha512-NM8/P9n3XjXhIZn1lLhkFaACTOURQXjWhV4BA/RnOv8xvgqtqpAX9IO4mRQxSx1Rlo4tqzeqb0sOlruaOy3dug=="],
-
    "express/mime-types/mime-db": ["mime-db@1.54.0", "", {}, "sha512-aU5EJuIN2WDemCcAp2vFBfp/m4EAhWJnUNSSw0ixs7/kXbd6Pg64EmwJkNdFhB8aWt1sH2CTXrLxo/iAGV3oPQ=="],

    "send/mime-types/mime-db": ["mime-db@1.54.0", "", {}, "sha512-aU5EJuIN2WDemCcAp2vFBfp/m4EAhWJnUNSSw0ixs7/kXbd6Pg64EmwJkNdFhB8aWt1sH2CTXrLxo/iAGV3oPQ=="],

    "type-is/mime-types/mime-db": ["mime-db@1.54.0", "", {}, "sha512-aU5EJuIN2WDemCcAp2vFBfp/m4EAhWJnUNSSw0ixs7/kXbd6Pg64EmwJkNdFhB8aWt1sH2CTXrLxo/iAGV3oPQ=="],

-    "@anthropic-ai/claude-agent-sdk/@modelcontextprotocol/sdk/ajv/json-schema-traverse": ["json-schema-traverse@1.0.0", "", {}, "sha512-NM8/P9n3XjXhIZn1lLhkFaACTOURQXjWhV4BA/RnOv8xvgqtqpAX9IO4mRQxSx1Rlo4tqzeqb0sOlruaOy3dug=="],
-
-    "@anthropic-ai/claude-agent-sdk/@modelcontextprotocol/sdk/express/body-parser": ["body-parser@2.2.2", "", { "dependencies": { "bytes": "^3.1.2", "content-type": "^1.0.5", "debug": "^4.4.3", "http-errors": "^2.0.0", "iconv-lite": "^0.7.0", "on-finished": "^2.4.1", "qs": "^6.14.1", "raw-body": "^3.0.1", "type-is": "^2.0.1" } }, "sha512-oP5VkATKlNwcgvxi0vM0p/D3n2C3EReYVX+DNYs5TjZFn/oQt2j+4sVJtSMr18pdRr8wjTcBl6LoV+FUwzPmNA=="],
-
-    "@anthropic-ai/claude-agent-sdk/@modelcontextprotocol/sdk/express/mime-types": ["mime-types@3.0.1", "", { "dependencies": { "mime-db": "^1.54.0" } }, "sha512-xRc4oEhT6eaBpU1XF7AjpOFD+xQmXNB5OVKwp4tqCuBpHLS/ZbBDrc07mYTDqVMg6PfxUjjNp85O6Cd2Z/5HWA=="],
-
-    "@anthropic-ai/claude-agent-sdk/@modelcontextprotocol/sdk/raw-body/http-errors": ["http-errors@2.0.1", "", { "dependencies": { "depd": "~2.0.0", "inherits": "~2.0.4", "setprototypeof": "~1.2.0", "statuses": "~2.0.2", "toidentifier": "~1.0.1" } }, "sha512-4FbRdAX+bSdmo4AUFuS0WNiPz8NgFt+r8ThgNWmlrjQjt1Q7ZR9+zTlce2859x4KSXrwIsaeTqDoKQmtP8pLmQ=="],
-
-    "@anthropic-ai/claude-agent-sdk/@modelcontextprotocol/sdk/raw-body/iconv-lite": ["iconv-lite@0.7.2", "", { "dependencies": { "safer-buffer": ">= 2.1.2 < 3.0.0" } }, "sha512-im9DjEDQ55s9fL4EYzOAv0yMqmMBSZp6G0VvFyTMPKWxiSBHUj9NW/qqLmXUwXrrM7AvqSlTCfvqRb0cM8yYqw=="],
-
    "@octokit/plugin-request-log/@octokit/core/@octokit/request/@octokit/endpoint": ["@octokit/endpoint@10.1.4", "", { "dependencies": { "@octokit/types": "^14.0.0", "universal-user-agent": "^7.0.2" } }, "sha512-OlYOlZIsfEVZm5HCSR8aSg02T2lbUWOsCQoPKfTXJwDzcHQBrVBGdGXb89dv2Kw2ToZaRtudp8O3ZIYoaOjKlA=="],

    "@octokit/rest/@octokit/core/@octokit/request/@octokit/endpoint": ["@octokit/endpoint@10.1.4", "", { "dependencies": { "@octokit/types": "^14.0.0", "universal-user-agent": "^7.0.2" } }, "sha512-OlYOlZIsfEVZm5HCSR8aSg02T2lbUWOsCQoPKfTXJwDzcHQBrVBGdGXb89dv2Kw2ToZaRtudp8O3ZIYoaOjKlA=="],
@ -450,15 +413,5 @@
    "@octokit/rest/@octokit/plugin-paginate-rest/@octokit/types/@octokit/openapi-types": ["@octokit/openapi-types@24.2.0", "", {}, "sha512-9sIH3nSUttelJSXUrmGzl7QUBFul0/mB8HRYl3fOlgHbIWG+WnYDXU3v/2zMtAvuzZ/ed00Ei6on975FhBfzrg=="],

    "@octokit/rest/@octokit/plugin-rest-endpoint-methods/@octokit/types/@octokit/openapi-types": ["@octokit/openapi-types@24.2.0", "", {}, "sha512-9sIH3nSUttelJSXUrmGzl7QUBFul0/mB8HRYl3fOlgHbIWG+WnYDXU3v/2zMtAvuzZ/ed00Ei6on975FhBfzrg=="],
-
-    "@anthropic-ai/claude-agent-sdk/@modelcontextprotocol/sdk/express/body-parser/debug": ["debug@4.4.3", "", { "dependencies": { "ms": "^2.1.3" } }, "sha512-RGwwWnwQvkVfavKVt22FGLw+xYSdzARwm0ru6DhTVA3umU5hZc28V3kO4stgYryrTlLpuvgI9GiijltAjNbcqA=="],
-
-    "@anthropic-ai/claude-agent-sdk/@modelcontextprotocol/sdk/express/body-parser/iconv-lite": ["iconv-lite@0.7.2", "", { "dependencies": { "safer-buffer": ">= 2.1.2 < 3.0.0" } }, "sha512-im9DjEDQ55s9fL4EYzOAv0yMqmMBSZp6G0VvFyTMPKWxiSBHUj9NW/qqLmXUwXrrM7AvqSlTCfvqRb0cM8yYqw=="],
-
-    "@anthropic-ai/claude-agent-sdk/@modelcontextprotocol/sdk/express/body-parser/qs": ["qs@6.15.0", "", { "dependencies": { "side-channel": "^1.1.0" } }, "sha512-mAZTtNCeetKMH+pSjrb76NAM8V9a05I9aBZOHztWy/UqcJdQYNsf59vrRKWnojAT9Y+GbIvoTBC++CPHqpDBhQ=="],
-
-    "@anthropic-ai/claude-agent-sdk/@modelcontextprotocol/sdk/express/mime-types/mime-db": ["mime-db@1.54.0", "", {}, "sha512-aU5EJuIN2WDemCcAp2vFBfp/m4EAhWJnUNSSw0ixs7/kXbd6Pg64EmwJkNdFhB8aWt1sH2CTXrLxo/iAGV3oPQ=="],
-
-    "@anthropic-ai/claude-agent-sdk/@modelcontextprotocol/sdk/raw-body/http-errors/statuses": ["statuses@2.0.2", "", {}, "sha512-DvEy55V3DB7uknRo+4iOGT5fP1slR8wQohVdknigZPMpMstaKJQWhwiYBACJE3Ul2pTnATihhBYnRhZQHGBiRw=="],
  }
 }
--- a/bunfig.toml
+++ b/bunfig.toml
@ -1,2 +0,0 @@
-# Intentionally minimal. action.yml pins --config to this file so bun resolves
-# its runtime config from the action directory rather than the workspace.
--- a/docs/cloud-providers.md
+++ b/docs/cloud-providers.md
@ -7,7 +7,7 @@ You can authenticate with Claude using any of these four methods:
 3. Google Vertex AI with OIDC authentication
 4. Microsoft Foundry with OIDC authentication

-For detailed setup instructions for AWS Bedrock and Google Vertex AI, see the [official documentation](https://code.claude.com/docs/en/github-actions#for-aws-bedrock:).
+For detailed setup instructions for AWS Bedrock and Google Vertex AI, see the [official documentation](https://docs.anthropic.com/en/docs/claude-code/github-actions#using-with-aws-bedrock-%26-google-vertex-ai).

 **Note**:

--- a/docs/configuration.md
+++ b/docs/configuration.md
@ -172,14 +172,9 @@ jobs:

 **Important Notes**:

- The GitHub token must have the corresponding permission in your workflow
+- The GitHub token must have the `actions: read` permission in your workflow
 - If the permission is missing, Claude will warn you and suggest adding it
- The following additional permissions can be requested beyond the defaults:
-  - `actions: read`
-  - `checks: read`
-  - `discussions: read` or `discussions: write`
-  - `workflows: read` or `workflows: write`
- Standard permissions (`contents: write`, `pull_requests: write`, `issues: write`) are always included and do not need to be specified
+- Currently, only `actions: read` is supported, but the format allows for future extensions

 ## Custom Environment Variables

--- a/docs/faq.md
+++ b/docs/faq.md
@ -127,7 +127,7 @@ For performance, Claude uses shallow clones:
 If you need full history, you can configure this in your workflow before calling Claude in the `actions/checkout` step.

 ```
- uses: actions/checkout@v6
+- uses: actions/checkout@v5
  depth: 0 # will fetch full repo history
 ```

--- a/docs/security.md
+++ b/docs/security.md
@ -4,71 +4,19 @@

 - **Repository Access**: The action can only be triggered by users with write access to the repository
 - **Bot User Control**: By default, GitHub Apps and bots cannot trigger this action for security reasons. Use the `allowed_bots` parameter to enable specific bots or all bots
-  - **⚠️ Allowed bots are not checked for repository permissions.** A bot that matches an entry does **not** need to be installed on your repository or have write access. On a **public repository**, external parties — including GitHub Apps created by anyone — may be able to trigger workflow events such as opening issues, commenting, or reviewing pull requests. If your workflow listens on those events and `allowed_bots` is set to `'*'`, any such App can invoke this action with a prompt it controls.
-  - Prefer an explicit list over `'*'`
-  - Only list App names you trust
-  - If you need `'*'`, scope workflow `permissions:` to the minimum required
 - **⚠️ Non-Write User Access (RISKY)**: The `allowed_non_write_users` parameter allows bypassing the write permission requirement. **This is a significant security risk and should only be used for workflows with extremely limited permissions** (e.g., issue labeling workflows that only have `issues: write` permission). This feature:
  - Only works when `github_token` is provided as input (not with GitHub App authentication)
  - Accepts either a comma-separated list of specific usernames or `*` to allow all users
  - **Should be used with extreme caution** as it bypasses the primary security mechanism of this action
  - Is designed for automation workflows where user permissions are already restricted by the workflow's permission scope
-  - When set, Claude does a best-effort scrub of Anthropic, cloud, and GitHub Actions secrets from subprocess environments. On Linux runners with bubblewrap available, subprocesses additionally run with PID-namespace isolation. This reduces but does not eliminate prompt injection risk — keep workflow permissions minimal and validate all outputs. Set `CLAUDE_CODE_SUBPROCESS_ENV_SCRUB: 0` in your workflow or job `env:` block to opt out.
-  - Optionally set `CLAUDE_CODE_SCRIPT_CAPS` in your workflow `env:` block to limit how many times Claude can call specific scripts per run. Value is JSON: `{"script-name.sh": maxCalls}`. Example: `CLAUDE_CODE_SCRIPT_CAPS: '{"edit-issue-labels.sh":2}'` allows at most 2 calls to `edit-issue-labels.sh`. Useful for write-capable helper scripts.
-  - When using `allowed_non_write_users`, always pass `github_token: ${{ secrets.GITHUB_TOKEN }}`. The auto-generated workflow token is scoped to the job's declared permissions and expires when the job completes. **Do not use a personal access token** — a static token does not rotate between runs and could be partially or fully recovered over time via prompt injection. Restricting allowed tools via `claude_args` reduces the rate of recovery but may not eliminate the risk. We recommend restricting allowed tools (e.g. `claude_args: '--allowedTools "Bash(gh issue view:*)"'`) to the minimum required when using `allowed_non_write_users`.
 - **Token Permissions**: The GitHub app receives only a short-lived token scoped specifically to the repository it's operating in
 - **No Cross-Repository Access**: Each action invocation is limited to the repository where it was triggered
 - **Limited Scope**: The token cannot access other repositories or perform actions beyond the configured permissions

-## Using this action with `pull_request_target` or `workflow_run`
-
-`pull_request_target` and `workflow_run` execute with the **base repository's secrets**. If your workflow checks out the PR head (`ref: ${{ github.event.pull_request.head.sha }}` for `pull_request_target`, `ref: ${{ github.event.workflow_run.head_sha }}` for `workflow_run`) into `$GITHUB_WORKSPACE` before this action, the action and Claude run with that checkout as the working directory.
-
-**Do not check out an untrusted ref into the workspace root before this action.** Use one of these patterns instead:
-
-```yaml
-# Preferred — check out the base ref (default).
- uses: actions/checkout@v6 # no `ref:` → base branch
- uses: anthropics/claude-code-action@v1
-```
-
-```yaml
-# If you need the PR's files locally — check out the base ref at the workspace
-# root (this action expects a git repo there), then check out the head ref into
-# a subdirectory and pass it via --add-dir.
- uses: actions/checkout@v6 # no `ref:` → base branch at workspace root
- uses: actions/checkout@v6
-  with:
-    # For workflow_run use: ${{ github.event.workflow_run.head_sha }}
-    ref: ${{ github.event.pull_request.head.sha }}
-    path: pr-head
- uses: anthropics/claude-code-action@v1
-  with:
-    claude_args: "--add-dir pr-head"
-```
-
-This is general guidance for these event types — see [GitHub's documentation](https://securitylab.github.com/research/github-actions-preventing-pwn-requests/).
-
-### `claude-code-action` vs `claude-code-base-action`
-
-`claude-code-base-action` is a lower-level building block that installs and runs Claude Code with the inputs you provide. It does not perform actor permission checks or restore project configuration from the base ref. If you need those behaviors, use this action (`claude-code-action`). See the [base-action README](../base-action/README.md#trust-model) for details.
-
-## Pull Request Creation
-
-In its default configuration, **Claude does not create pull requests automatically** when responding to `@claude` mentions. Instead:
-
- Claude commits code changes to a new branch
- Claude provides a **link to the GitHub PR creation page** in its response
- **The user must click the link and create the PR themselves**, ensuring human oversight before any code is proposed for merging
-
-This design ensures that users retain full control over what pull requests are created and can review the changes before initiating the PR workflow.
-
 ## ⚠️ Prompt Injection Risks

 **Beware of potential hidden markdown when tagging Claude on untrusted content.** External contributors may include hidden instructions through HTML comments, invisible characters, hidden attributes, or other techniques. The action sanitizes content by stripping HTML comments, invisible characters, markdown image alt text, hidden HTML attributes, and HTML entities, but new bypass techniques may emerge. We recommend reviewing the raw content of all input coming from external contributors before allowing Claude to process it.

-On public repos, you can also use `include_comments_by_actor` to allowlist which users' comments are passed to Claude, reducing exposure to untrusted input. Use `exclude_comments_by_actor` to filter out noisy bot comments (e.g., `dependabot[bot]`, `renovate[bot]`). If an actor matches both lists, exclusion takes priority. See [Usage](./usage.md) for details.
-
 ## GitHub App Permissions

 The [Claude Code GitHub app](https://github.com/apps/claude) requests the following permissions:
@ -90,64 +38,7 @@ The following permissions are requested but not yet actively used. These will en

 ## Commit Signing

-By default, commits made by Claude are unsigned. You can enable commit signing using one of two methods:
-
-### Option 1: GitHub API Commit Signing (use_commit_signing)
-
-This uses GitHub's API to create commits, which automatically signs them as verified from the GitHub App:
-
-```yaml
- uses: anthropics/claude-code-action@main
-  with:
-    use_commit_signing: true
-```
-
-This is the simplest option and requires no additional setup. However, because it uses the GitHub API instead of git CLI, it cannot perform complex git operations like rebasing, cherry-picking, or interactive history manipulation.
-
-### Option 2: SSH Signing Key (ssh_signing_key)
-
-This uses an SSH key to sign commits via git CLI. Use this option when you need both signed commits AND standard git operations (rebasing, cherry-picking, etc.):
-
-```yaml
- uses: anthropics/claude-code-action@main
-  with:
-    ssh_signing_key: ${{ secrets.SSH_SIGNING_KEY }}
-    bot_id: "YOUR_GITHUB_USER_ID"
-    bot_name: "YOUR_GITHUB_USERNAME"
-```
-
-Commits will show as verified and attributed to the GitHub account that owns the signing key.
-
-**Setup steps:**
-
-1. Generate an SSH key pair for signing:
-
-   ```bash
-   ssh-keygen -t ed25519 -f ~/.ssh/signing_key -N "" -C "commit signing key"
-   ```
-
-2. Add the **public key** to your GitHub account:
-
-   - Go to GitHub → Settings → SSH and GPG keys
-   - Click "New SSH key"
-   - Select **Key type: Signing Key** (important)
-   - Paste the contents of `~/.ssh/signing_key.pub`
-
-3. Add the **private key** to your repository secrets:
-
-   - Go to your repo → Settings → Secrets and variables → Actions
-   - Create a new secret named `SSH_SIGNING_KEY`
-   - Paste the contents of `~/.ssh/signing_key`
-
-4. Get your GitHub user ID:
-
-   ```bash
-   gh api users/YOUR_USERNAME --jq '.id'
-   ```
-
-5. Update your workflow with `bot_id` and `bot_name` matching the account where you added the signing key.
-
-**Note:** If both `ssh_signing_key` and `use_commit_signing` are provided, `ssh_signing_key` takes precedence.
+Commits made by Claude through this action are no longer automatically signed with commit signatures. To enable commit signing set `use_commit_signing: True` in the workflow(s). This ensures the authenticity and integrity of commits, providing a verifiable trail of changes made by the action.

 ## ⚠️ Authentication Protection

--- a/docs/solutions.md
+++ b/docs/solutions.md
@ -35,7 +35,7 @@ jobs:
      pull-requests: write
      id-token: write
    steps:
-      - uses: actions/checkout@v6
+      - uses: actions/checkout@v5
        with:
          fetch-depth: 1

@ -55,7 +55,7 @@ jobs:
            Note: The PR branch is already checked out in the current working directory.

            Use `gh pr comment` for top-level feedback.
-            Use `mcp__github_inline_comment__create_inline_comment` (with `confirmed: true`) to highlight specific code issues.
+            Use `mcp__github_inline_comment__create_inline_comment` to highlight specific code issues.
            Only post GitHub comments - don't submit review text as messages.

          claude_args: |
@ -89,7 +89,7 @@ jobs:
      pull-requests: write
      id-token: write
    steps:
-      - uses: actions/checkout@v6
+      - uses: actions/checkout@v5
        with:
          fetch-depth: 1

@ -153,7 +153,7 @@ jobs:
      pull-requests: write
      id-token: write
    steps:
-      - uses: actions/checkout@v6
+      - uses: actions/checkout@v5
        with:
          fetch-depth: 1

@ -211,7 +211,7 @@ jobs:
      pull-requests: write
      id-token: write
    steps:
-      - uses: actions/checkout@v6
+      - uses: actions/checkout@v5
        with:
          fetch-depth: 1

@ -268,7 +268,7 @@ jobs:
      pull-requests: write
      id-token: write
    steps:
-      - uses: actions/checkout@v6
+      - uses: actions/checkout@v5
        with:
          fetch-depth: 1

@ -344,7 +344,7 @@ jobs:
      pull-requests: write
      id-token: write
    steps:
-      - uses: actions/checkout@v6
+      - uses: actions/checkout@v5
        with:
          fetch-depth: 0

@ -398,7 +398,6 @@ jobs:
      issues: write
      id-token: write
    steps:
-      - uses: actions/checkout@v4
      - uses: anthropics/claude-code-action@v1
        with:
          anthropic_api_key: ${{ secrets.ANTHROPIC_API_KEY }}
@ -415,19 +414,13 @@ jobs:
            3. Suggest appropriate labels
            4. Check if it duplicates existing issues

-            Use ./scripts/gh.sh to interact with GitHub:
-            - `./scripts/gh.sh issue view [number]` to view the issue
-            - `./scripts/gh.sh search issues "query"` to find similar issues
-            - `./scripts/gh.sh label list` to see available labels
-
            Based on your analysis, add the appropriate labels using:
-            `./scripts/edit-issue-labels.sh --add-label "label1" --add-label "label2"`
-            (the issue number is read automatically from the workflow event)
+            `gh issue edit [number] --add-label "label1,label2"`

            If it appears to be a duplicate, post a comment mentioning the original issue.

          claude_args: |
-            --allowedTools "Bash(./scripts/gh.sh:*),Bash(./scripts/edit-issue-labels.sh:*)"
+            --allowedTools "Bash(gh issue:*),Bash(gh search:*)"
 ```

 **Key Configuration:**
@ -435,7 +428,6 @@ jobs:
 - Triggered on new issues
 - Issue context in prompt
 - Label management capabilities
- Requires `scripts/gh.sh` and `scripts/edit-issue-labels.sh` in your repo (see this repo's `scripts/` directory for examples)

 **Expected Output:** Automatically labeled and categorized issues.

@ -464,7 +456,7 @@ jobs:
      pull-requests: write
      id-token: write
    steps:
-      - uses: actions/checkout@v6
+      - uses: actions/checkout@v5
        with:
          ref: ${{ github.event.pull_request.head.ref }}
          fetch-depth: 0
@ -521,7 +513,7 @@ jobs:
      security-events: write
      id-token: write
    steps:
-      - uses: actions/checkout@v6
+      - uses: actions/checkout@v5
        with:
          fetch-depth: 1

@ -586,7 +578,7 @@ prompt: |
 ### Common Tool Permissions

 - **PR Comments**: `Bash(gh pr comment:*)`
- **Inline Comments**: `mcp__github_inline_comment__create_inline_comment` — pass `confirmed: true` to post immediately. When omitted, the comment is buffered and classified after the session ends (real review comments post, test/probe comments are filtered). This prevents subagent test comments from reaching PRs. To disable classification entirely, set `classify_inline_comments: 'false'` on the action.
+- **Inline Comments**: `mcp__github_inline_comment__create_inline_comment`
 - **File Operations**: `Read,Write,Edit`
 - **Git Operations**: `Bash(git:*)`

--- a/docs/usage.md
+++ b/docs/usage.md
@ -52,38 +52,33 @@ jobs:

 ## Inputs

-| Input                            | Description                                                                                                                                                                                                                            | Required | Default       |
-| -------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------- | ------------- |
-| `anthropic_api_key`              | Anthropic API key (required for direct API, not needed for Bedrock/Vertex)                                                                                                                                                             | No\*     | -             |
-| `claude_code_oauth_token`        | Claude Code OAuth token (alternative to anthropic_api_key)                                                                                                                                                                             | No\*     | -             |
-| `prompt`                         | Instructions for Claude. Can be a direct prompt or custom template for automation workflows                                                                                                                                            | No       | -             |
-| `track_progress`                 | Force tag mode with tracking comments. Only works with specific PR/issue events. Preserves GitHub context                                                                                                                              | No       | `false`       |
-| `include_fix_links`              | Include 'Fix this' links in PR code review feedback that open Claude Code with context to fix the identified issue                                                                                                                     | No       | `true`        |
-| `claude_args`                    | Additional [arguments to pass directly to Claude CLI](https://docs.claude.com/en/docs/claude-code/cli-reference#cli-flags) (e.g., `--max-turns 10 --model claude-4-0-sonnet-20250805`)                                                 | No       | ""            |
-| `base_branch`                    | The base branch to use for creating new branches (e.g., 'main', 'develop')                                                                                                                                                             | No       | -             |
-| `use_sticky_comment`             | Use just one comment to deliver PR comments (only applies for pull_request event workflows)                                                                                                                                            | No       | `false`       |
-| `classify_inline_comments`       | Buffer inline comments without `confirmed: true` and classify them (real review vs test/probe) via Haiku before posting after the session ends. Prevents subagent test comments. Set `'false'` to post all inline comments immediately | No       | `true`        |
-| `github_token`                   | GitHub token for Claude to operate with. **Only include this if you're connecting a custom GitHub app of your own!**                                                                                                                   | No       | -             |
-| `use_bedrock`                    | Use Amazon Bedrock with OIDC authentication instead of direct Anthropic API                                                                                                                                                            | No       | `false`       |
-| `use_vertex`                     | Use Google Vertex AI with OIDC authentication instead of direct Anthropic API                                                                                                                                                          | No       | `false`       |
-| `assignee_trigger`               | The assignee username that triggers the action (e.g. @claude). Only used for issue assignment                                                                                                                                          | No       | -             |
-| `label_trigger`                  | The label name that triggers the action when applied to an issue (e.g. "claude")                                                                                                                                                       | No       | -             |
-| `trigger_phrase`                 | The trigger phrase to look for in comments, issue/PR bodies, and issue titles                                                                                                                                                          | No       | `@claude`     |
-| `branch_prefix`                  | The prefix to use for Claude branches (defaults to 'claude/', use 'claude-' for dash format)                                                                                                                                           | No       | `claude/`     |
-| `settings`                       | Claude Code settings as JSON string or path to settings JSON file                                                                                                                                                                      | No       | ""            |
-| `additional_permissions`         | Additional permissions to enable. Currently supports 'actions: read' for viewing workflow results                                                                                                                                      | No       | ""            |
-| `use_commit_signing`             | Enable commit signing using GitHub's API. Simple but cannot perform complex git operations like rebasing. See [Security](./security.md#commit-signing)                                                                                 | No       | `false`       |
-| `ssh_signing_key`                | SSH private key for signing commits. Enables signed commits with full git CLI support (rebasing, etc.). See [Security](./security.md#commit-signing)                                                                                   | No       | ""            |
-| `bot_id`                         | GitHub user ID to use for git operations (defaults to Claude's bot ID). Required with `ssh_signing_key` for verified commits                                                                                                           | No       | `41898282`    |
-| `bot_name`                       | GitHub username to use for git operations (defaults to Claude's bot name). Required with `ssh_signing_key` for verified commits                                                                                                        | No       | `claude[bot]` |
-| `include_comments_by_actor`      | Comma-separated list of actor usernames to INCLUDE in comments. Supports the `*[bot]` wildcard to match all bot accounts. Empty (default) includes all actors                                                                          | No       | ""            |
-| `exclude_comments_by_actor`      | Comma-separated list of actor usernames to EXCLUDE from comments. Supports the `*[bot]` wildcard to match all bot accounts. If an actor matches both lists, exclusion takes priority                                                   | No       | ""            |
-| `allowed_bots`                   | Comma-separated list of allowed bot usernames, or '\*' to allow all bots. Empty string (default) allows no bots. **⚠️ On public repos with `'*'`, external Apps may be able to invoke this action.** See [Security](./security.md)     | No       | ""            |
-| `allowed_non_write_users`        | **⚠️ RISKY**: Comma-separated list of usernames to allow without write permissions, or '\*' for all users. Only works with `github_token` input. See [Security](./security.md)                                                         | No       | ""            |
-| `path_to_claude_code_executable` | Optional path to a custom Claude Code executable. Skips automatic installation. Useful for Nix, custom containers, or specialized environments                                                                                         | No       | ""            |
-| `path_to_bun_executable`         | Optional path to a custom Bun executable. Skips automatic Bun installation. Useful for Nix, custom containers, or specialized environments                                                                                             | No       | ""            |
-| `plugin_marketplaces`            | Newline-separated list of Claude Code plugin marketplace Git URLs to install from (e.g., see example in workflow above). Marketplaces are added before plugin installation                                                             | No       | ""            |
-| `plugins`                        | Newline-separated list of Claude Code plugin names to install (e.g., see example in workflow above). Plugins are installed before Claude Code execution                                                                                | No       | ""            |
+| Input                            | Description                                                                                                                                                                            | Required | Default       |
+| -------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------- | ------------- |
+| `anthropic_api_key`              | Anthropic API key (required for direct API, not needed for Bedrock/Vertex)                                                                                                             | No\*     | -             |
+| `claude_code_oauth_token`        | Claude Code OAuth token (alternative to anthropic_api_key)                                                                                                                             | No\*     | -             |
+| `prompt`                         | Instructions for Claude. Can be a direct prompt or custom template for automation workflows                                                                                            | No       | -             |
+| `track_progress`                 | Force tag mode with tracking comments. Only works with specific PR/issue events. Preserves GitHub context                                                                              | No       | `false`       |
+| `claude_args`                    | Additional [arguments to pass directly to Claude CLI](https://docs.claude.com/en/docs/claude-code/cli-reference#cli-flags) (e.g., `--max-turns 10 --model claude-4-0-sonnet-20250805`) | No       | ""            |
+| `base_branch`                    | The base branch to use for creating new branches (e.g., 'main', 'develop')                                                                                                             | No       | -             |
+| `use_sticky_comment`             | Use just one comment to deliver PR comments (only applies for pull_request event workflows)                                                                                            | No       | `false`       |
+| `github_token`                   | GitHub token for Claude to operate with. **Only include this if you're connecting a custom GitHub app of your own!**                                                                   | No       | -             |
+| `use_bedrock`                    | Use Amazon Bedrock with OIDC authentication instead of direct Anthropic API                                                                                                            | No       | `false`       |
+| `use_vertex`                     | Use Google Vertex AI with OIDC authentication instead of direct Anthropic API                                                                                                          | No       | `false`       |
+| `assignee_trigger`               | The assignee username that triggers the action (e.g. @claude). Only used for issue assignment                                                                                          | No       | -             |
+| `label_trigger`                  | The label name that triggers the action when applied to an issue (e.g. "claude")                                                                                                       | No       | -             |
+| `trigger_phrase`                 | The trigger phrase to look for in comments, issue/PR bodies, and issue titles                                                                                                          | No       | `@claude`     |
+| `branch_prefix`                  | The prefix to use for Claude branches (defaults to 'claude/', use 'claude-' for dash format)                                                                                           | No       | `claude/`     |
+| `settings`                       | Claude Code settings as JSON string or path to settings JSON file                                                                                                                      | No       | ""            |
+| `additional_permissions`         | Additional permissions to enable. Currently supports 'actions: read' for viewing workflow results                                                                                      | No       | ""            |
+| `use_commit_signing`             | Enable commit signing using GitHub's commit signature verification. When false, Claude uses standard git commands                                                                      | No       | `false`       |
+| `bot_id`                         | GitHub user ID to use for git operations (defaults to Claude's bot ID)                                                                                                                 | No       | `41898282`    |
+| `bot_name`                       | GitHub username to use for git operations (defaults to Claude's bot name)                                                                                                              | No       | `claude[bot]` |
+| `allowed_bots`                   | Comma-separated list of allowed bot usernames, or '\*' to allow all bots. Empty string (default) allows no bots                                                                        | No       | ""            |
+| `allowed_non_write_users`        | **⚠️ RISKY**: Comma-separated list of usernames to allow without write permissions, or '\*' for all users. Only works with `github_token` input. See [Security](./security.md)         | No       | ""            |
+| `path_to_claude_code_executable` | Optional path to a custom Claude Code executable. Skips automatic installation. Useful for Nix, custom containers, or specialized environments                                         | No       | ""            |
+| `path_to_bun_executable`         | Optional path to a custom Bun executable. Skips automatic Bun installation. Useful for Nix, custom containers, or specialized environments                                             | No       | ""            |
+| `plugin_marketplaces`            | Newline-separated list of Claude Code plugin marketplace Git URLs to install from (e.g., see example in workflow above). Marketplaces are added before plugin installation             | No       | ""            |
+| `plugins`                        | Newline-separated list of Claude Code plugin names to install (e.g., see example in workflow above). Plugins are installed before Claude Code execution                                | No       | ""            |

 ### Deprecated Inputs

--- a/examples/ci-failure-auto-fix.yml
+++ b/examples/ci-failure-auto-fix.yml
@ -1,21 +1,5 @@
 name: Auto Fix CI Failures

-# ⚠️ SECURITY NOTE
-#
-# This workflow checks out the PR branch and runs build/test commands
-# (npm, bun, etc.) against it with elevated permissions (contents:write,
-# id-token:write). This means code from the PR branch executes in a
-# trusted context with access to secrets and the ability to push to the
-# repository.
-#
-# Only use this workflow in repositories where everyone with write access
-# is fully trusted with these permissions. Do not use this in repositories
-# that accept contributions from untrusted or semi-trusted collaborators.
-#
-# The pull_requests[0] check below limits this to same-repo PRs (fork PRs
-# are excluded), but anyone who can push a branch to this repository can
-# control what code runs here.
-
 on:
  workflow_run:
    workflows: ["CI"]
@ -38,7 +22,7 @@ jobs:
    runs-on: ubuntu-latest
    steps:
      - name: Checkout code
-        uses: actions/checkout@v6
+        uses: actions/checkout@v5
        with:
          ref: ${{ github.event.workflow_run.head_branch }}
          fetch-depth: 0
@ -51,14 +35,10 @@ jobs:

      - name: Create fix branch
        id: branch
-        env:
-          HEAD_BRANCH: ${{ github.event.workflow_run.head_branch }}
-          RUN_ID: ${{ github.run_id }}
        run: |
-          SAFE_BRANCH=$(printf '%s' "$HEAD_BRANCH" | tr -cd 'a-zA-Z0-9/_.-')
-          BRANCH_NAME="claude-auto-fix-ci-${SAFE_BRANCH}-${RUN_ID}"
+          BRANCH_NAME="claude-auto-fix-ci-${{ github.event.workflow_run.head_branch }}-${{ github.run_id }}"
          git checkout -b "$BRANCH_NAME"
-          echo "branch_name=$BRANCH_NAME" >> "$GITHUB_OUTPUT"
+          echo "branch_name=$BRANCH_NAME" >> $GITHUB_OUTPUT

      - name: Get CI failure details
        id: failure_details
--- a/examples/claude.yml
+++ b/examples/claude.yml
@ -26,7 +26,7 @@ jobs:
      actions: read # Required for Claude to read CI results on PRs
    steps:
      - name: Checkout repository
-        uses: actions/checkout@v6
+        uses: actions/checkout@v5
        with:
          fetch-depth: 1

--- a/examples/issue-deduplication.yml
+++ b/examples/issue-deduplication.yml
@ -15,7 +15,7 @@ jobs:

    steps:
      - name: Checkout repository
-        uses: actions/checkout@v6
+        uses: actions/checkout@v5
        with:
          fetch-depth: 1

--- a/examples/issue-triage.yml
+++ b/examples/issue-triage.yml
@ -14,15 +14,15 @@ jobs:

    steps:
      - name: Checkout repository
-        uses: actions/checkout@v6
+        uses: actions/checkout@v5
        with:
          fetch-depth: 0

      - name: Run Claude Code for Issue Triage
        uses: anthropics/claude-code-action@v1
        with:
-          # NOTE: /label-issue requires .claude/commands/label-issue.md and scripts/edit-issue-labels.sh in your repo (see this repo for examples)
-          prompt: "/label-issue REPO: ${{ github.repository }} ISSUE_NUMBER: ${{ github.event.issue.number }}"
+          # NOTE: /label-issue here requires a .claude/commands/label-issue.md file in your repo (see this repo's .claude directory for an example)
+          prompt: "/label-issue REPO: ${{ github.repository }} ISSUE_NUMBER${{ github.event.issue.number }}"

          anthropic_api_key: ${{ secrets.ANTHROPIC_API_KEY }}
          allowed_non_write_users: "*" # Required for issue triage workflow, if users without repo write access create issues
--- a/examples/manual-code-analysis.yml
+++ b/examples/manual-code-analysis.yml
@ -23,7 +23,7 @@ jobs:

    steps:
      - name: Checkout repository
-        uses: actions/checkout@v6
+        uses: actions/checkout@v5
        with:
          fetch-depth: 2 # Need at least 2 commits to analyze the latest

--- a/examples/pr-review-comprehensive.yml
+++ b/examples/pr-review-comprehensive.yml
@ -16,7 +16,7 @@ jobs:
      id-token: write
    steps:
      - name: Checkout repository
-        uses: actions/checkout@v6
+        uses: actions/checkout@v5
        with:
          fetch-depth: 1

--- a/examples/pr-review-filtered-authors.yml
+++ b/examples/pr-review-filtered-authors.yml
@ -18,7 +18,7 @@ jobs:
      id-token: write
    steps:
      - name: Checkout repository
-        uses: actions/checkout@v6
+        uses: actions/checkout@v5
        with:
          fetch-depth: 1

--- a/examples/pr-review-filtered-paths.yml
+++ b/examples/pr-review-filtered-paths.yml
@ -19,7 +19,7 @@ jobs:
      id-token: write
    steps:
      - name: Checkout repository
-        uses: actions/checkout@v6
+        uses: actions/checkout@v5
        with:
          fetch-depth: 1

--- a/examples/test-failure-analysis.yml
+++ b/examples/test-failure-analysis.yml
@ -53,8 +53,6 @@ jobs:
          fromJSON(steps.detect.outputs.structured_output).confidence >= 0.7
        env:
          GH_TOKEN: ${{ github.token }}
-          WORKFLOW_NAME: ${{ github.event.workflow_run.name }}
-          HEAD_BRANCH: ${{ github.event.workflow_run.head_branch }}
        run: |
          OUTPUT='${{ steps.detect.outputs.structured_output }}'
          CONFIDENCE=$(echo "$OUTPUT" | jq -r '.confidence')
@ -65,7 +63,8 @@ jobs:
          echo ""
          echo "Triggering automatic retry..."

-          gh workflow run "$WORKFLOW_NAME" --ref "$HEAD_BRANCH"
+          gh workflow run "${{ github.event.workflow_run.name }}" \
+            --ref "${{ github.event.workflow_run.head_branch }}"

      # Low confidence flaky detection - skip retry
      - name: Low confidence detection
@ -84,14 +83,13 @@ jobs:
        if: github.event.workflow_run.event == 'pull_request'
        env:
          GH_TOKEN: ${{ github.token }}
-          HEAD_BRANCH: ${{ github.event.workflow_run.head_branch }}
        run: |
          OUTPUT='${{ steps.detect.outputs.structured_output }}'
          IS_FLAKY=$(echo "$OUTPUT" | jq -r '.is_flaky')
          CONFIDENCE=$(echo "$OUTPUT" | jq -r '.confidence')
          SUMMARY=$(echo "$OUTPUT" | jq -r '.summary')

-          pr_number=$(gh pr list --head "$HEAD_BRANCH" --json number --jq '.[0].number')
+          pr_number=$(gh pr list --head "${{ github.event.workflow_run.head_branch }}" --json number --jq '.[0].number')

          if [ -n "$pr_number" ]; then
            if [ "$IS_FLAKY" = "true" ]; then
--- a/package.json
+++ b/package.json
@ -12,7 +12,7 @@
  "dependencies": {
    "@actions/core": "^1.10.1",
    "@actions/github": "^6.0.1",
-    "@anthropic-ai/claude-agent-sdk": "^0.2.123",
+    "@anthropic-ai/claude-agent-sdk": "^0.1.52",
    "@modelcontextprotocol/sdk": "^1.11.0",
    "@octokit/graphql": "^8.2.2",
    "@octokit/rest": "^21.1.1",
--- a/scripts/edit-issue-labels.sh
+++ b/scripts/edit-issue-labels.sh
@ -1,83 +0,0 @@
-#!/usr/bin/env bash
-#
-# Edits labels on a GitHub issue.
-# Usage: ./scripts/edit-issue-labels.sh --add-label bug --add-label needs-triage --remove-label untriaged
-#
-# The issue number is read from the workflow event payload.
-#
-
-set -euo pipefail
-
-# Read from event payload so the issue number is bound to the triggering event
-ISSUE=$(jq -r '.issue.number // empty' "${GITHUB_EVENT_PATH:?GITHUB_EVENT_PATH not set}")
-if ! [[ "$ISSUE" =~ ^[0-9]+$ ]]; then
-  echo "Error: no issue number in event payload" >&2
-  exit 1
-fi
-
-ADD_LABELS=()
-REMOVE_LABELS=()
-
-# Parse arguments
-while [[ $# -gt 0 ]]; do
-  case $1 in
-    --add-label)
-      ADD_LABELS+=("$2")
-      shift 2
-      ;;
-    --remove-label)
-      REMOVE_LABELS+=("$2")
-      shift 2
-      ;;
-    *)
-      echo "Error: unknown argument (only --add-label and --remove-label are accepted)" >&2
-      exit 1
-      ;;
-  esac
-done
-
-if [[ ${#ADD_LABELS[@]} -eq 0 && ${#REMOVE_LABELS[@]} -eq 0 ]]; then
-  exit 1
-fi
-
-# Fetch valid labels from the repo
-VALID_LABELS=$(gh label list --limit 500 --json name --jq '.[].name')
-
-# Filter to only labels that exist in the repo
-FILTERED_ADD=()
-for label in "${ADD_LABELS[@]}"; do
-  if echo "$VALID_LABELS" | grep -qxF "$label"; then
-    FILTERED_ADD+=("$label")
-  fi
-done
-
-FILTERED_REMOVE=()
-for label in "${REMOVE_LABELS[@]}"; do
-  if echo "$VALID_LABELS" | grep -qxF "$label"; then
-    FILTERED_REMOVE+=("$label")
-  fi
-done
-
-if [[ ${#FILTERED_ADD[@]} -eq 0 && ${#FILTERED_REMOVE[@]} -eq 0 ]]; then
-  exit 0
-fi
-
-# Build gh command arguments
-GH_ARGS=("issue" "edit" "$ISSUE")
-
-for label in "${FILTERED_ADD[@]}"; do
-  GH_ARGS+=("--add-label" "$label")
-done
-
-for label in "${FILTERED_REMOVE[@]}"; do
-  GH_ARGS+=("--remove-label" "$label")
-done
-
-gh "${GH_ARGS[@]}"
-
-if [[ ${#FILTERED_ADD[@]} -gt 0 ]]; then
-  echo "Added: ${FILTERED_ADD[*]}"
-fi
-if [[ ${#FILTERED_REMOVE[@]} -gt 0 ]]; then
-  echo "Removed: ${FILTERED_REMOVE[*]}"
-fi
--- a/scripts/gh.sh
+++ b/scripts/gh.sh
@ -1,96 +0,0 @@
-#!/usr/bin/env bash
-set -euo pipefail
-
-# Wrapper around gh CLI that only allows specific subcommands and flags.
-# All commands are scoped to the current repository via GH_REPO or GITHUB_REPOSITORY.
-#
-# Usage:
-#   ./scripts/gh.sh issue view 123
-#   ./scripts/gh.sh issue view 123 --comments
-#   ./scripts/gh.sh issue list --state open --limit 20
-#   ./scripts/gh.sh search issues "search query" --limit 10
-#   ./scripts/gh.sh label list --limit 100
-
-export GH_HOST=github.com
-
-REPO="${GH_REPO:-${GITHUB_REPOSITORY:-}}"
-if [[ -z "$REPO" || "$REPO" == */*/* || "$REPO" != */* ]]; then
-  echo "Error: GH_REPO or GITHUB_REPOSITORY must be set to owner/repo format (e.g., GITHUB_REPOSITORY=anthropics/claude-code)" >&2
-  exit 1
-fi
-export GH_REPO="$REPO"
-
-ALLOWED_FLAGS=(--comments --state --limit --label)
-FLAGS_WITH_VALUES=(--state --limit --label)
-
-SUB1="${1:-}"
-SUB2="${2:-}"
-CMD="$SUB1 $SUB2"
-case "$CMD" in
-  "issue view"|"issue list"|"search issues"|"label list")
-    ;;
-  *)
-    echo "Error: only 'issue view', 'issue list', 'search issues', 'label list' are allowed (e.g., ./scripts/gh.sh issue view 123)" >&2
-    exit 1
-    ;;
-esac
-
-shift 2
-
-# Separate flags from positional arguments
-POSITIONAL=()
-FLAGS=()
-skip_next=false
-for arg in "$@"; do
-  if [[ "$skip_next" == true ]]; then
-    FLAGS+=("$arg")
-    skip_next=false
-  elif [[ "$arg" == -* ]]; then
-    flag="${arg%%=*}"
-    matched=false
-    for allowed in "${ALLOWED_FLAGS[@]}"; do
-      if [[ "$flag" == "$allowed" ]]; then
-        matched=true
-        break
-      fi
-    done
-    if [[ "$matched" == false ]]; then
-      echo "Error: only --comments, --state, --limit, --label flags are allowed (e.g., ./scripts/gh.sh issue list --state open --limit 20)" >&2
-      exit 1
-    fi
-    FLAGS+=("$arg")
-    # If flag expects a value and isn't using = syntax, skip next arg
-    if [[ "$arg" != *=* ]]; then
-      for vflag in "${FLAGS_WITH_VALUES[@]}"; do
-        if [[ "$flag" == "$vflag" ]]; then
-          skip_next=true
-          break
-        fi
-      done
-    fi
-  else
-    POSITIONAL+=("$arg")
-  fi
-done
-
-if [[ "$CMD" == "search issues" ]]; then
-  QUERY="${POSITIONAL[0]:-}"
-  QUERY_LOWER=$(echo "$QUERY" | tr '[:upper:]' '[:lower:]')
-  if [[ "$QUERY_LOWER" == *"repo:"* || "$QUERY_LOWER" == *"org:"* || "$QUERY_LOWER" == *"user:"* ]]; then
-    echo "Error: search query must not contain repo:, org:, or user: qualifiers (e.g., ./scripts/gh.sh search issues \"bug report\" --limit 10)" >&2
-    exit 1
-  fi
-  gh "$SUB1" "$SUB2" "$QUERY" --repo "$REPO" "${FLAGS[@]}"
-elif [[ "$CMD" == "issue view" ]]; then
-  if [[ ${#POSITIONAL[@]} -ne 1 ]] || ! [[ "${POSITIONAL[0]}" =~ ^[0-9]+$ ]]; then
-    echo "Error: issue view requires exactly one numeric issue number (e.g., ./scripts/gh.sh issue view 123)" >&2
-    exit 1
-  fi
-  gh "$SUB1" "$SUB2" "${POSITIONAL[0]}" "${FLAGS[@]}"
-else
-  if [[ ${#POSITIONAL[@]} -ne 0 ]]; then
-    echo "Error: issue list and label list do not accept positional arguments (e.g., ./scripts/gh.sh issue list --state open, ./scripts/gh.sh label list --limit 100)" >&2
-    exit 1
-  fi
-  gh "$SUB1" "$SUB2" "${FLAGS[@]}"
-fi
--- a/scripts/git-push.sh
+++ b/scripts/git-push.sh
@ -1,36 +0,0 @@
-#!/usr/bin/env bash
-set -euo pipefail
-
-# Wrapper around `git push` that only allows `origin <ref>` with no flags.
-# Defends against --receive-pack / --exec RCE and arbitrary-remote exfiltration
-# (H1 #3556799). `git push:*` in allowedTools permits `git push --receive-pack='sh -c ...' ext::sh`
-# which runs arbitrary shell on the Actions runner. This wrapper closes that.
-#
-# Usage:
-#   git-push.sh origin HEAD
-#   git-push.sh origin claude/issue-123-20260304
-
-if [[ $# -ne 2 ]]; then
-  echo "Error: exactly two arguments required: origin <ref>" >&2
-  exit 1
-fi
-
-for arg in "$@"; do
-  if [[ "$arg" == -* ]]; then
-    echo "Error: flags are not allowed (got: $arg)" >&2
-    exit 1
-  fi
-done
-
-if [[ "$1" != "origin" ]]; then
-  echo "Error: remote must be 'origin' (got: $1)" >&2
-  exit 1
-fi
-
-REF="$2"
-if [[ "$REF" != "HEAD" ]] && ! git check-ref-format --branch "$REF" >/dev/null 2>&1; then
-  echo "Error: invalid ref: $REF" >&2
-  exit 1
-fi
-
-exec git push origin "$REF"
--- a/src/create-prompt/index.ts
+++ b/src/create-prompt/index.ts
@ -20,18 +20,19 @@ import {
 import type { ParsedGitHubContext } from "../github/context";
 import type { CommonFields, PreparedContext, EventData } from "./types";
 import { GITHUB_SERVER_URL } from "../github/api/config";
-import { extractUserRequest } from "../utils/extract-user-request";
+import type { Mode, ModeContext } from "../modes/types";
 export type { CommonFields, PreparedContext } from "./types";

-const GIT_PUSH_WRAPPER = `${process.env.GITHUB_ACTION_PATH}/scripts/git-push.sh`;
-
-/** Filename for the user request file, read by the SDK runner */
-const USER_REQUEST_FILENAME = "claude-user-request.txt";
-
-// Tag mode defaults - these tools are needed for tag mode to function.
-// Edit/MultiEdit/Write are intentionally omitted: acceptEdits permission mode
-// auto-allows file edits inside $GITHUB_WORKSPACE and denies writes outside it.
-const BASE_ALLOWED_TOOLS = ["Glob", "Grep", "LS", "Read"];
+// Tag mode defaults - these tools are needed for tag mode to function
+const BASE_ALLOWED_TOOLS = [
+  "Edit",
+  "MultiEdit",
+  "Glob",
+  "Grep",
+  "LS",
+  "Read",
+  "Write",
+];

 export function buildAllowedToolsString(
  customAllowedTools?: string[],
@ -55,7 +56,10 @@ export function buildAllowedToolsString(
    baseTools.push(
      "Bash(git add:*)",
      "Bash(git commit:*)",
-      `Bash(${GIT_PUSH_WRAPPER}:*)`,
+      "Bash(git push:*)",
+      "Bash(git status:*)",
+      "Bash(git diff:*)",
+      "Bash(git log:*)",
      "Bash(git rm:*)",
    );
  }
@ -427,7 +431,7 @@ function getCommitInstructions(
          Bash(git commit -m "<message>\\n\\n${coAuthorLine}")`
            : ""
        }
-        - Push to the remote: Bash(${GIT_PUSH_WRAPPER} origin HEAD)`;
+        - Push to the remote: Bash(git push origin HEAD)`;
    } else {
      const branchName = eventData.claudeBranch || eventData.baseBranch;
      return `
@ -441,7 +445,7 @@ function getCommitInstructions(
          Bash(git commit -m "<message>\\n\\n${coAuthorLine}")`
            : ""
        }
-        - Push to the remote: Bash(${GIT_PUSH_WRAPPER} origin ${branchName})`;
+        - Push to the remote: Bash(git push origin ${branchName})`;
    }
  }
 }
@ -450,31 +454,9 @@ export function generatePrompt(
  context: PreparedContext,
  githubData: FetchDataResult,
  useCommitSigning: boolean,
-  modeName: "tag" | "agent",
+  mode: Mode,
 ): string {
-  if (modeName === "agent") {
-    return context.prompt || `Repository: ${context.repository}`;
-  }
-
-  // Tag mode
-  const defaultPrompt = generateDefaultPrompt(
-    context,
-    githubData,
-    useCommitSigning,
-  );
-
-  if (context.githubContext?.inputs?.prompt) {
-    return (
-      defaultPrompt +
-      `
-
-<custom_instructions>
-${context.githubContext.inputs.prompt}
-</custom_instructions>`
-    );
-  }
-
-  return defaultPrompt;
+  return mode.generatePrompt(context, githubData, useCommitSigning);
 }

 /**
@ -752,13 +734,7 @@ ${eventData.eventName === "issue_comment" || eventData.eventName === "pull_reque
        - Reference specific code sections with file paths and line numbers${eventData.isPR ? `\n      - AFTER reading files and analyzing code, you MUST call mcp__github_comment__update_claude_comment to post your review` : ""}
      - Formulate a concise, technical, and helpful response based on the context.
      - Reference specific code with inline formatting or code blocks.
-      - Include relevant file paths and line numbers when applicable.${
-        eventData.isPR && context.githubContext?.inputs.includeFixLinks
-          ? `
-      - When identifying issues that could be fixed, include an inline link: [Fix this →](https://claude.ai/code?q=<URI_ENCODED_INSTRUCTIONS>&repo=${context.repository})
-        The query should be URI-encoded and include enough context for Claude Code to understand and fix the issue (file path, line numbers, branch name, what needs to change).`
-          : ""
-      }
+      - Include relevant file paths and line numbers when applicable.
      - ${eventData.isPR ? `IMPORTANT: Submit your review feedback by updating the Claude comment using mcp__github_comment__update_claude_comment. This will be displayed as your PR review.` : `Remember that this feedback must be posted to the GitHub comment using mcp__github_comment__update_claude_comment.`}

   B. For Straightforward Changes:
@ -816,7 +792,7 @@ ${
    : `- Use git commands via the Bash tool for version control (remember that you have access to these git commands):
  - Stage files: Bash(git add <files>)
  - Commit changes: Bash(git commit -m "<message>")
-  - Push to remote: Bash(${GIT_PUSH_WRAPPER} origin <branch>)
+  - Push to remote: Bash(git push origin <branch>) (NEVER force push)
  - Delete files: Bash(git rm <files>) followed by commit and push
  - Check status: Bash(git status)
  - View diff: Bash(git diff)${eventData.isPR && eventData.baseBranch ? `\n  - IMPORTANT: For PR diffs, use: Bash(git diff origin/${eventData.baseBranch}...HEAD)` : ""}`
@ -865,70 +841,29 @@ f. If you are unable to complete certain steps, such as running a linter or test
  return promptContent;
 }

-/**
- * Extracts the user's request from the prepared context and GitHub data.
- *
- * This is used to send the user's actual command/request as a separate
- * content block, enabling slash command processing in the CLI.
- *
- * @param context - The prepared context containing event data and trigger phrase
- * @param githubData - The fetched GitHub data containing issue/PR body content
- * @returns The extracted user request text (e.g., "/review-pr" or "fix this bug"),
- *          or null for assigned/labeled events without an explicit trigger in the body
- *
- * @example
- * // Comment event: "@claude /review-pr" -> returns "/review-pr"
- * // Issue body with "@claude fix this" -> returns "fix this"
- * // Issue assigned without @claude in body -> returns null
- */
-function extractUserRequestFromContext(
-  context: PreparedContext,
-  githubData: FetchDataResult,
-): string | null {
-  const { eventData, triggerPhrase } = context;
-
-  // For comment events, extract from comment body
-  if (
-    "commentBody" in eventData &&
-    eventData.commentBody &&
-    (eventData.eventName === "issue_comment" ||
-      eventData.eventName === "pull_request_review_comment" ||
-      eventData.eventName === "pull_request_review")
-  ) {
-    return extractUserRequest(eventData.commentBody, triggerPhrase);
-  }
-
-  // For issue/PR events triggered by body content, extract from the body
-  if (githubData.contextData?.body) {
-    const request = extractUserRequest(
-      githubData.contextData.body,
-      triggerPhrase,
-    );
-    if (request) {
-      return request;
-    }
-  }
-
-  // For assigned/labeled events without explicit trigger in body,
-  // return null to indicate the full context should be used
-  return null;
-}
-
 export async function createPrompt(
-  commentId: number,
-  baseBranch: string | undefined,
-  claudeBranch: string | undefined,
+  mode: Mode,
+  modeContext: ModeContext,
  githubData: FetchDataResult,
  context: ParsedGitHubContext,
 ) {
  try {
-    const claudeCommentId = commentId.toString();
+    // Prepare the context for prompt generation
+    let claudeCommentId: string = "";
+    if (mode.name === "tag") {
+      if (!modeContext.commentId) {
+        throw new Error(
+          `${mode.name} mode requires a comment ID for prompt generation`,
+        );
+      }
+      claudeCommentId = modeContext.commentId.toString();
+    }

    const preparedContext = prepareContext(
      context,
      claudeCommentId,
-      baseBranch,
-      claudeBranch,
+      modeContext.baseBranch,
+      modeContext.claudeBranch,
    );

    await mkdir(`${process.env.RUNNER_TEMP || "/tmp"}/claude-prompts`, {
@ -940,7 +875,7 @@ export async function createPrompt(
      preparedContext,
      githubData,
      context.inputs.useCommitSigning,
-      "tag",
+      mode,
    );

    // Log the final prompt to console
@ -954,33 +889,22 @@ export async function createPrompt(
      promptContent,
    );

-    // Extract and write the user request separately for SDK multi-block messaging
-    // This allows the CLI to process slash commands (e.g., "@claude /review-pr")
-    const userRequest = extractUserRequestFromContext(
-      preparedContext,
-      githubData,
-    );
-    if (userRequest) {
-      await writeFile(
-        `${process.env.RUNNER_TEMP || "/tmp"}/claude-prompts/${USER_REQUEST_FILENAME}`,
-        userRequest,
-      );
-      console.log("===== USER REQUEST =====");
-      console.log(userRequest);
-      console.log("========================");
-    }
-
-    // NOTE: these env var exports are dead — nothing reads ALLOWED_TOOLS / DISALLOWED_TOOLS.
-    // The live path is modes/tag/index.ts which builds --allowedTools into claudeArgs directly.
-    // Kept only so the H1 report's pointed-to file stays in sync with the live fix.
+    // Set allowed tools
    const hasActionsReadPermission = false;

+    // Get mode-specific tools
+    const modeAllowedTools = mode.getAllowedTools();
+    const modeDisallowedTools = mode.getDisallowedTools();
+
    const allAllowedTools = buildAllowedToolsString(
-      [],
+      modeAllowedTools,
      hasActionsReadPermission,
      context.inputs.useCommitSigning,
    );
-    const allDisallowedTools = buildDisallowedToolsString([], []);
+    const allDisallowedTools = buildDisallowedToolsString(
+      modeDisallowedTools,
+      modeAllowedTools,
+    );

    core.exportVariable("ALLOWED_TOOLS", allAllowedTools);
    core.exportVariable("DISALLOWED_TOOLS", allDisallowedTools);
--- a/src/entrypoints/cleanup-ssh-signing.ts
+++ b/src/entrypoints/cleanup-ssh-signing.ts
@ -1,21 +0,0 @@
-#!/usr/bin/env bun
-
-/**
- * Cleanup SSH signing key after action completes
- * This is run as a post step for security purposes
- */
-
-import { cleanupSshSigning } from "../github/operations/git-config";
-
-async function run() {
-  try {
-    await cleanupSshSigning();
-  } catch (error) {
-    // Don't fail the action if cleanup fails, just log it
-    console.error("Failed to cleanup SSH signing key:", error);
-  }
-}
-
-if (import.meta.main) {
-  run();
-}
--- a/src/entrypoints/collect-inputs.ts
+++ b/src/entrypoints/collect-inputs.ts
@ -1,4 +1,6 @@
-export function collectActionInputsPresence(): string {
+import * as core from "@actions/core";
+
+export function collectActionInputsPresence(): void {
  const inputDefaults: Record<string, string> = {
    trigger_phrase: "@claude",
    assignee_trigger: "",
@ -23,15 +25,14 @@ export function collectActionInputsPresence(): string {
    github_token: "",
    max_turns: "",
    use_sticky_comment: "false",
-    classify_inline_comments: "true",
    use_commit_signing: "false",
-    ssh_signing_key: "",
  };

  const allInputsJson = process.env.ALL_INPUTS;
  if (!allInputsJson) {
    console.log("ALL_INPUTS environment variable not found");
-    return JSON.stringify({});
+    core.setOutput("action_inputs_present", JSON.stringify({}));
+    return;
  }

  let allInputs: Record<string, string>;
@ -39,7 +40,8 @@ export function collectActionInputsPresence(): string {
    allInputs = JSON.parse(allInputsJson);
  } catch (e) {
    console.error("Failed to parse ALL_INPUTS JSON:", e);
-    return JSON.stringify({});
+    core.setOutput("action_inputs_present", JSON.stringify({}));
+    return;
  }

  const presentInputs: Record<string, boolean> = {};
@ -51,5 +53,5 @@ export function collectActionInputsPresence(): string {
    presentInputs[name] = isSet;
  }

-  return JSON.stringify(presentInputs);
+  core.setOutput("action_inputs_present", JSON.stringify(presentInputs));
 }
--- a/src/entrypoints/post-buffered-inline-comments.ts
+++ b/src/entrypoints/post-buffered-inline-comments.ts
@ -1,233 +0,0 @@
-#!/usr/bin/env bun
-/**
- * Reads buffered inline-comment calls from /tmp/inline-comments-buffer.jsonl,
- * classifies each as "real review" vs "test/probe" using Haiku, and posts
- * only the real ones. Calls with confirmed=false are never posted.
- *
- * If the Anthropic API is unavailable (Bedrock/Vertex users without a direct
- * key), falls back to posting everything with confirmed !== false. This
- * preserves backward compatibility — before this change, all unconfirmed
- * calls posted immediately.
- */
-import { readFileSync } from "fs";
-import { createOctokit } from "../github/api/client";
-
-const BUFFER_PATH = "/tmp/inline-comments-buffer.jsonl";
-
-type BufferedComment = {
-  ts: string;
-  path: string;
-  line?: number;
-  startLine?: number;
-  side?: "LEFT" | "RIGHT";
-  commit_id?: string;
-  body: string;
-  confirmed?: boolean;
-};
-
-const CLASSIFICATION_PROMPT = `You are classifying PR inline comments as either REAL code review feedback or TEST/PROBE calls.
-
-A TEST/PROBE call is when an automated agent is checking whether a commenting tool works. These typically:
- Start with phrases like "Test comment", "Testing if", "Can I", "Does this work", "Checking if"
- Have generic/placeholder content not specific to any code
- Exist to verify tool functionality, not to provide review feedback
-
-A REAL review comment:
- Discusses specific code, logic, bugs, or style
- Provides actionable feedback for the PR author
- References concrete aspects of the change
-
-For each numbered comment body below, respond with ONLY a JSON array of booleans where true = REAL review comment, false = test/probe. No other text.
-
-Comments:
-`;
-
-async function classifyComments(bodies: string[]): Promise<boolean[] | null> {
-  const apiKey = process.env.ANTHROPIC_API_KEY;
-  if (!apiKey) {
-    console.log(
-      "ANTHROPIC_API_KEY not set — skipping classification, posting all unconfirmed comments",
-    );
-    return null;
-  }
-
-  const prompt =
-    CLASSIFICATION_PROMPT +
-    bodies.map((b, i) => `${i + 1}. ${JSON.stringify(b)}`).join("\n");
-
-  try {
-    const res = await fetch("https://api.anthropic.com/v1/messages", {
-      method: "POST",
-      headers: {
-        "content-type": "application/json",
-        "x-api-key": apiKey,
-        "anthropic-version": "2023-06-01",
-      },
-      body: JSON.stringify({
-        model: "claude-haiku-4-5",
-        max_tokens: 1024,
-        messages: [{ role: "user", content: prompt }],
-      }),
-    });
-
-    if (!res.ok) {
-      console.log(
-        `Classification API returned ${res.status} — posting all unconfirmed comments`,
-      );
-      return null;
-    }
-
-    const data = (await res.json()) as {
-      content: { type: string; text: string }[];
-    };
-    const text = data.content.find((c) => c.type === "text")?.text ?? "";
-    const match = text.match(/\[[\s\S]*\]/);
-    if (!match) {
-      console.log(
-        "Could not parse classification response — posting all unconfirmed comments",
-      );
-      return null;
-    }
-    const parsed = JSON.parse(match[0]);
-    if (
-      !Array.isArray(parsed) ||
-      parsed.length !== bodies.length ||
-      !parsed.every((v) => typeof v === "boolean")
-    ) {
-      console.log(
-        "Classification response shape mismatch — posting all unconfirmed comments",
-      );
-      return null;
-    }
-    return parsed;
-  } catch (e) {
-    console.log(
-      `Classification failed (${e instanceof Error ? e.message : String(e)}) — posting all unconfirmed comments`,
-    );
-    return null;
-  }
-}
-
-async function postComment(
-  octokit: ReturnType<typeof createOctokit>["rest"],
-  owner: string,
-  repo: string,
-  pull_number: number,
-  headSha: string,
-  c: BufferedComment,
-): Promise<boolean> {
-  const params: Parameters<typeof octokit.rest.pulls.createReviewComment>[0] = {
-    owner,
-    repo,
-    pull_number,
-    body: c.body,
-    path: c.path,
-    side: c.side || "RIGHT",
-    commit_id: c.commit_id || headSha,
-  };
-  if (c.startLine) {
-    params.start_line = c.startLine;
-    params.start_side = c.side || "RIGHT";
-    params.line = c.line;
-  } else {
-    params.line = c.line;
-  }
-  try {
-    await octokit.rest.pulls.createReviewComment(params);
-    return true;
-  } catch (e) {
-    console.log(
-      `  failed ${c.path}:${c.line}: ${e instanceof Error ? e.message : String(e)}`,
-    );
-    return false;
-  }
-}
-
-async function main() {
-  let raw: string;
-  try {
-    raw = readFileSync(BUFFER_PATH, "utf8");
-  } catch {
-    console.log("No buffered inline comments");
-    return;
-  }
-
-  const comments: BufferedComment[] = raw
-    .split("\n")
-    .filter(Boolean)
-    .map((line) => JSON.parse(line));
-
-  if (comments.length === 0) {
-    console.log("No buffered inline comments");
-    return;
-  }
-
-  console.log(`Found ${comments.length} buffered inline comment(s)`);
-
-  const githubToken = process.env.GITHUB_TOKEN;
-  const owner = process.env.REPO_OWNER;
-  const repo = process.env.REPO_NAME;
-  const prNumber = process.env.PR_NUMBER;
-
-  if (!githubToken || !owner || !repo || !prNumber) {
-    console.log(
-      "::warning::Missing GITHUB_TOKEN/REPO_OWNER/REPO_NAME/PR_NUMBER — cannot post buffered comments",
-    );
-    return;
-  }
-
-  // Partition: confirmed=false are never posted; the rest are candidates
-  const neverPost = comments.filter((c) => c.confirmed === false);
-  const candidates = comments.filter((c) => c.confirmed !== false);
-
-  if (neverPost.length > 0) {
-    console.log(`  ${neverPost.length} with confirmed=false — not posting`);
-  }
-
-  if (candidates.length === 0) {
-    return;
-  }
-
-  // Classify candidates
-  const verdicts = await classifyComments(candidates.map((c) => c.body));
-  const toPost =
-    verdicts === null
-      ? candidates
-      : candidates.filter((_, i) => verdicts[i] === true);
-  const filtered =
-    verdicts === null ? [] : candidates.filter((_, i) => verdicts[i] === false);
-
-  if (filtered.length > 0) {
-    console.log(
-      `::warning::${filtered.length} buffered comment(s) classified as test/probe — NOT posted:`,
-    );
-    for (const c of filtered) {
-      console.log(`  [${c.path}:${c.line}] ${c.body.slice(0, 120)}`);
-    }
-  }
-
-  if (toPost.length === 0) {
-    console.log("No real comments to post");
-    return;
-  }
-
-  const octokit = createOctokit(githubToken).rest;
-  const pull_number = parseInt(prNumber, 10);
-  const pr = await octokit.pulls.get({ owner, repo, pull_number });
-  const headSha = pr.data.head.sha;
-
-  console.log(`Posting ${toPost.length} classified-as-real comment(s)`);
-  let posted = 0;
-  for (const c of toPost) {
-    if (await postComment(octokit, owner, repo, pull_number, headSha, c)) {
-      console.log(`  posted ${c.path}:${c.line}`);
-      posted++;
-    }
-  }
-  console.log(`Posted ${posted}/${toPost.length}`);
-}
-
-main().catch((e) => {
-  console.error("post-buffered-inline-comments failed:", e);
-  process.exit(1);
-});
--- a/src/entrypoints/prepare.ts
+++ b/src/entrypoints/prepare.ts
@ -10,10 +10,8 @@ import { setupGitHubToken } from "../github/token";
 import { checkWritePermissions } from "../github/validation/permissions";
 import { createOctokit } from "../github/api/client";
 import { parseGitHubContext, isEntityContext } from "../github/context";
-import { detectMode } from "../modes/detector";
-import { prepareTagMode } from "../modes/tag";
-import { prepareAgentMode } from "../modes/agent";
-import { checkContainsTrigger } from "../github/validation/trigger";
+import { getMode } from "../modes/registry";
+import { prepare } from "../prepare";
 import { collectActionInputsPresence } from "./collect-inputs";

 async function run() {
@ -24,10 +22,7 @@ async function run() {
    const context = parseGitHubContext();

    // Auto-detect mode based on context
-    const modeName = detectMode(context);
-    console.log(
-      `Auto-detected mode: ${modeName} for event: ${context.eventName}`,
-    );
+    const mode = getMode(context);

    // Setup GitHub token
    const githubToken = await setupGitHubToken();
@ -51,13 +46,10 @@ async function run() {
    }

    // Check trigger conditions
-    const containsTrigger =
-      modeName === "tag"
-        ? isEntityContext(context) && checkContainsTrigger(context)
-        : !!context.inputs?.prompt;
+    const containsTrigger = mode.shouldTrigger(context);

    // Debug logging
-    console.log(`Mode: ${modeName}`);
+    console.log(`Mode: ${mode.name}`);
    console.log(`Context prompt: ${context.inputs?.prompt || "NO PROMPT"}`);
    console.log(`Trigger result: ${containsTrigger}`);

@ -71,20 +63,31 @@ async function run() {
      return;
    }

-    // Run prepare
-    console.log(
-      `Preparing with mode: ${modeName} for event: ${context.eventName}`,
-    );
-    if (modeName === "tag") {
-      await prepareTagMode({ context, octokit, githubToken });
-    } else {
-      await prepareAgentMode({ context, octokit, githubToken });
-    }
+    // Step 5: Use the new modular prepare function
+    const result = await prepare({
+      context,
+      octokit,
+      mode,
+      githubToken,
+    });

    // MCP config is handled by individual modes (tag/agent) and included in their claude_args output

    // Expose the GitHub token (Claude App token) as an output
    core.setOutput("github_token", githubToken);
+
+    // Step 6: Get system prompt from mode if available
+    if (mode.getSystemPrompt) {
+      const modeContext = mode.prepareContext(context, {
+        commentId: result.commentId,
+        baseBranch: result.branchInfo.baseBranch,
+        claudeBranch: result.branchInfo.claudeBranch,
+      });
+      const systemPrompt = mode.getSystemPrompt(modeContext);
+      if (systemPrompt) {
+        core.exportVariable("APPEND_SYSTEM_PROMPT", systemPrompt);
+      }
+    }
  } catch (error) {
    const errorMessage = error instanceof Error ? error.message : String(error);
    core.setFailed(`Prepare step failed with error: ${errorMessage}`);
--- a/src/entrypoints/run.ts
+++ b/src/entrypoints/run.ts
@ -1,353 +0,0 @@
-#!/usr/bin/env bun
-
-/**
- * Unified entrypoint for the Claude Code Action.
- * Merges all previously separate action.yml steps (prepare, install, run, cleanup)
- * into a single TypeScript orchestrator.
- */
-
-import * as core from "@actions/core";
-import { dirname } from "path";
-import { spawn } from "child_process";
-import { appendFile } from "fs/promises";
-import { existsSync, readFileSync } from "fs";
-import { setupGitHubToken, WorkflowValidationSkipError } from "../github/token";
-import { checkWritePermissions } from "../github/validation/permissions";
-import { createOctokit } from "../github/api/client";
-import type { Octokits } from "../github/api/client";
-import {
-  parseGitHubContext,
-  isEntityContext,
-  isPullRequestEvent,
-  isPullRequestReviewEvent,
-  isPullRequestReviewCommentEvent,
-} from "../github/context";
-import type { GitHubContext } from "../github/context";
-import { detectMode } from "../modes/detector";
-import { prepareTagMode } from "../modes/tag";
-import { prepareAgentMode } from "../modes/agent";
-import { checkContainsTrigger } from "../github/validation/trigger";
-import { restoreConfigFromBase } from "../github/operations/restore-config";
-import { validateBranchName } from "../github/operations/branch";
-import { collectActionInputsPresence } from "./collect-inputs";
-import { updateCommentLink } from "./update-comment-link";
-import { formatTurnsFromData } from "./format-turns";
-import type { Turn } from "./format-turns";
-// Base-action imports (used directly instead of subprocess)
-import { validateEnvironmentVariables } from "../../base-action/src/validate-env";
-import { setupClaudeCodeSettings } from "../../base-action/src/setup-claude-code-settings";
-import { installPlugins } from "../../base-action/src/install-plugins";
-import { preparePrompt } from "../../base-action/src/prepare-prompt";
-import { runClaude } from "../../base-action/src/run-claude";
-import type { ClaudeRunResult } from "../../base-action/src/run-claude-sdk";
-
-/**
- * Install Claude Code CLI, handling retry logic and custom executable paths.
- * Returns the absolute path to the claude executable.
- */
-async function installClaudeCode(): Promise<string> {
-  const customExecutable = process.env.PATH_TO_CLAUDE_CODE_EXECUTABLE;
-  if (customExecutable) {
-    if (/[\x00-\x1f\x7f]/.test(customExecutable)) {
-      throw new Error(
-        "PATH_TO_CLAUDE_CODE_EXECUTABLE contains control characters (e.g. newlines), which is not allowed",
-      );
-    }
-    console.log(`Using custom Claude Code executable: ${customExecutable}`);
-    const claudeDir = dirname(customExecutable);
-    // Add to PATH by appending to GITHUB_PATH
-    const githubPath = process.env.GITHUB_PATH;
-    if (githubPath) {
-      await appendFile(githubPath, `${claudeDir}\n`);
-    }
-    // Also add to current process PATH
-    process.env.PATH = `${claudeDir}:${process.env.PATH}`;
-    return customExecutable;
-  }
-
-  const claudeCodeVersion = "2.1.123";
-  console.log(`Installing Claude Code v${claudeCodeVersion}...`);
-
-  for (let attempt = 1; attempt <= 3; attempt++) {
-    console.log(`Installation attempt ${attempt}...`);
-    try {
-      await new Promise<void>((resolve, reject) => {
-        const child = spawn(
-          "bash",
-          [
-            "-c",
-            `curl -fsSL https://claude.ai/install.sh | bash -s -- ${claudeCodeVersion}`,
-          ],
-          { stdio: "inherit" },
-        );
-        child.on("close", (code) => {
-          if (code === 0) resolve();
-          else reject(new Error(`Install failed with exit code ${code}`));
-        });
-        child.on("error", reject);
-      });
-      console.log("Claude Code installed successfully");
-      // Add to PATH
-      const homeBin = `${process.env.HOME}/.local/bin`;
-      const githubPath = process.env.GITHUB_PATH;
-      if (githubPath) {
-        await appendFile(githubPath, `${homeBin}\n`);
-      }
-      process.env.PATH = `${homeBin}:${process.env.PATH}`;
-      return `${homeBin}/claude`;
-    } catch (error) {
-      if (attempt === 3) {
-        throw new Error(
-          `Failed to install Claude Code after 3 attempts: ${error}`,
-        );
-      }
-      console.log("Installation failed, retrying...");
-      await new Promise((resolve) => setTimeout(resolve, 5000));
-    }
-  }
-  throw new Error("unreachable");
-}
-
-/**
- * Write the step summary from Claude's execution output file.
- */
-async function writeStepSummary(executionFile: string): Promise<void> {
-  const summaryFile = process.env.GITHUB_STEP_SUMMARY;
-  if (!summaryFile) return;
-
-  try {
-    const fileContent = readFileSync(executionFile, "utf-8");
-    const data: Turn[] = JSON.parse(fileContent);
-    const markdown = formatTurnsFromData(data);
-    await appendFile(summaryFile, markdown);
-    console.log("Successfully formatted Claude Code report");
-  } catch (error) {
-    console.error(`Failed to format output: ${error}`);
-    // Fall back to raw JSON
-    try {
-      let fallback = "## Claude Code Report (Raw Output)\n\n";
-      fallback +=
-        "Failed to format output (please report). Here's the raw JSON:\n\n";
-      fallback += "```json\n";
-      fallback += readFileSync(executionFile, "utf-8");
-      fallback += "\n```\n";
-      await appendFile(summaryFile, fallback);
-    } catch {
-      console.error("Failed to write raw output to step summary");
-    }
-  }
-}
-
-async function run() {
-  let githubToken: string | undefined;
-  let commentId: number | undefined;
-  let claudeBranch: string | undefined;
-  let baseBranch: string | undefined;
-  let executionFile: string | undefined;
-  let claudeSuccess = false;
-  let prepareSuccess = true;
-  let prepareError: string | undefined;
-  let context: GitHubContext | undefined;
-  let octokit: Octokits | undefined;
-  // Track whether we've completed prepare phase, so we can attribute errors correctly
-  let prepareCompleted = false;
-  try {
-    // Phase 1: Prepare
-    const actionInputsPresent = collectActionInputsPresence();
-    context = parseGitHubContext();
-    const modeName = detectMode(context);
-    console.log(
-      `Auto-detected mode: ${modeName} for event: ${context.eventName}`,
-    );
-
-    try {
-      githubToken = await setupGitHubToken();
-    } catch (error) {
-      if (error instanceof WorkflowValidationSkipError) {
-        core.setOutput("skipped_due_to_workflow_validation_mismatch", "true");
-        console.log("Exiting due to workflow validation skip");
-        return;
-      }
-      throw error;
-    }
-
-    octokit = createOctokit(githubToken);
-
-    // Set GITHUB_TOKEN and GH_TOKEN in process env for downstream usage
-    process.env.GITHUB_TOKEN = githubToken;
-    process.env.GH_TOKEN = githubToken;
-
-    // Check write permissions (only for entity contexts)
-    if (isEntityContext(context)) {
-      const hasWritePermissions = await checkWritePermissions(
-        octokit.rest,
-        context,
-        context.inputs.allowedNonWriteUsers,
-        !!process.env.OVERRIDE_GITHUB_TOKEN,
-      );
-      if (!hasWritePermissions) {
-        throw new Error(
-          "Actor does not have write permissions to the repository",
-        );
-      }
-    }
-
-    // Check trigger conditions
-    const containsTrigger =
-      modeName === "tag"
-        ? isEntityContext(context) && checkContainsTrigger(context)
-        : !!context.inputs?.prompt;
-    console.log(`Mode: ${modeName}`);
-    console.log(`Context prompt: ${context.inputs?.prompt || "NO PROMPT"}`);
-    console.log(`Trigger result: ${containsTrigger}`);
-
-    if (!containsTrigger) {
-      console.log("No trigger found, skipping remaining steps");
-      core.setOutput("github_token", githubToken);
-      return;
-    }
-
-    // Run prepare
-    console.log(
-      `Preparing with mode: ${modeName} for event: ${context.eventName}`,
-    );
-    const prepareResult =
-      modeName === "tag"
-        ? await prepareTagMode({ context, octokit, githubToken })
-        : await prepareAgentMode({ context, octokit, githubToken });
-
-    commentId = prepareResult.commentId;
-    claudeBranch = prepareResult.branchInfo.claudeBranch;
-    baseBranch = prepareResult.branchInfo.baseBranch;
-    prepareCompleted = true;
-
-    // Phase 2: Install Claude Code CLI
-    const claudeExecutable = await installClaudeCode();
-
-    // Phase 3: Run Claude (import base-action directly)
-    // Set env vars needed by the base-action code
-    process.env.INPUT_ACTION_INPUTS_PRESENT = actionInputsPresent;
-    process.env.CLAUDE_CODE_ACTION = "1";
-    process.env.DETAILED_PERMISSION_MESSAGES = "1";
-
-    validateEnvironmentVariables();
-
-    // On PRs, .claude/ and .mcp.json in the checkout are attacker-controlled.
-    // Restore them from the base branch before the CLI reads them.
-    //
-    // We read pull_request.base.ref from the payload directly because agent
-    // mode's branchInfo.baseBranch defaults to the repo's default branch rather
-    // than the PR's actual target (agent/index.ts). For issue_comment on a PR the payload
-    // lacks base.ref, so we fall back to the mode-provided value — tag mode
-    // fetches it from GraphQL; agent mode on issue_comment is an edge case
-    // that at worst restores from the wrong trusted branch (still secure).
-    if (isEntityContext(context) && context.isPR) {
-      let restoreBase = baseBranch;
-      if (
-        isPullRequestEvent(context) ||
-        isPullRequestReviewEvent(context) ||
-        isPullRequestReviewCommentEvent(context)
-      ) {
-        restoreBase = context.payload.pull_request.base.ref;
-        validateBranchName(restoreBase);
-      }
-      if (restoreBase) {
-        restoreConfigFromBase(restoreBase);
-      }
-    }
-
-    await setupClaudeCodeSettings(process.env.INPUT_SETTINGS);
-
-    await installPlugins(
-      process.env.INPUT_PLUGIN_MARKETPLACES,
-      process.env.INPUT_PLUGINS,
-      claudeExecutable,
-    );
-
-    const promptFile =
-      process.env.INPUT_PROMPT_FILE ||
-      `${process.env.RUNNER_TEMP}/claude-prompts/claude-prompt.txt`;
-    const promptConfig = await preparePrompt({
-      prompt: "",
-      promptFile,
-    });
-
-    const claudeResult: ClaudeRunResult = await runClaude(promptConfig.path, {
-      claudeArgs: prepareResult.claudeArgs,
-      appendSystemPrompt: process.env.APPEND_SYSTEM_PROMPT,
-      model: process.env.ANTHROPIC_MODEL,
-      pathToClaudeCodeExecutable: claudeExecutable,
-      showFullOutput: process.env.INPUT_SHOW_FULL_OUTPUT,
-    });
-
-    claudeSuccess = claudeResult.conclusion === "success";
-    executionFile = claudeResult.executionFile;
-
-    // Set action-level outputs
-    if (claudeResult.executionFile) {
-      core.setOutput("execution_file", claudeResult.executionFile);
-    }
-    if (claudeResult.sessionId) {
-      core.setOutput("session_id", claudeResult.sessionId);
-    }
-    if (claudeResult.structuredOutput) {
-      core.setOutput("structured_output", claudeResult.structuredOutput);
-    }
-    core.setOutput("conclusion", claudeResult.conclusion);
-  } catch (error) {
-    const errorMessage = error instanceof Error ? error.message : String(error);
-    // Only mark as prepare failure if we haven't completed the prepare phase
-    if (!prepareCompleted) {
-      prepareSuccess = false;
-      prepareError = errorMessage;
-    }
-    core.setFailed(`Action failed with error: ${errorMessage}`);
-  } finally {
-    // Phase 4: Cleanup (always runs)
-
-    // Update tracking comment
-    if (
-      commentId &&
-      context &&
-      isEntityContext(context) &&
-      githubToken &&
-      octokit
-    ) {
-      try {
-        await updateCommentLink({
-          commentId,
-          githubToken,
-          claudeBranch,
-          baseBranch: baseBranch || context.repository.default_branch || "main",
-          triggerUsername: context.actor,
-          context,
-          octokit,
-          claudeSuccess,
-          outputFile: executionFile,
-          prepareSuccess,
-          prepareError,
-          useCommitSigning: context.inputs.useCommitSigning,
-        });
-      } catch (error) {
-        console.error("Error updating comment with job link:", error);
-      }
-    }
-
-    // Write step summary (unless display_report is set to false)
-    if (
-      executionFile &&
-      existsSync(executionFile) &&
-      process.env.DISPLAY_REPORT !== "false"
-    ) {
-      await writeStepSummary(executionFile);
-    }
-
-    // Set remaining action-level outputs
-    core.setOutput("branch_name", claudeBranch);
-    core.setOutput("github_token", githubToken);
-  }
-}
-
-if (import.meta.main) {
-  run();
-}
--- a/src/entrypoints/update-comment-link.ts
+++ b/src/entrypoints/update-comment-link.ts
@ -1,7 +1,6 @@
 #!/usr/bin/env bun

 import { createOctokit } from "../github/api/client";
-import type { Octokits } from "../github/api/client";
 import * as fs from "fs/promises";
 import {
  updateCommentBody,
@ -12,258 +11,229 @@ import {
  isPullRequestReviewCommentEvent,
  isEntityContext,
 } from "../github/context";
-import type { ParsedGitHubContext } from "../github/context";
 import { GITHUB_SERVER_URL } from "../github/api/config";
 import { checkAndCommitOrDeleteBranch } from "../github/operations/branch-cleanup";
 import { updateClaudeComment } from "../github/operations/comments/update-claude-comment";

-export type UpdateCommentLinkParams = {
-  commentId: number;
-  githubToken: string;
-  claudeBranch?: string;
-  baseBranch: string;
-  triggerUsername?: string;
-  context: ParsedGitHubContext;
-  octokit: Octokits;
-  claudeSuccess: boolean;
-  outputFile?: string;
-  prepareSuccess: boolean;
-  prepareError?: string;
-  useCommitSigning: boolean;
-};
-
-export async function updateCommentLink(
-  params: UpdateCommentLinkParams,
-): Promise<void> {
-  const {
-    commentId,
-    claudeBranch,
-    baseBranch,
-    triggerUsername,
-    context,
-    octokit,
-    useCommitSigning,
-  } = params;
-
-  const { owner, repo } = context.repository;
-
-  const serverUrl = GITHUB_SERVER_URL;
-  const jobUrl = `${serverUrl}/${owner}/${repo}/actions/runs/${process.env.GITHUB_RUN_ID}`;
-
-  let comment;
-  let isPRReviewComment = false;
-
-  try {
-    // GitHub has separate ID namespaces for review comments and issue comments
-    // We need to use the correct API based on the event type
-    if (isPullRequestReviewCommentEvent(context)) {
-      // For PR review comments, use the pulls API
-      console.log(`Fetching PR review comment ${commentId}`);
-      const { data: prComment } = await octokit.rest.pulls.getReviewComment({
-        owner,
-        repo,
-        comment_id: commentId,
-      });
-      comment = prComment;
-      isPRReviewComment = true;
-      console.log("Successfully fetched as PR review comment");
-    }
-
-    // For all other event types, use the issues API
-    if (!comment) {
-      console.log(`Fetching issue comment ${commentId}`);
-      const { data: issueComment } = await octokit.rest.issues.getComment({
-        owner,
-        repo,
-        comment_id: commentId,
-      });
-      comment = issueComment;
-      isPRReviewComment = false;
-      console.log("Successfully fetched as issue comment");
-    }
-  } catch (finalError) {
-    // If all attempts fail, try to determine more information about the comment
-    console.error("Failed to fetch comment. Debug info:");
-    console.error(`Comment ID: ${commentId}`);
-    console.error(`Event name: ${context.eventName}`);
-    console.error(`Entity number: ${context.entityNumber}`);
-    console.error(`Repository: ${context.repository.full_name}`);
-
-    // Try to get the PR info to understand the comment structure
-    try {
-      const { data: pr } = await octokit.rest.pulls.get({
-        owner,
-        repo,
-        pull_number: context.entityNumber,
-      });
-      console.log(`PR state: ${pr.state}`);
-      console.log(`PR comments count: ${pr.comments}`);
-      console.log(`PR review comments count: ${pr.review_comments}`);
-    } catch {
-      console.error("Could not fetch PR info for debugging");
-    }
-
-    throw finalError;
-  }
-
-  const currentBody = comment.body ?? "";
-
-  // Check if we need to add branch link for new branches
-  const { shouldDeleteBranch, branchLink } = await checkAndCommitOrDeleteBranch(
-    octokit,
-    owner,
-    repo,
-    claudeBranch,
-    baseBranch,
-    useCommitSigning,
-  );
-
-  // Check if we need to add PR URL when we have a new branch
-  let prLink = "";
-  // If claudeBranch is set, it means we created a new branch (for issues or closed/merged PRs)
-  if (claudeBranch && !shouldDeleteBranch) {
-    // Check if comment already contains a PR URL
-    const serverUrlPattern = serverUrl.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-    const prUrlPattern = new RegExp(
-      `${serverUrlPattern}\\/.+\\/compare\\/${baseBranch.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\\.\\.\\.`,
-    );
-    const containsPRUrl = currentBody.match(prUrlPattern);
-
-    if (!containsPRUrl) {
-      // Check if there are changes to the branch compared to the default branch
-      try {
-        const { data: comparison } =
-          await octokit.rest.repos.compareCommitsWithBasehead({
-            owner,
-            repo,
-            basehead: `${baseBranch}...${claudeBranch}`,
-          });
-
-        // If there are changes (commits or file changes), add the PR URL
-        if (
-          comparison.total_commits > 0 ||
-          (comparison.files && comparison.files.length > 0)
-        ) {
-          const entityType = context.isPR ? "PR" : "Issue";
-          const prTitle = encodeURIComponent(
-            `${entityType} #${context.entityNumber}: Changes from Claude`,
-          );
-          const prBody = encodeURIComponent(
-            `This PR addresses ${entityType.toLowerCase()} #${context.entityNumber}\n\nGenerated with [Claude Code](https://claude.ai/code)`,
-          );
-          const prUrl = `${serverUrl}/${owner}/${repo}/compare/${baseBranch}...${claudeBranch}?quick_pull=1&title=${prTitle}&body=${prBody}`;
-          prLink = `\n[Create a PR](${prUrl})`;
-        }
-      } catch (error) {
-        console.error("Error checking for changes in branch:", error);
-        // Don't fail the entire update if we can't check for changes
-      }
-    }
-  }
-
-  // Check if action failed and read output file for execution details
-  let executionDetails: {
-    total_cost_usd?: number;
-    duration_ms?: number;
-    duration_api_ms?: number;
-  } | null = null;
-  let actionFailed = false;
-  let errorDetails: string | undefined;
-
-  if (!params.prepareSuccess && params.prepareError) {
-    actionFailed = true;
-    errorDetails = params.prepareError;
-  } else {
-    // Check for existence of output file and parse it if available
-    try {
-      if (params.outputFile) {
-        const fileContent = await fs.readFile(params.outputFile, "utf8");
-        const outputData = JSON.parse(fileContent);
-
-        // Output file is an array, get the last element which contains execution details
-        if (Array.isArray(outputData) && outputData.length > 0) {
-          const lastElement = outputData[outputData.length - 1];
-          if (
-            lastElement.type === "result" &&
-            "total_cost_usd" in lastElement &&
-            "duration_ms" in lastElement
-          ) {
-            executionDetails = {
-              total_cost_usd: lastElement.total_cost_usd,
-              duration_ms: lastElement.duration_ms,
-              duration_api_ms: lastElement.duration_api_ms,
-            };
-          }
-        }
-      }
-
-      actionFailed = !params.claudeSuccess;
-    } catch (error) {
-      console.error("Error reading output file:", error);
-      actionFailed = !params.claudeSuccess;
-    }
-  }
-
-  // Prepare input for updateCommentBody function
-  const commentInput: CommentUpdateInput = {
-    currentBody,
-    actionFailed,
-    executionDetails,
-    jobUrl,
-    branchLink,
-    prLink,
-    branchName: shouldDeleteBranch || !branchLink ? undefined : claudeBranch,
-    triggerUsername,
-    errorDetails,
-  };
-
-  const updatedBody = updateCommentBody(commentInput);
-
-  try {
-    await updateClaudeComment(octokit.rest, {
-      owner,
-      repo,
-      commentId,
-      body: updatedBody,
-      isPullRequestReviewComment: isPRReviewComment,
-    });
-    console.log(
-      `✅ Updated ${isPRReviewComment ? "PR review" : "issue"} comment ${commentId} with job link`,
-    );
-  } catch (updateError) {
-    console.error(
-      `Failed to update ${isPRReviewComment ? "PR review" : "issue"} comment:`,
-      updateError,
-    );
-    throw updateError;
-  }
-}
-
 async function run() {
  try {
+    const commentId = parseInt(process.env.CLAUDE_COMMENT_ID!);
+    const githubToken = process.env.GITHUB_TOKEN!;
+    const claudeBranch = process.env.CLAUDE_BRANCH;
+    const baseBranch = process.env.BASE_BRANCH || "main";
+    const triggerUsername = process.env.TRIGGER_USERNAME;
+
    const context = parseGitHubContext();
+
+    // This script is only called for entity-based events
    if (!isEntityContext(context)) {
      throw new Error("update-comment-link requires an entity context");
    }

-    const githubToken = process.env.GITHUB_TOKEN!;
+    const { owner, repo } = context.repository;
+
    const octokit = createOctokit(githubToken);

-    await updateCommentLink({
-      commentId: parseInt(process.env.CLAUDE_COMMENT_ID!),
-      githubToken,
-      claudeBranch: process.env.CLAUDE_BRANCH,
-      baseBranch:
-        process.env.BASE_BRANCH || context.repository.default_branch || "main",
-      triggerUsername: process.env.TRIGGER_USERNAME,
-      context,
-      octokit,
-      claudeSuccess: process.env.CLAUDE_SUCCESS !== "false",
-      outputFile: process.env.OUTPUT_FILE,
-      prepareSuccess: process.env.PREPARE_SUCCESS !== "false",
-      prepareError: process.env.PREPARE_ERROR,
-      useCommitSigning: process.env.USE_COMMIT_SIGNING === "true",
-    });
+    const serverUrl = GITHUB_SERVER_URL;
+    const jobUrl = `${serverUrl}/${owner}/${repo}/actions/runs/${process.env.GITHUB_RUN_ID}`;
+
+    let comment;
+    let isPRReviewComment = false;
+
+    try {
+      // GitHub has separate ID namespaces for review comments and issue comments
+      // We need to use the correct API based on the event type
+      if (isPullRequestReviewCommentEvent(context)) {
+        // For PR review comments, use the pulls API
+        console.log(`Fetching PR review comment ${commentId}`);
+        const { data: prComment } = await octokit.rest.pulls.getReviewComment({
+          owner,
+          repo,
+          comment_id: commentId,
+        });
+        comment = prComment;
+        isPRReviewComment = true;
+        console.log("Successfully fetched as PR review comment");
+      }
+
+      // For all other event types, use the issues API
+      if (!comment) {
+        console.log(`Fetching issue comment ${commentId}`);
+        const { data: issueComment } = await octokit.rest.issues.getComment({
+          owner,
+          repo,
+          comment_id: commentId,
+        });
+        comment = issueComment;
+        isPRReviewComment = false;
+        console.log("Successfully fetched as issue comment");
+      }
+    } catch (finalError) {
+      // If all attempts fail, try to determine more information about the comment
+      console.error("Failed to fetch comment. Debug info:");
+      console.error(`Comment ID: ${commentId}`);
+      console.error(`Event name: ${context.eventName}`);
+      console.error(`Entity number: ${context.entityNumber}`);
+      console.error(`Repository: ${context.repository.full_name}`);
+
+      // Try to get the PR info to understand the comment structure
+      try {
+        const { data: pr } = await octokit.rest.pulls.get({
+          owner,
+          repo,
+          pull_number: context.entityNumber,
+        });
+        console.log(`PR state: ${pr.state}`);
+        console.log(`PR comments count: ${pr.comments}`);
+        console.log(`PR review comments count: ${pr.review_comments}`);
+      } catch {
+        console.error("Could not fetch PR info for debugging");
+      }
+
+      throw finalError;
+    }
+
+    const currentBody = comment.body ?? "";
+
+    // Check if we need to add branch link for new branches
+    const useCommitSigning = process.env.USE_COMMIT_SIGNING === "true";
+    const { shouldDeleteBranch, branchLink } =
+      await checkAndCommitOrDeleteBranch(
+        octokit,
+        owner,
+        repo,
+        claudeBranch,
+        baseBranch,
+        useCommitSigning,
+      );
+
+    // Check if we need to add PR URL when we have a new branch
+    let prLink = "";
+    // If claudeBranch is set, it means we created a new branch (for issues or closed/merged PRs)
+    if (claudeBranch && !shouldDeleteBranch) {
+      // Check if comment already contains a PR URL
+      const serverUrlPattern = serverUrl.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+      const prUrlPattern = new RegExp(
+        `${serverUrlPattern}\\/.+\\/compare\\/${baseBranch.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\\.\\.\\.`,
+      );
+      const containsPRUrl = currentBody.match(prUrlPattern);
+
+      if (!containsPRUrl) {
+        // Check if there are changes to the branch compared to the default branch
+        try {
+          const { data: comparison } =
+            await octokit.rest.repos.compareCommitsWithBasehead({
+              owner,
+              repo,
+              basehead: `${baseBranch}...${claudeBranch}`,
+            });
+
+          // If there are changes (commits or file changes), add the PR URL
+          if (
+            comparison.total_commits > 0 ||
+            (comparison.files && comparison.files.length > 0)
+          ) {
+            const entityType = context.isPR ? "PR" : "Issue";
+            const prTitle = encodeURIComponent(
+              `${entityType} #${context.entityNumber}: Changes from Claude`,
+            );
+            const prBody = encodeURIComponent(
+              `This PR addresses ${entityType.toLowerCase()} #${context.entityNumber}\n\nGenerated with [Claude Code](https://claude.ai/code)`,
+            );
+            const prUrl = `${serverUrl}/${owner}/${repo}/compare/${baseBranch}...${claudeBranch}?quick_pull=1&title=${prTitle}&body=${prBody}`;
+            prLink = `\n[Create a PR](${prUrl})`;
+          }
+        } catch (error) {
+          console.error("Error checking for changes in branch:", error);
+          // Don't fail the entire update if we can't check for changes
+        }
+      }
+    }
+
+    // Check if action failed and read output file for execution details
+    let executionDetails: {
+      total_cost_usd?: number;
+      duration_ms?: number;
+      duration_api_ms?: number;
+    } | null = null;
+    let actionFailed = false;
+    let errorDetails: string | undefined;
+
+    // First check if prepare step failed
+    const prepareSuccess = process.env.PREPARE_SUCCESS !== "false";
+    const prepareError = process.env.PREPARE_ERROR;
+
+    if (!prepareSuccess && prepareError) {
+      actionFailed = true;
+      errorDetails = prepareError;
+    } else {
+      // Check for existence of output file and parse it if available
+      try {
+        const outputFile = process.env.OUTPUT_FILE;
+        if (outputFile) {
+          const fileContent = await fs.readFile(outputFile, "utf8");
+          const outputData = JSON.parse(fileContent);
+
+          // Output file is an array, get the last element which contains execution details
+          if (Array.isArray(outputData) && outputData.length > 0) {
+            const lastElement = outputData[outputData.length - 1];
+            if (
+              lastElement.type === "result" &&
+              "total_cost_usd" in lastElement &&
+              "duration_ms" in lastElement
+            ) {
+              executionDetails = {
+                total_cost_usd: lastElement.total_cost_usd,
+                duration_ms: lastElement.duration_ms,
+                duration_api_ms: lastElement.duration_api_ms,
+              };
+            }
+          }
+        }
+
+        // Check if the Claude action failed
+        const claudeSuccess = process.env.CLAUDE_SUCCESS !== "false";
+        actionFailed = !claudeSuccess;
+      } catch (error) {
+        console.error("Error reading output file:", error);
+        // If we can't read the file, check for any failure markers
+        actionFailed = process.env.CLAUDE_SUCCESS === "false";
+      }
+    }
+
+    // Prepare input for updateCommentBody function
+    const commentInput: CommentUpdateInput = {
+      currentBody,
+      actionFailed,
+      executionDetails,
+      jobUrl,
+      branchLink,
+      prLink,
+      branchName: shouldDeleteBranch || !branchLink ? undefined : claudeBranch,
+      triggerUsername,
+      errorDetails,
+    };
+
+    const updatedBody = updateCommentBody(commentInput);
+
+    try {
+      await updateClaudeComment(octokit.rest, {
+        owner,
+        repo,
+        commentId,
+        body: updatedBody,
+        isPullRequestReviewComment: isPRReviewComment,
+      });
+      console.log(
+        `✅ Updated ${isPRReviewComment ? "PR review" : "issue"} comment ${commentId} with job link`,
+      );
+    } catch (updateError) {
+      console.error(
+        `Failed to update ${isPRReviewComment ? "PR review" : "issue"} comment:`,
+        updateError,
+      );
+      throw updateError;
+    }

    process.exit(0);
  } catch (error) {
@ -272,6 +242,4 @@ async function run() {
  }
 }

-if (import.meta.main) {
-  run();
-}
+run();
--- a/src/github/api/queries/github.ts
+++ b/src/github/api/queries/github.ts
@ -12,24 +12,12 @@ export const PR_QUERY = `
        baseRefName
        headRefName
        headRefOid
-        isCrossRepository
-        headRepository {
-          owner {
-            login
-          }
-          name
-        }
        createdAt
        updatedAt
        lastEditedAt
        additions
        deletions
        state
-        labels(first: 1) {
-          nodes {
-            name
-          }
-        }
        commits(first: 100) {
          totalCount
          nodes {
@ -113,11 +101,6 @@ export const ISSUE_QUERY = `
        updatedAt
        lastEditedAt
        state
-        labels(first: 1) {
-          nodes {
-            name
-          }
-        }
        comments(first: 100) {
          nodes {
            id
--- a/src/github/context.ts
+++ b/src/github/context.ts
@ -79,7 +79,6 @@ type BaseContext = {
    owner: string;
    repo: string;
    full_name: string;
-    default_branch?: string;
  };
  actor: string;
  inputs: {
@ -89,19 +88,13 @@ type BaseContext = {
    labelTrigger: string;
    baseBranch?: string;
    branchPrefix: string;
-    branchNameTemplate?: string;
    useStickyComment: boolean;
-    classifyInlineComments: boolean;
    useCommitSigning: boolean;
-    sshSigningKey: string;
    botId: string;
    botName: string;
    allowedBots: string;
    allowedNonWriteUsers: string;
    trackProgress: boolean;
-    includeFixLinks: boolean;
-    includeCommentsByActor: string;
-    excludeCommentsByActor: string;
  };
 };

@ -141,7 +134,6 @@ export function parseGitHubContext(): GitHubContext {
      owner: context.repo.owner,
      repo: context.repo.repo,
      full_name: `${context.repo.owner}/${context.repo.repo}`,
-      default_branch: context.payload.repository?.default_branch,
    },
    actor: context.actor,
    inputs: {
@ -151,19 +143,13 @@ export function parseGitHubContext(): GitHubContext {
      labelTrigger: process.env.LABEL_TRIGGER ?? "",
      baseBranch: process.env.BASE_BRANCH,
      branchPrefix: process.env.BRANCH_PREFIX ?? "claude/",
-      branchNameTemplate: process.env.BRANCH_NAME_TEMPLATE,
      useStickyComment: process.env.USE_STICKY_COMMENT === "true",
-      classifyInlineComments: process.env.CLASSIFY_INLINE_COMMENTS !== "false",
      useCommitSigning: process.env.USE_COMMIT_SIGNING === "true",
-      sshSigningKey: process.env.SSH_SIGNING_KEY || "",
      botId: process.env.BOT_ID ?? String(CLAUDE_APP_BOT_ID),
      botName: process.env.BOT_NAME ?? CLAUDE_BOT_LOGIN,
      allowedBots: process.env.ALLOWED_BOTS ?? "",
      allowedNonWriteUsers: process.env.ALLOWED_NON_WRITE_USERS ?? "",
      trackProgress: process.env.TRACK_PROGRESS === "true",
-      includeFixLinks: process.env.INCLUDE_FIX_LINKS === "true",
-      includeCommentsByActor: process.env.INCLUDE_COMMENTS_BY_ACTOR ?? "",
-      excludeCommentsByActor: process.env.EXCLUDE_COMMENTS_BY_ACTOR ?? "",
    },
  };

--- a/src/github/data/fetcher.ts
+++ b/src/github/data/fetcher.ts
@ -3,8 +3,6 @@ import type { Octokits } from "../api/client";
 import { ISSUE_QUERY, PR_QUERY, USER_QUERY } from "../api/queries/github";
 import {
  isIssueCommentEvent,
-  isIssuesEvent,
-  isPullRequestEvent,
  isPullRequestReviewEvent,
  isPullRequestReviewCommentEvent,
  type ParsedGitHubContext,
@ -20,10 +18,6 @@ import type {
 } from "../types";
 import type { CommentWithImages } from "../utils/image-downloader";
 import { downloadCommentImages } from "../utils/image-downloader";
-import {
-  parseActorFilter,
-  shouldIncludeCommentByActor,
-} from "../utils/actor-filter";

 /**
 * Extracts the trigger timestamp from the GitHub webhook payload.
@ -46,58 +40,6 @@ export function extractTriggerTimestamp(
  return undefined;
 }

-/**
- * Extracts the original title from the GitHub webhook payload.
- * This is the title as it existed when the trigger event occurred.
- *
- * @param context - Parsed GitHub context from webhook
- * @returns The original title string or undefined if not available
- */
-export function extractOriginalTitle(
-  context: ParsedGitHubContext,
-): string | undefined {
-  if (isIssueCommentEvent(context)) {
-    return context.payload.issue?.title;
-  } else if (isPullRequestEvent(context)) {
-    return context.payload.pull_request?.title;
-  } else if (isPullRequestReviewEvent(context)) {
-    return context.payload.pull_request?.title;
-  } else if (isPullRequestReviewCommentEvent(context)) {
-    return context.payload.pull_request?.title;
-  } else if (isIssuesEvent(context)) {
-    return context.payload.issue?.title;
-  }
-
-  return undefined;
-}
-
-/**
- * Extracts the original body from the GitHub webhook payload.
- * This is the body as it existed when the trigger event occurred,
- * preventing TOCTOU attacks where an attacker edits the body after
- * the trigger but before the action reads it.
- *
- * @param context - Parsed GitHub context from webhook
- * @returns The original body string, null (no body), or undefined (not available)
- */
-export function extractOriginalBody(
-  context: ParsedGitHubContext,
-): string | null | undefined {
-  if (isIssueCommentEvent(context)) {
-    return context.payload.issue?.body;
-  } else if (isPullRequestEvent(context)) {
-    return context.payload.pull_request?.body;
-  } else if (isPullRequestReviewEvent(context)) {
-    return context.payload.pull_request?.body;
-  } else if (isPullRequestReviewCommentEvent(context)) {
-    return context.payload.pull_request?.body;
-  } else if (isIssuesEvent(context)) {
-    return context.payload.issue?.body;
-  }
-
-  return undefined;
-}
-
 /**
 * Filters comments to only include those that existed in their final state before the trigger time.
 * This prevents malicious actors from editing comments after the trigger to inject harmful content.
@ -197,35 +139,6 @@ export function isBodySafeToUse(
  return true;
 }

-/**
- * Filters comments by actor username based on include/exclude patterns
- * @param comments - Array of comments to filter
- * @param includeActors - Comma-separated actors to include
- * @param excludeActors - Comma-separated actors to exclude
- * @returns Filtered array of comments
- */
-export function filterCommentsByActor<T extends { author: { login: string } }>(
-  comments: T[],
-  includeActors: string = "",
-  excludeActors: string = "",
-): T[] {
-  const includeParsed = parseActorFilter(includeActors);
-  const excludeParsed = parseActorFilter(excludeActors);
-
-  // No filters = return all
-  if (includeParsed.length === 0 && excludeParsed.length === 0) {
-    return comments;
-  }
-
-  return comments.filter((comment) =>
-    shouldIncludeCommentByActor(
-      comment.author.login,
-      includeParsed,
-      excludeParsed,
-    ),
-  );
-}
-
 type FetchDataParams = {
  octokits: Octokits;
  repository: string;
@ -233,10 +146,6 @@ type FetchDataParams = {
  isPR: boolean;
  triggerUsername?: string;
  triggerTime?: string;
-  originalTitle?: string;
-  originalBody?: string | null;
-  includeCommentsByActor?: string;
-  excludeCommentsByActor?: string;
 };

 export type GitHubFileWithSHA = GitHubFile & {
@ -260,10 +169,6 @@ export async function fetchGitHubData({
  isPR,
  triggerUsername,
  triggerTime,
-  originalTitle,
-  originalBody,
-  includeCommentsByActor,
-  excludeCommentsByActor,
 }: FetchDataParams): Promise<FetchDataResult> {
  const [owner, repo] = repository.split("/");
  if (!owner || !repo) {
@ -291,15 +196,11 @@ export async function fetchGitHubData({
        const pullRequest = prResult.repository.pullRequest;
        contextData = pullRequest;
        changedFiles = pullRequest.files.nodes || [];
-        comments = filterCommentsByActor(
-          filterCommentsToTriggerTime(
-            pullRequest.comments?.nodes || [],
-            triggerTime,
-          ),
-          includeCommentsByActor,
-          excludeCommentsByActor,
+        comments = filterCommentsToTriggerTime(
+          pullRequest.comments?.nodes || [],
+          triggerTime,
        );
-        reviewData = pullRequest.reviews || { nodes: [] };
+        reviewData = pullRequest.reviews || [];

        console.log(`Successfully fetched PR #${prNumber} data`);
      } else {
@ -318,13 +219,9 @@ export async function fetchGitHubData({

      if (issueResult.repository.issue) {
        contextData = issueResult.repository.issue;
-        comments = filterCommentsByActor(
-          filterCommentsToTriggerTime(
-            contextData?.comments?.nodes || [],
-            triggerTime,
-          ),
-          includeCommentsByActor,
-          excludeCommentsByActor,
+        comments = filterCommentsToTriggerTime(
+          contextData?.comments?.nodes || [],
+          triggerTime,
        );

        console.log(`Successfully fetched issue #${prNumber} data`);
@ -392,27 +289,7 @@ export async function fetchGitHubData({
    body: r.body,
  }));

-  // Filter review comments to trigger time and by actor
-  if (reviewData && reviewData.nodes) {
-    // Filter reviews by actor
-    reviewData.nodes = filterCommentsByActor(
-      reviewData.nodes,
-      includeCommentsByActor,
-      excludeCommentsByActor,
-    );
-
-    // Also filter inline review comments within each review
-    reviewData.nodes.forEach((review) => {
-      if (review.comments?.nodes) {
-        review.comments.nodes = filterCommentsByActor(
-          review.comments.nodes,
-          includeCommentsByActor,
-          excludeCommentsByActor,
-        );
-      }
-    });
-  }
-
+  // Filter review comments to trigger time
  const allReviewComments =
    reviewData?.nodes?.flatMap((r) => r.comments?.nodes ?? []) ?? [];
  const filteredReviewComments = filterCommentsToTriggerTime(
@ -428,21 +305,12 @@ export async function fetchGitHubData({
      body: c.body,
    }));

-  // Use the original body from the webhook payload if provided (TOCTOU protection).
-  // The webhook payload captures the body at event time, before any attacker edits.
-  if (originalBody !== undefined) {
-    contextData.body = originalBody ?? "";
-  }
-
-  // Add the main issue/PR body if it has content and wasn't edited after trigger.
-  // When originalBody is provided, the body is already safe (from webhook payload).
-  // Otherwise, fall back to timestamp-based validation.
+  // Add the main issue/PR body if it has content and wasn't edited after trigger
+  // This prevents a TOCTOU race condition where an attacker could edit the body
+  // between when an authorized user triggered Claude and when Claude processes the request
  let mainBody: CommentWithImages[] = [];
  if (contextData.body) {
-    if (
-      originalBody !== undefined ||
-      isBodySafeToUse(contextData, triggerTime)
-    ) {
+    if (isBodySafeToUse(contextData, triggerTime)) {
      mainBody = [
        {
          ...(isPR
@ -486,11 +354,6 @@ export async function fetchGitHubData({
    triggerDisplayName = await fetchUserDisplayName(octokits, triggerUsername);
  }

-  // Use the original title from the webhook payload if provided
-  if (originalTitle !== undefined) {
-    contextData.title = originalTitle;
-  }
-
  return {
    contextData,
    comments,
--- a/src/github/data/formatter.ts
+++ b/src/github/data/formatter.ts
@ -14,8 +14,7 @@ export function formatContext(
 ): string {
  if (isPR) {
    const prData = contextData as GitHubPullRequest;
-    const sanitizedTitle = sanitizeContent(prData.title);
-    return `PR Title: ${sanitizedTitle}
+    return `PR Title: ${prData.title}
 PR Author: ${prData.author.login}
 PR Branch: ${prData.headRefName} -> ${prData.baseRefName}
 PR State: ${prData.state}
@ -25,8 +24,7 @@ Total Commits: ${prData.commits.totalCount}
 Changed Files: ${prData.files.nodes.length} files`;
  } else {
    const issueData = contextData as GitHubIssue;
-    const sanitizedTitle = sanitizeContent(issueData.title);
-    return `Issue Title: ${sanitizedTitle}
+    return `Issue Title: ${issueData.title}
 Issue Author: ${issueData.author.login}
 Issue State: ${issueData.state}`;
  }
--- a/src/github/operations/branch.ts
+++ b/src/github/operations/branch.ts
@ -6,21 +6,12 @@
 * - For Issues: Create a new branch
 */

-import { $ } from "bun";
 import { execFileSync } from "child_process";
+import * as core from "@actions/core";
 import type { ParsedGitHubContext } from "../context";
 import type { GitHubPullRequest } from "../types";
 import type { Octokits } from "../api/client";
 import type { FetchDataResult } from "../data/fetcher";
-import { generateBranchName } from "../../utils/branch-template";
-
-/**
- * Extracts the first label from GitHub data, or returns undefined if no labels exist
- */
-function extractFirstLabel(githubData: FetchDataResult): string | undefined {
-  const labels = githubData.contextData.labels?.nodes;
-  return labels && labels.length > 0 ? labels[0]?.name : undefined;
-}

 /**
 * Validates a git branch name against a strict whitelist pattern.
@ -28,7 +19,7 @@ function extractFirstLabel(githubData: FetchDataResult): string | undefined {
 *
 * Valid branch names:
 * - Start with alphanumeric character (not dash, to prevent option injection)
- * - Contain only alphanumeric, forward slash, hyphen, underscore, period, or hash (#)
+ * - Contain only alphanumeric, forward slash, hyphen, underscore, or period
 * - Do not start or end with a period
 * - Do not end with a slash
 * - Do not contain '..' (path traversal)
@ -58,16 +49,12 @@ export function validateBranchName(branchName: string): void {
    );
  }

-  // Strict whitelist pattern: alphanumeric start, then alphanumeric/slash/hyphen/underscore/period/hash/plus.
-  // # is valid per git-check-ref-format and commonly used in branch names like "fix/#123-description".
-  // + is valid per git-check-ref-format and generated by Claude Code's EnterWorktree tool when
-  //   converting worktree names containing "/" (e.g. "feat/foo" becomes "worktree-feat+foo").
-  // All git calls use execFileSync (not shell interpolation), so neither # nor + carries injection risk.
-  const validPattern = /^[a-zA-Z0-9][a-zA-Z0-9/_.#+-]*$/;
+  // Strict whitelist pattern: alphanumeric start, then alphanumeric/slash/hyphen/underscore/period
+  const validPattern = /^[a-zA-Z0-9][a-zA-Z0-9/_.-]*$/;

  if (!validPattern.test(branchName)) {
    throw new Error(
-      `Invalid branch name: "${branchName}". Branch names must start with an alphanumeric character and contain only alphanumeric characters, forward slashes, hyphens, underscores, periods, hashes (#), or plus signs (+).`,
+      `Invalid branch name: "${branchName}". Branch names must start with an alphanumeric character and contain only alphanumeric characters, forward slashes, hyphens, underscores, or periods.`,
    );
  }

@ -122,7 +109,7 @@ export function validateBranchName(branchName: string): void {
 * @param args - Git command arguments (e.g., ["checkout", "branch-name"])
 */
 function execGit(args: string[]): void {
-  execFileSync("git", args, { stdio: "inherit", env: process.env });
+  execFileSync("git", args, { stdio: "inherit" });
 }

 export type BranchInfo = {
@ -138,7 +125,7 @@ export async function setupBranch(
 ): Promise<BranchInfo> {
  const { owner, repo } = context.repository;
  const entityNumber = context.entityNumber;
-  const { baseBranch, branchPrefix, branchNameTemplate } = context.inputs;
+  const { baseBranch, branchPrefix } = context.inputs;
  const isPR = context.isPR;

  if (isPR) {
@ -168,23 +155,9 @@ export async function setupBranch(
      // Validate branch names before use to prevent command injection
      validateBranchName(branchName);

-      // For cross-repository (fork) PRs, fetch via the pull ref since the
-      // branch only exists on the fork's remote, not on origin.
-      if (prData.isCrossRepository) {
-        console.log(
-          `PR #${entityNumber} is from a fork, fetching via refs/pull/${entityNumber}/head...`,
-        );
-        execGit([
-          "fetch",
-          "origin",
-          `--depth=${fetchDepth}`,
-          `pull/${entityNumber}/head:${branchName}`,
-        ]);
-      } else {
-        // Execute git commands to checkout PR branch (dynamic depth based on PR size)
-        // Using execFileSync instead of shell template literals for security
-        execGit(["fetch", "origin", `--depth=${fetchDepth}`, branchName]);
-      }
+      // Execute git commands to checkout PR branch (dynamic depth based on PR size)
+      // Using execFileSync instead of shell template literals for security
+      execGit(["fetch", "origin", `--depth=${fetchDepth}`, branchName]);
      execGit(["checkout", branchName, "--"]);

      console.log(`Successfully checked out PR branch for PR #${entityNumber}`);
@ -218,8 +191,17 @@ export async function setupBranch(
  // Generate branch name for either an issue or closed/merged PR
  const entityType = isPR ? "pr" : "issue";

-  // Get the SHA of the source branch to use in template
-  let sourceSHA: string | undefined;
+  // Create Kubernetes-compatible timestamp: lowercase, hyphens only, shorter format
+  const now = new Date();
+  const timestamp = `${now.getFullYear()}${String(now.getMonth() + 1).padStart(2, "0")}${String(now.getDate()).padStart(2, "0")}-${String(now.getHours()).padStart(2, "0")}${String(now.getMinutes()).padStart(2, "0")}`;
+
+  // Ensure branch name is Kubernetes-compatible:
+  // - Lowercase only
+  // - Alphanumeric with hyphens
+  // - No underscores
+  // - Max 50 chars (to allow for prefixes)
+  const branchName = `${branchPrefix}${entityType}-${entityNumber}-${timestamp}`;
+  const newBranch = branchName.toLowerCase().substring(0, 50);

  try {
    // Get the SHA of the source branch to verify it exists
@ -229,46 +211,8 @@ export async function setupBranch(
      ref: `heads/${sourceBranch}`,
    });

-    sourceSHA = sourceBranchRef.data.object.sha;
-    console.log(`Source branch SHA: ${sourceSHA}`);
-
-    // Extract first label from GitHub data
-    const firstLabel = extractFirstLabel(githubData);
-
-    // Extract title from GitHub data
-    const title = githubData.contextData.title;
-
-    // Generate branch name using template or default format
-    let newBranch = generateBranchName(
-      branchNameTemplate,
-      branchPrefix,
-      entityType,
-      entityNumber,
-      sourceSHA,
-      firstLabel,
-      title,
-    );
-
-    // Check if generated branch already exists on remote
-    try {
-      await $`git ls-remote --exit-code origin refs/heads/${newBranch}`.quiet();
-
-      // If we get here, branch exists (exit code 0)
-      console.log(
-        `Branch '${newBranch}' already exists, falling back to default format`,
-      );
-      newBranch = generateBranchName(
-        undefined, // Force default template
-        branchPrefix,
-        entityType,
-        entityNumber,
-        sourceSHA,
-        firstLabel,
-        title,
-      );
-    } catch {
-      // Branch doesn't exist (non-zero exit code), continue with generated name
-    }
+    const currentSHA = sourceBranchRef.data.object.sha;
+    console.log(`Source branch SHA: ${currentSHA}`);

    // For commit signing, defer branch creation to the file ops server
    if (context.inputs.useCommitSigning) {
@ -282,6 +226,9 @@ export async function setupBranch(
      execGit(["fetch", "origin", sourceBranch, "--depth=1"]);
      execGit(["checkout", sourceBranch, "--"]);

+      // Set outputs for GitHub Actions
+      core.setOutput("CLAUDE_BRANCH", newBranch);
+      core.setOutput("BASE_BRANCH", sourceBranch);
      return {
        baseBranch: sourceBranch,
        claudeBranch: newBranch,
@ -308,6 +255,9 @@ export async function setupBranch(
      `Successfully created and checked out local branch: ${newBranch}`,
    );

+    // Set outputs for GitHub Actions
+    core.setOutput("CLAUDE_BRANCH", newBranch);
+    core.setOutput("BASE_BRANCH", sourceBranch);
    return {
      baseBranch: sourceBranch,
      claudeBranch: newBranch,
--- a/src/github/operations/git-config.ts
+++ b/src/github/operations/git-config.ts
@ -6,14 +6,9 @@
 */

 import { $ } from "bun";
-import { mkdir, writeFile, rm } from "fs/promises";
-import { join } from "path";
-import { homedir } from "os";
 import type { GitHubContext } from "../context";
 import { GITHUB_SERVER_URL } from "../api/config";

-const SSH_SIGNING_KEY_PATH = join(homedir(), ".ssh", "claude_signing_key");
-
 type GitUser = {
  login: string;
  id: number;
@ -51,86 +46,11 @@ export async function configureGitAuth(
    console.log("No existing authentication headers to remove");
  }

-  if (process.env.ALLOWED_NON_WRITE_USERS) {
-    // When processing content from non-write users, use a credential helper
-    // instead of embedding the token in the remote URL. The helper script reads
-    // from GH_TOKEN at auth time, so .git/config stays token-free. Written as a
-    // file to avoid shell-escaping the helper body; placed under
-    // GITHUB_ACTION_PATH so it sits alongside the action source.
-    console.log("Configuring git credential helper...");
-    process.env.GH_TOKEN = githubToken;
-    const helperPath = join(
-      process.env.GITHUB_ACTION_PATH || homedir(),
-      ".git-credential-gh-token",
-    );
-    await writeFile(
-      helperPath,
-      '#!/bin/sh\necho username=x-access-token\necho password="$GH_TOKEN"\n',
-      { mode: 0o700 },
-    );
-    const cleanUrl = `https://${serverUrl.host}/${context.repository.owner}/${context.repository.repo}.git`;
-    await $`git remote set-url origin ${cleanUrl}`;
-    await $`git config credential.helper ${helperPath}`;
-    console.log("✓ Configured credential helper");
-  } else {
-    // Update the remote URL to include the token for authentication
-    console.log("Updating remote URL with authentication...");
-    const remoteUrl = `https://x-access-token:${githubToken}@${serverUrl.host}/${context.repository.owner}/${context.repository.repo}.git`;
-    await $`git remote set-url origin ${remoteUrl}`;
-    console.log("✓ Updated remote URL with authentication token");
-  }
+  // Update the remote URL to include the token for authentication
+  console.log("Updating remote URL with authentication...");
+  const remoteUrl = `https://x-access-token:${githubToken}@${serverUrl.host}/${context.repository.owner}/${context.repository.repo}.git`;
+  await $`git remote set-url origin ${remoteUrl}`;
+  console.log("✓ Updated remote URL with authentication token");

  console.log("Git authentication configured successfully");
 }
-
-/**
- * Configure git to use SSH signing for commits
- * This is an alternative to GitHub API-based commit signing (use_commit_signing)
- */
-export async function setupSshSigning(sshSigningKey: string): Promise<void> {
-  console.log("Configuring SSH signing for commits...");
-
-  // Validate SSH key format
-  if (!sshSigningKey.trim()) {
-    throw new Error("SSH signing key cannot be empty");
-  }
-  if (
-    !sshSigningKey.includes("BEGIN") ||
-    !sshSigningKey.includes("PRIVATE KEY")
-  ) {
-    throw new Error("Invalid SSH private key format");
-  }
-
-  // Create .ssh directory with secure permissions (700)
-  const sshDir = join(homedir(), ".ssh");
-  await mkdir(sshDir, { recursive: true, mode: 0o700 });
-
-  // Ensure key ends with newline (required for ssh-keygen to parse it)
-  const normalizedKey = sshSigningKey.endsWith("\n")
-    ? sshSigningKey
-    : sshSigningKey + "\n";
-
-  // Write the signing key atomically with secure permissions (600)
-  await writeFile(SSH_SIGNING_KEY_PATH, normalizedKey, { mode: 0o600 });
-  console.log(`✓ SSH signing key written to ${SSH_SIGNING_KEY_PATH}`);
-
-  // Configure git to use SSH signing
-  await $`git config gpg.format ssh`;
-  await $`git config user.signingkey ${SSH_SIGNING_KEY_PATH}`;
-  await $`git config commit.gpgsign true`;
-
-  console.log("✓ Git configured to use SSH signing for commits");
-}
-
-/**
- * Clean up the SSH signing key file
- * Should be called in the post step for security
- */
-export async function cleanupSshSigning(): Promise<void> {
-  try {
-    await rm(SSH_SIGNING_KEY_PATH, { force: true });
-    console.log("✓ SSH signing key cleaned up");
-  } catch (error) {
-    console.log("No SSH signing key to clean up");
-  }
-}
--- a/src/github/operations/restore-config.ts
+++ b/src/github/operations/restore-config.ts
@ -1,109 +0,0 @@
-import { execFileSync } from "child_process";
-import { cpSync, existsSync, rmSync } from "fs";
-
-// Paths that are both PR-controllable and read from cwd at CLI startup.
-//
-// Deliberately excluded from the CLI's broader auto-edit blocklist:
-//   .git/        — not tracked by git; PR commits cannot place files there.
-//                  Restoring it would also undo the PR checkout entirely.
-//   .gitconfig   — git reads ~/.gitconfig and .git/config, never cwd/.gitconfig.
-//   .bashrc etc. — shells source these from $HOME; checkout cannot reach $HOME.
-//   .vscode/.idea— IDE config; nothing in the CLI's startup path reads them.
-const SENSITIVE_PATHS = [
-  ".claude",
-  ".mcp.json",
-  ".claude.json",
-  ".gitmodules",
-  ".ripgreprc",
-  "CLAUDE.md",
-  "CLAUDE.local.md",
-  ".husky",
-];
-
-/**
- * Restores security-sensitive config paths from the PR base branch.
- *
- * The CLI's non-interactive mode trusts cwd: it reads `.mcp.json`,
- * `.claude/settings.json`, and `.claude/settings.local.json` from the working
- * directory and acts on them before any tool-permission gating — executing
- * hooks (including SessionStart), setting env vars (NODE_OPTIONS, LD_PRELOAD,
- * PATH), running apiKeyHelper/awsAuthRefresh shell commands, and auto-approving
- * MCP servers. When this action checks out a PR head, all of these are
- * attacker-controlled.
- *
- * Rather than enumerate every dangerous key, this replaces the entire `.claude/`
- * tree and `.mcp.json` with the versions from the PR base branch, which a
- * maintainer has reviewed and merged. Paths absent on base are deleted.
- *
- * Known limitation: if a PR legitimately modifies `.claude/` and the CLI later
- * commits with `git add -A`, the revert will be included in that commit. This
- * is a narrow UX tradeoff for closing the RCE surface.
- *
- * @param baseBranch - PR base branch name. Must be pre-validated (branch.ts
- *   calls validateBranchName on it before returning).
- */
-export function restoreConfigFromBase(baseBranch: string): void {
-  console.log(
-    `Restoring ${SENSITIVE_PATHS.join(", ")} from origin/${baseBranch} (PR head is untrusted)`,
-  );
-
-  // Snapshot every PR-authored sensitive path into .claude-pr/ before deletion
-  // so review agents can inspect what the PR changes without those files ever
-  // being executed. Captured before the security delete so it reflects the
-  // PR-authored version.
-  rmSync(".claude-pr", { recursive: true, force: true });
-  for (const p of SENSITIVE_PATHS) {
-    if (existsSync(p)) {
-      cpSync(p, `.claude-pr/${p}`, { recursive: true });
-    }
-  }
-  if (existsSync(".claude-pr")) {
-    console.log(
-      "Preserved PR's sensitive paths → .claude-pr/ for review agents (not executed)",
-    );
-  }
-
-  // Delete PR-controlled versions BEFORE fetching so the attacker-controlled
-  // .gitmodules is absent during the network operation. If git reads .gitmodules
-  // during fetch (fetch.recurseSubmodules=on-demand, the git default), it will
-  // attempt to fetch submodule objects and block on credential prompts in CI —
-  // causing an indefinite hang. Deleting first closes that window.
-  //
-  // If the restore below fails for a given path, that path stays deleted —
-  // the safe fallback (no attacker-controlled config). A bare `git checkout`
-  // alone wouldn't remove files the PR added, so nuke first.
-  for (const p of SENSITIVE_PATHS) {
-    rmSync(p, { recursive: true, force: true });
-  }
-
-  // --no-recurse-submodules: explicitly suppress submodule fetching regardless of
-  // fetch.recurseSubmodules config. Defense-in-depth alongside the delete above.
-  execFileSync(
-    "git",
-    ["fetch", "origin", baseBranch, "--depth=1", "--no-recurse-submodules"],
-    {
-      stdio: "inherit",
-      env: process.env,
-    },
-  );
-
-  for (const p of SENSITIVE_PATHS) {
-    try {
-      execFileSync("git", ["checkout", `origin/${baseBranch}`, "--", p], {
-        stdio: "pipe",
-      });
-    } catch {
-      // Path doesn't exist on base — it stays deleted.
-    }
-  }
-
-  // `git checkout <ref> -- <path>` stages the restored files. Unstage so the
-  // revert doesn't silently leak into commits the CLI makes later.
-  try {
-    execFileSync("git", ["reset", "--", ...SENSITIVE_PATHS], {
-      stdio: "pipe",
-    });
-  } catch {
-    // Nothing was staged, or paths don't exist on HEAD — either is fine.
-  }
-}
--- a/src/github/token.ts
+++ b/src/github/token.ts
@ -3,13 +3,6 @@
 import * as core from "@actions/core";
 import { retryWithBackoff } from "../utils/retry";

-export class WorkflowValidationSkipError extends Error {
-  constructor(message: string) {
-    super(message);
-    this.name = "WorkflowValidationSkipError";
-  }
-}
-
 async function getOidcToken(): Promise<string> {
  try {
    const oidcToken = await core.getIDToken("claude-code-github-action");
@ -23,60 +16,15 @@ async function getOidcToken(): Promise<string> {
  }
 }

-const DEFAULT_PERMISSIONS: Record<string, string> = {
-  contents: "write",
-  pull_requests: "write",
-  issues: "write",
-};
-
-export function parseAdditionalPermissions():
-  | Record<string, string>
-  | undefined {
-  const raw = process.env.ADDITIONAL_PERMISSIONS;
-  if (!raw || !raw.trim()) {
-    return undefined;
-  }
-
-  const additional: Record<string, string> = {};
-  for (const line of raw.split("\n")) {
-    const trimmed = line.trim();
-    if (!trimmed) continue;
-    const colonIndex = trimmed.indexOf(":");
-    if (colonIndex === -1) continue;
-    const key = trimmed.slice(0, colonIndex).trim();
-    const value = trimmed.slice(colonIndex + 1).trim();
-    if (key && value) {
-      additional[key] = value;
-    }
-  }
-
-  if (Object.keys(additional).length === 0) {
-    return undefined;
-  }
-
-  return { ...DEFAULT_PERMISSIONS, ...additional };
-}
-
-async function exchangeForAppToken(
-  oidcToken: string,
-  permissions?: Record<string, string>,
-): Promise<string> {
-  const headers: Record<string, string> = {
-    Authorization: `Bearer ${oidcToken}`,
-  };
-  const fetchOptions: RequestInit = {
-    method: "POST",
-    headers,
-  };
-
-  if (permissions) {
-    headers["Content-Type"] = "application/json";
-    fetchOptions.body = JSON.stringify({ permissions });
-  }
-
+async function exchangeForAppToken(oidcToken: string): Promise<string> {
  const response = await fetch(
    "https://api.anthropic.com/api/github/github-app-token-exchange",
-    fetchOptions,
+    {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${oidcToken}`,
+      },
+    },
  );

  if (!response.ok) {
@ -103,7 +51,8 @@ async function exchangeForAppToken(
      console.log(
        "Action skipped due to workflow validation error. This is expected when adding Claude Code workflows to new repositories or on PRs with workflow changes. If you're seeing this, your workflow will begin working once you merge your PR.",
      );
-      throw new WorkflowValidationSkipError(message);
+      core.setOutput("skipped_due_to_workflow_validation_mismatch", "true");
+      process.exit(0);
    }

    console.error(
@ -126,30 +75,34 @@ async function exchangeForAppToken(
 }

 export async function setupGitHubToken(): Promise<string> {
-  // Check if GitHub token was provided as override
-  const providedToken = process.env.OVERRIDE_GITHUB_TOKEN;
+  try {
+    // Check if GitHub token was provided as override
+    const providedToken = process.env.OVERRIDE_GITHUB_TOKEN;

-  if (providedToken) {
-    console.log("Using provided GITHUB_TOKEN for authentication");
-    return providedToken;
+    if (providedToken) {
+      console.log("Using provided GITHUB_TOKEN for authentication");
+      core.setOutput("GITHUB_TOKEN", providedToken);
+      return providedToken;
+    }
+
+    console.log("Requesting OIDC token...");
+    const oidcToken = await retryWithBackoff(() => getOidcToken());
+    console.log("OIDC token successfully obtained");
+
+    console.log("Exchanging OIDC token for app token...");
+    const appToken = await retryWithBackoff(() =>
+      exchangeForAppToken(oidcToken),
+    );
+    console.log("App token successfully obtained");
+
+    console.log("Using GITHUB_TOKEN from OIDC");
+    core.setOutput("GITHUB_TOKEN", appToken);
+    return appToken;
+  } catch (error) {
+    // Only set failed if we get here - workflow validation errors will exit(0) before this
+    core.setFailed(
+      `Failed to setup GitHub token: ${error}\n\nIf you instead wish to use this action with a custom GitHub token or custom GitHub app, provide a \`github_token\` in the \`uses\` section of the app in your workflow yml file.`,
+    );
+    process.exit(1);
  }
-
-  console.log("Requesting OIDC token...");
-  const oidcToken = await retryWithBackoff(() => getOidcToken());
-  console.log("OIDC token successfully obtained");
-
-  const permissions = parseAdditionalPermissions();
-
-  console.log("Exchanging OIDC token for app token...");
-  const appToken = await retryWithBackoff(
-    () => exchangeForAppToken(oidcToken, permissions),
-    {
-      shouldRetry: (error) => !(error instanceof WorkflowValidationSkipError),
-    },
-  );
-  console.log("App token successfully obtained");
-  core.setSecret(appToken);
-
-  console.log("Using GITHUB_TOKEN from OIDC");
-  return appToken;
 }
--- a/src/github/types.ts
+++ b/src/github/types.ts
@ -57,24 +57,12 @@ export type GitHubPullRequest = {
  baseRefName: string;
  headRefName: string;
  headRefOid: string;
-  isCrossRepository: boolean;
-  headRepository: {
-    owner: {
-      login: string;
-    };
-    name: string;
-  } | null;
  createdAt: string;
  updatedAt?: string;
  lastEditedAt?: string;
  additions: number;
  deletions: number;
  state: string;
-  labels: {
-    nodes: Array<{
-      name: string;
-    }>;
-  };
  commits: {
    totalCount: number;
    nodes: Array<{
@ -100,11 +88,6 @@ export type GitHubIssue = {
  updatedAt?: string;
  lastEditedAt?: string;
  state: string;
-  labels: {
-    nodes: Array<{
-      name: string;
-    }>;
-  };
  comments: {
    nodes: GitHubComment[];
  };
--- a/src/github/utils/actor-filter.ts
+++ b/src/github/utils/actor-filter.ts
@ -1,65 +0,0 @@
-/**
- * Parses actor filter string into array of patterns
- * @param filterString - Comma-separated actor names (e.g., "user1,user2,*[bot]")
- * @returns Array of actor patterns
- */
-export function parseActorFilter(filterString: string): string[] {
-  if (!filterString.trim()) return [];
-  return filterString
-    .split(",")
-    .map((actor) => actor.trim())
-    .filter((actor) => actor.length > 0);
-}
-
-/**
- * Checks if an actor matches a pattern
- * Supports wildcards: "*[bot]" matches all bots, "dependabot[bot]" matches specific
- * @param actor - Actor username to check
- * @param pattern - Pattern to match against
- * @returns true if actor matches pattern
- */
-export function actorMatchesPattern(actor: string, pattern: string): boolean {
-  // Exact match
-  if (actor === pattern) return true;
-
-  // Wildcard bot pattern: "*[bot]" matches any username ending with [bot]
-  if (pattern === "*[bot]" && actor.endsWith("[bot]")) return true;
-
-  // No match
-  return false;
-}
-
-/**
- * Determines if a comment should be included based on actor filters
- * @param actor - Comment author username
- * @param includeActors - Array of actors to include (empty = include all)
- * @param excludeActors - Array of actors to exclude (empty = exclude none)
- * @returns true if comment should be included
- */
-export function shouldIncludeCommentByActor(
-  actor: string,
-  includeActors: string[],
-  excludeActors: string[],
-): boolean {
-  // Check exclusion first (exclusion takes priority)
-  if (excludeActors.length > 0) {
-    for (const pattern of excludeActors) {
-      if (actorMatchesPattern(actor, pattern)) {
-        return false; // Excluded
-      }
-    }
-  }
-
-  // Check inclusion
-  if (includeActors.length > 0) {
-    for (const pattern of includeActors) {
-      if (actorMatchesPattern(actor, pattern)) {
-        return true; // Explicitly included
-      }
-    }
-    return false; // Not in include list
-  }
-
-  // No filters or passed all checks
-  return true;
-}
--- a/src/github/validation/actor.ts
+++ b/src/github/validation/actor.ts
@ -6,11 +6,11 @@
 */

 import type { Octokit } from "@octokit/rest";
-import type { GitHubContext } from "../context";
+import type { ParsedGitHubContext } from "../context";

 export async function checkHumanActor(
  octokit: Octokit,
-  githubContext: GitHubContext,
+  githubContext: ParsedGitHubContext,
 ) {
  // Fetch user information from GitHub API
  const { data: userData } = await octokit.users.getByUsername({
--- a/src/mcp/github-file-ops-server.ts
+++ b/src/mcp/github-file-ops-server.ts
@ -4,12 +4,11 @@ import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { z } from "zod";
 import { readFile, stat } from "fs/promises";
-import { resolve } from "path";
+import { join } from "path";
 import { constants } from "fs";
 import fetch from "node-fetch";
 import { GITHUB_API_URL } from "../github/api/config";
 import { retryWithBackoff } from "../utils/retry";
-import { validatePathWithinRepo } from "./path-validation";

 type GitHubRef = {
  object: {
@ -214,18 +213,12 @@ server.tool(
        throw new Error("GITHUB_TOKEN environment variable is required");
      }

-      // Validate all paths are within repository root and get full/relative paths
-      const resolvedRepoDir = resolve(REPO_DIR);
-      const validatedFiles = await Promise.all(
-        files.map(async (filePath) => {
-          const fullPath = await validatePathWithinRepo(filePath, REPO_DIR);
-          // Calculate the relative path for the git tree entry
-          // Use the original filePath (normalized) for the git path, not the symlink-resolved path
-          const normalizedPath = resolve(resolvedRepoDir, filePath);
-          const relativePath = normalizedPath.slice(resolvedRepoDir.length + 1);
-          return { fullPath, relativePath };
-        }),
-      );
+      const processedFiles = files.map((filePath) => {
+        if (filePath.startsWith("/")) {
+          return filePath.slice(1);
+        }
+        return filePath;
+      });

      // 1. Get the branch reference (create if doesn't exist)
      const baseSha = await getOrCreateBranchRef(
@ -254,14 +247,18 @@ server.tool(

      // 3. Create tree entries for all files
      const treeEntries = await Promise.all(
-        validatedFiles.map(async ({ fullPath, relativePath }) => {
+        processedFiles.map(async (filePath) => {
+          const fullPath = filePath.startsWith("/")
+            ? filePath
+            : join(REPO_DIR, filePath);
+
          // Get the proper file mode based on file permissions
          const fileMode = await getFileMode(fullPath);

          // Check if file is binary (images, etc.)
          const isBinaryFile =
            /\.(png|jpg|jpeg|gif|webp|ico|pdf|zip|tar|gz|exe|bin|woff|woff2|ttf|eot)$/i.test(
-              relativePath,
+              filePath,
            );

          if (isBinaryFile) {
@ -287,7 +284,7 @@ server.tool(
            if (!blobResponse.ok) {
              const errorText = await blobResponse.text();
              throw new Error(
-                `Failed to create blob for ${relativePath}: ${blobResponse.status} - ${errorText}`,
+                `Failed to create blob for ${filePath}: ${blobResponse.status} - ${errorText}`,
              );
            }

@ -295,7 +292,7 @@ server.tool(

            // Return tree entry with blob SHA
            return {
-              path: relativePath,
+              path: filePath,
              mode: fileMode,
              type: "blob",
              sha: blobData.sha,
@ -304,7 +301,7 @@ server.tool(
            // For text files, include content directly in tree
            const content = await readFile(fullPath, "utf-8");
            return {
-              path: relativePath,
+              path: filePath,
              mode: fileMode,
              type: "blob",
              content: content,
@ -424,9 +421,7 @@ server.tool(
          author: newCommitData.author.name,
          date: newCommitData.author.date,
        },
-        files: validatedFiles.map(({ relativePath }) => ({
-          path: relativePath,
-        })),
+        files: processedFiles.map((path) => ({ path })),
        tree: {
          sha: treeData.sha,
        },
--- a/src/mcp/github-inline-comment-server.ts
+++ b/src/mcp/github-inline-comment-server.ts
@ -1,7 +1,6 @@
 #!/usr/bin/env node
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import { appendFileSync } from "fs";
 import { z } from "zod";
 import { createOctokit } from "../github/api/client";
 import { sanitizeContent } from "../github/utils/sanitizer";
@ -11,13 +10,6 @@ const REPO_OWNER = process.env.REPO_OWNER;
 const REPO_NAME = process.env.REPO_NAME;
 const PR_NUMBER = process.env.PR_NUMBER;

-// Calls without confirmed=true are buffered here instead of posted. This
-// prevents subagents from posting test/probe comments when they inherit this
-// tool and probe it after hitting unrelated errors. The action's post-step
-// reports the buffer count for diagnostics.
-const BUFFER_PATH = "/tmp/inline-comments-buffer.jsonl";
-const CLASSIFY_ENABLED = process.env.CLASSIFY_INLINE_COMMENTS !== "false";
-
 if (!REPO_OWNER || !REPO_NAME || !PR_NUMBER) {
  console.error(
    "Error: REPO_OWNER, REPO_NAME, and PR_NUMBER environment variables are required",
@ -75,17 +67,8 @@ server.tool(
      .describe(
        "Specific commit SHA to comment on (defaults to latest commit)",
      ),
-    confirmed: z
-      .boolean()
-      .optional()
-      .describe(
-        "Set true to post immediately. When omitted, the call is buffered " +
-          "and classified after the session completes — real review comments " +
-          "post, test/probe comments are dropped. Set false to buffer and " +
-          "never post. Only set true when posting final review comments.",
-      ),
  },
-  async ({ path, body, line, startLine, side, commit_id, confirmed }) => {
+  async ({ path, body, line, startLine, side, commit_id }) => {
    try {
      const githubToken = process.env.GITHUB_TOKEN;

@ -97,6 +80,8 @@ server.tool(
      const repo = REPO_NAME;
      const pull_number = parseInt(PR_NUMBER, 10);

+      const octokit = createOctokit(githubToken).rest;
+
      // Sanitize the comment body to remove any potential GitHub tokens
      const sanitizedBody = sanitizeContent(body);

@ -107,49 +92,10 @@ server.tool(
        );
      }

-      if (CLASSIFY_ENABLED && confirmed !== true) {
-        appendFileSync(
-          BUFFER_PATH,
-          JSON.stringify({
-            ts: new Date().toISOString(),
-            path,
-            line,
-            startLine,
-            side,
-            commit_id,
-            body: sanitizedBody,
-            confirmed,
-          }) + "\n",
-        );
-        return {
-          content: [
-            {
-              type: "text",
-              text: JSON.stringify(
-                {
-                  success: true,
-                  buffered: true,
-                  message:
-                    "Comment buffered. It will be classified and posted after " +
-                    "this session completes (real review comments post, " +
-                    "test/probe comments are dropped). Set confirmed=true to " +
-                    "post immediately. If you are testing whether this tool " +
-                    "works: it works — no need to test further.",
-                },
-                null,
-                2,
-              ),
-            },
-          ],
-        };
-      }
-
      // If only line is provided, it's a single-line comment
      // If both startLine and line are provided, it's a multi-line comment
      const isSingleLine = !startLine;

-      const octokit = createOctokit(githubToken).rest;
-
      const pr = await octokit.pulls.get({
        owner,
        repo,
--- a/src/mcp/install-mcp-server.ts
+++ b/src/mcp/install-mcp-server.ts
@ -152,9 +152,6 @@ export async function prepareMcpConfig(
          REPO_NAME: repo,
          PR_NUMBER: context.entityNumber?.toString() || "",
          GITHUB_API_URL: GITHUB_API_URL,
-          CLASSIFY_INLINE_COMMENTS: context.inputs.classifyInlineComments
-            ? "true"
-            : "false",
        },
      };
    }
@ -180,27 +177,25 @@ export async function prepareMcpConfig(
      if (!actuallyHasPermission) {
        core.warning(
          "The github_ci MCP server requires 'actions: read' permission. " +
-            "Skipping CI server installation. " +
-            "To enable CI status checks, add 'actions: read' to your workflow permissions. " +
+            "Please ensure your GitHub token has this permission. " +
            "See: https://docs.github.com/en/actions/security-guides/automatic-token-authentication#permissions-for-the-github_token",
        );
-      } else {
-        baseMcpConfig.mcpServers.github_ci = {
-          command: "bun",
-          args: [
-            "run",
-            `${process.env.GITHUB_ACTION_PATH}/src/mcp/github-actions-server.ts`,
-          ],
-          env: {
-            // Use workflow github token, not app token
-            GITHUB_TOKEN: process.env.DEFAULT_WORKFLOW_TOKEN,
-            REPO_OWNER: owner,
-            REPO_NAME: repo,
-            PR_NUMBER: context.entityNumber?.toString() || "",
-            RUNNER_TEMP: process.env.RUNNER_TEMP || "/tmp",
-          },
-        };
      }
+      baseMcpConfig.mcpServers.github_ci = {
+        command: "bun",
+        args: [
+          "run",
+          `${process.env.GITHUB_ACTION_PATH}/src/mcp/github-actions-server.ts`,
+        ],
+        env: {
+          // Use workflow github token, not app token
+          GITHUB_TOKEN: process.env.DEFAULT_WORKFLOW_TOKEN,
+          REPO_OWNER: owner,
+          REPO_NAME: repo,
+          PR_NUMBER: context.entityNumber?.toString() || "",
+          RUNNER_TEMP: process.env.RUNNER_TEMP || "/tmp",
+        },
+      };
    }

    if (hasGitHubMcpTools) {
--- a/src/mcp/path-validation.ts
+++ b/src/mcp/path-validation.ts
@ -1,64 +0,0 @@
-import { realpath } from "fs/promises";
-import { resolve, sep } from "path";
-
-/**
- * Validates that a file path resolves within the repository root.
- * Prevents path traversal attacks via "../" sequences and symlinks.
- * @param filePath - The file path to validate (can be relative or absolute)
- * @param repoRoot - The repository root directory
- * @returns The resolved absolute path (with symlinks resolved) if valid
- * @throws Error if the path resolves outside the repository root
- */
-export async function validatePathWithinRepo(
-  filePath: string,
-  repoRoot: string,
-): Promise<string> {
-  // First resolve the path string (handles .. and . segments)
-  const initialPath = resolve(repoRoot, filePath);
-
-  // Resolve symlinks to get the real path
-  // This prevents symlink attacks where a link inside the repo points outside
-  let resolvedRoot: string;
-  let resolvedPath: string;
-
-  try {
-    resolvedRoot = await realpath(repoRoot);
-  } catch {
-    throw new Error(`Repository root '${repoRoot}' does not exist`);
-  }
-
-  try {
-    resolvedPath = await realpath(initialPath);
-  } catch {
-    // File doesn't exist yet - fall back to checking the parent directory
-    // This handles the case where we're creating a new file
-    const parentDir = resolve(initialPath, "..");
-    try {
-      const resolvedParent = await realpath(parentDir);
-      if (
-        resolvedParent !== resolvedRoot &&
-        !resolvedParent.startsWith(resolvedRoot + sep)
-      ) {
-        throw new Error(
-          `Path '${filePath}' resolves outside the repository root`,
-        );
-      }
-      // Parent is valid, return the initial path since file doesn't exist yet
-      return initialPath;
-    } catch {
-      throw new Error(
-        `Path '${filePath}' resolves outside the repository root`,
-      );
-    }
-  }
-
-  // Path must be within repo root (or be the root itself)
-  if (
-    resolvedPath !== resolvedRoot &&
-    !resolvedPath.startsWith(resolvedRoot + sep)
-  ) {
-    throw new Error(`Path '${filePath}' resolves outside the repository root`);
-  }
-
-  return resolvedPath;
-}
--- a/src/modes/agent/index.ts
+++ b/src/modes/agent/index.ts
@ -1,134 +1,190 @@
+import * as core from "@actions/core";
 import { mkdir, writeFile } from "fs/promises";
+import type { Mode, ModeOptions, ModeResult } from "../types";
+import type { PreparedContext } from "../../create-prompt/types";
 import { prepareMcpConfig } from "../../mcp/install-mcp-server";
 import { parseAllowedTools } from "./parse-tools";
-import {
-  configureGitAuth,
-  setupSshSigning,
-} from "../../github/operations/git-config";
-import { checkHumanActor } from "../../github/validation/actor";
+import { configureGitAuth } from "../../github/operations/git-config";
 import type { GitHubContext } from "../../github/context";
-import type { Octokits } from "../../github/api/client";
+import { isEntityContext } from "../../github/context";

 /**
- * Prepares the agent mode execution context.
+ * Extract GitHub context as environment variables for agent mode
+ */
+function extractGitHubContext(context: GitHubContext): Record<string, string> {
+  const envVars: Record<string, string> = {};
+
+  // Basic repository info
+  envVars.GITHUB_REPOSITORY = context.repository.full_name;
+  envVars.GITHUB_TRIGGER_ACTOR = context.actor;
+  envVars.GITHUB_EVENT_NAME = context.eventName;
+
+  // Entity-specific context (PR/issue numbers, branches, etc.)
+  if (isEntityContext(context)) {
+    if (context.isPR) {
+      envVars.GITHUB_PR_NUMBER = String(context.entityNumber);
+
+      // Extract branch info from payload if available
+      if (
+        context.payload &&
+        "pull_request" in context.payload &&
+        context.payload.pull_request
+      ) {
+        envVars.GITHUB_BASE_REF = context.payload.pull_request.base?.ref || "";
+        envVars.GITHUB_HEAD_REF = context.payload.pull_request.head?.ref || "";
+      }
+    } else {
+      envVars.GITHUB_ISSUE_NUMBER = String(context.entityNumber);
+    }
+  }
+
+  return envVars;
+}
+
+/**
+ * Agent mode implementation.
 *
- * Agent mode runs whenever an explicit prompt is provided in the workflow configuration.
+ * This mode runs whenever an explicit prompt is provided in the workflow configuration.
 * It bypasses the standard @claude mention checking and comment tracking used by tag mode,
 * providing direct access to Claude Code for automation workflows.
 */
-export async function prepareAgentMode({
-  context,
-  octokit,
-  githubToken,
-}: {
-  context: GitHubContext;
-  octokit: Octokits;
-  githubToken: string;
-}) {
-  // Check if actor is human (prevents bot-triggered loops)
-  await checkHumanActor(octokit.rest, context);
+export const agentMode: Mode = {
+  name: "agent",
+  description: "Direct automation mode for explicit prompts",

-  // Configure git authentication for agent mode (same as tag mode)
-  // SSH signing takes precedence if provided
-  const useSshSigning = !!context.inputs.sshSigningKey;
-  const useApiCommitSigning = context.inputs.useCommitSigning && !useSshSigning;
+  shouldTrigger(context) {
+    // Only trigger when an explicit prompt is provided
+    return !!context.inputs?.prompt;
+  },

-  if (useSshSigning) {
-    // Setup SSH signing for commits
-    await setupSshSigning(context.inputs.sshSigningKey);
-
-    // Still configure git auth for push operations (user/email and remote URL)
-    const user = {
-      login: context.inputs.botName,
-      id: parseInt(context.inputs.botId),
+  prepareContext(context) {
+    // Agent mode doesn't use comment tracking or branch management
+    return {
+      mode: "agent",
+      githubContext: context,
    };
-    try {
-      await configureGitAuth(githubToken, context, user);
-    } catch (error) {
-      console.error("Failed to configure git authentication:", error);
-      // Continue anyway - git operations may still work with default config
+  },
+
+  getAllowedTools() {
+    return [];
+  },
+
+  getDisallowedTools() {
+    return [];
+  },
+
+  shouldCreateTrackingComment() {
+    return false;
+  },
+
+  async prepare({ context, githubToken }: ModeOptions): Promise<ModeResult> {
+    // Configure git authentication for agent mode (same as tag mode)
+    if (!context.inputs.useCommitSigning) {
+      // Use bot_id and bot_name from inputs directly
+      const user = {
+        login: context.inputs.botName,
+        id: parseInt(context.inputs.botId),
+      };
+
+      try {
+        // Use the shared git configuration function
+        await configureGitAuth(githubToken, context, user);
+      } catch (error) {
+        console.error("Failed to configure git authentication:", error);
+        // Continue anyway - git operations may still work with default config
+      }
    }
-  } else if (!useApiCommitSigning) {
-    // Use bot_id and bot_name from inputs directly
-    const user = {
-      login: context.inputs.botName,
-      id: parseInt(context.inputs.botId),
-    };

-    try {
-      // Use the shared git configuration function
-      await configureGitAuth(githubToken, context, user);
-    } catch (error) {
-      console.error("Failed to configure git authentication:", error);
-      // Continue anyway - git operations may still work with default config
-    }
-  }
+    // Create prompt directory
+    await mkdir(`${process.env.RUNNER_TEMP || "/tmp"}/claude-prompts`, {
+      recursive: true,
+    });

-  // Create prompt directory
-  await mkdir(`${process.env.RUNNER_TEMP || "/tmp"}/claude-prompts`, {
-    recursive: true,
-  });
+    // Write the prompt file - use the user's prompt directly
+    const promptContent =
+      context.inputs.prompt ||
+      `Repository: ${context.repository.owner}/${context.repository.repo}`;

-  // Write the prompt file - use the user's prompt directly
-  const promptContent =
-    context.inputs.prompt ||
-    `Repository: ${context.repository.owner}/${context.repository.repo}`;
+    await writeFile(
+      `${process.env.RUNNER_TEMP || "/tmp"}/claude-prompts/claude-prompt.txt`,
+      promptContent,
+    );

-  await writeFile(
-    `${process.env.RUNNER_TEMP || "/tmp"}/claude-prompts/claude-prompt.txt`,
-    promptContent,
-  );
+    // Parse allowed tools from user's claude_args
+    const userClaudeArgs = process.env.CLAUDE_ARGS || "";
+    const allowedTools = parseAllowedTools(userClaudeArgs);

-  // Parse allowed tools from user's claude_args
-  const userClaudeArgs = process.env.CLAUDE_ARGS || "";
-  const allowedTools = parseAllowedTools(userClaudeArgs);
+    // Check for branch info from environment variables (useful for auto-fix workflows)
+    const claudeBranch = process.env.CLAUDE_BRANCH || undefined;
+    const baseBranch =
+      process.env.BASE_BRANCH || context.inputs.baseBranch || "main";

-  // Check for branch info from environment variables (useful for auto-fix workflows)
-  const claudeBranch = process.env.CLAUDE_BRANCH || undefined;
-  const defaultBranch = context.repository.default_branch || "main";
-  const baseBranch = context.inputs.baseBranch || defaultBranch;
+    // Detect current branch from GitHub environment
+    const currentBranch =
+      claudeBranch ||
+      process.env.GITHUB_HEAD_REF ||
+      process.env.GITHUB_REF_NAME ||
+      "main";

-  // Detect current branch from GitHub environment
-  const currentBranch =
-    claudeBranch ||
-    process.env.GITHUB_HEAD_REF ||
-    process.env.GITHUB_REF_NAME ||
-    defaultBranch;
-
-  // Get our GitHub MCP servers config
-  const ourMcpConfig = await prepareMcpConfig({
-    githubToken,
-    owner: context.repository.owner,
-    repo: context.repository.repo,
-    branch: currentBranch,
-    baseBranch: baseBranch,
-    claudeCommentId: undefined, // No tracking comment in agent mode
-    allowedTools,
-    mode: "agent",
-    context,
-  });
-
-  // Build final claude_args with multiple --mcp-config flags
-  let claudeArgs = "";
-
-  // Add our GitHub servers config if we have any
-  const ourConfig = JSON.parse(ourMcpConfig);
-  if (ourConfig.mcpServers && Object.keys(ourConfig.mcpServers).length > 0) {
-    const escapedOurConfig = ourMcpConfig.replace(/'/g, "'\\''");
-    claudeArgs = `--mcp-config '${escapedOurConfig}'`;
-  }
-
-  // Append user's claude_args (which may have more --mcp-config flags)
-  claudeArgs = `${claudeArgs} ${userClaudeArgs}`.trim();
-
-  return {
-    commentId: undefined,
-    branchInfo: {
+    // Get our GitHub MCP servers config
+    const ourMcpConfig = await prepareMcpConfig({
+      githubToken,
+      owner: context.repository.owner,
+      repo: context.repository.repo,
+      branch: currentBranch,
      baseBranch: baseBranch,
-      currentBranch: baseBranch, // Use base branch as current when creating new branch
-      claudeBranch: claudeBranch,
-    },
-    mcpConfig: ourMcpConfig,
-    claudeArgs,
-  };
-}
+      claudeCommentId: undefined, // No tracking comment in agent mode
+      allowedTools,
+      mode: "agent",
+      context,
+    });
+
+    // Build final claude_args with multiple --mcp-config flags
+    let claudeArgs = "";
+
+    // Add our GitHub servers config if we have any
+    const ourConfig = JSON.parse(ourMcpConfig);
+    if (ourConfig.mcpServers && Object.keys(ourConfig.mcpServers).length > 0) {
+      const escapedOurConfig = ourMcpConfig.replace(/'/g, "'\\''");
+      claudeArgs = `--mcp-config '${escapedOurConfig}'`;
+    }
+
+    // Append user's claude_args (which may have more --mcp-config flags)
+    claudeArgs = `${claudeArgs} ${userClaudeArgs}`.trim();
+
+    core.setOutput("claude_args", claudeArgs);
+
+    return {
+      commentId: undefined,
+      branchInfo: {
+        baseBranch: baseBranch,
+        currentBranch: baseBranch, // Use base branch as current when creating new branch
+        claudeBranch: claudeBranch,
+      },
+      mcpConfig: ourMcpConfig,
+    };
+  },
+
+  generatePrompt(context: PreparedContext): string {
+    // Inject GitHub context as environment variables
+    if (context.githubContext) {
+      const envVars = extractGitHubContext(context.githubContext);
+      for (const [key, value] of Object.entries(envVars)) {
+        core.exportVariable(key, value);
+      }
+    }
+
+    // Agent mode uses prompt field
+    if (context.prompt) {
+      return context.prompt;
+    }
+
+    // Minimal fallback - repository is a string in PreparedContext
+    return `Repository: ${context.repository}`;
+  },
+
+  getSystemPrompt() {
+    // Agent mode doesn't need additional system prompts
+    return undefined;
+  },
+};
--- a/src/modes/agent/parse-tools.ts
+++ b/src/modes/agent/parse-tools.ts
@ -1,33 +1,22 @@
 export function parseAllowedTools(claudeArgs: string): string[] {
  // Match --allowedTools or --allowed-tools followed by the value
  // Handle both quoted and unquoted values
-  // Use /g flag to find ALL occurrences, not just the first one
  const patterns = [
-    /--(?:allowedTools|allowed-tools)\s+"([^"]+)"/g, // Double quoted
-    /--(?:allowedTools|allowed-tools)\s+'([^']+)'/g, // Single quoted
-    /--(?:allowedTools|allowed-tools)\s+([^'"\s][^\s]*)/g, // Unquoted (must not start with quote)
+    /--(?:allowedTools|allowed-tools)\s+"([^"]+)"/, // Double quoted
+    /--(?:allowedTools|allowed-tools)\s+'([^']+)'/, // Single quoted
+    /--(?:allowedTools|allowed-tools)\s+([^\s]+)/, // Unquoted
  ];

-  const tools: string[] = [];
-  const seen = new Set<string>();
-
  for (const pattern of patterns) {
-    for (const match of claudeArgs.matchAll(pattern)) {
-      if (match[1]) {
-        // Don't add if the value starts with -- (another flag)
-        if (match[1].startsWith("--")) {
-          continue;
-        }
-        for (const tool of match[1].split(",")) {
-          const trimmed = tool.trim();
-          if (trimmed && !seen.has(trimmed)) {
-            seen.add(trimmed);
-            tools.push(trimmed);
-          }
-        }
+    const match = claudeArgs.match(pattern);
+    if (match && match[1]) {
+      // Don't return if the value starts with -- (another flag)
+      if (match[1].startsWith("--")) {
+        return [];
      }
+      return match[1].split(",").map((t) => t.trim());
    }
  }

-  return tools;
+  return [];
 }
--- a/src/modes/detector.ts
+++ b/src/modes/detector.ts
@ -80,6 +80,17 @@ export function detectMode(context: GitHubContext): AutoDetectedMode {
  return "agent";
 }

+export function getModeDescription(mode: AutoDetectedMode): string {
+  switch (mode) {
+    case "tag":
+      return "Interactive mode triggered by @claude mentions";
+    case "agent":
+      return "Direct automation mode for explicit prompts";
+    default:
+      return "Unknown mode";
+  }
+}
+
 function validateTrackProgressEvent(context: GitHubContext): void {
  // track_progress is only valid for pull_request and issue events
  const validEvents = [
@ -112,3 +123,21 @@ function validateTrackProgressEvent(context: GitHubContext): void {
    }
  }
 }
+
+export function shouldUseTrackingComment(mode: AutoDetectedMode): boolean {
+  return mode === "tag";
+}
+
+export function getDefaultPromptForMode(
+  mode: AutoDetectedMode,
+  context: GitHubContext,
+): string | undefined {
+  switch (mode) {
+    case "tag":
+      return undefined;
+    case "agent":
+      return context.inputs?.prompt;
+    default:
+      return undefined;
+  }
+}
--- a/src/modes/registry.ts
+++ b/src/modes/registry.ts
@ -0,0 +1,54 @@
+/**
+ * Mode Registry for claude-code-action v1.0
+ *
+ * This module provides access to all available execution modes and handles
+ * automatic mode detection based on GitHub event types.
+ */
+
+import type { Mode, ModeName } from "./types";
+import { tagMode } from "./tag";
+import { agentMode } from "./agent";
+import type { GitHubContext } from "../github/context";
+import { detectMode, type AutoDetectedMode } from "./detector";
+
+export const VALID_MODES = ["tag", "agent"] as const;
+
+/**
+ * All available modes in v1.0
+ */
+const modes = {
+  tag: tagMode,
+  agent: agentMode,
+} as const satisfies Record<AutoDetectedMode, Mode>;
+
+/**
+ * Automatically detects and retrieves the appropriate mode based on the GitHub context.
+ * In v1.0, modes are auto-selected based on event type.
+ * @param context The GitHub context
+ * @returns The appropriate mode for the context
+ */
+export function getMode(context: GitHubContext): Mode {
+  const modeName = detectMode(context);
+  console.log(
+    `Auto-detected mode: ${modeName} for event: ${context.eventName}`,
+  );
+
+  const mode = modes[modeName];
+  if (!mode) {
+    throw new Error(
+      `Mode '${modeName}' not found. This should not happen. Please report this issue.`,
+    );
+  }
+
+  return mode;
+}
+
+/**
+ * Type guard to check if a string is a valid mode name.
+ * @param name The string to check
+ * @returns True if the name is a valid mode name
+ */
+export function isValidMode(name: string): name is ModeName {
+  const validModes = ["tag", "agent"];
+  return validModes.includes(name);
+}
--- a/src/modes/tag/index.ts
+++ b/src/modes/tag/index.ts
@ -1,188 +1,224 @@
+import * as core from "@actions/core";
+import type { Mode, ModeOptions, ModeResult } from "../types";
+import { checkContainsTrigger } from "../../github/validation/trigger";
 import { checkHumanActor } from "../../github/validation/actor";
 import { createInitialComment } from "../../github/operations/comments/create-initial";
 import { setupBranch } from "../../github/operations/branch";
-import {
-  configureGitAuth,
-  setupSshSigning,
-} from "../../github/operations/git-config";
+import { configureGitAuth } from "../../github/operations/git-config";
 import { prepareMcpConfig } from "../../mcp/install-mcp-server";
 import {
  fetchGitHubData,
  extractTriggerTimestamp,
-  extractOriginalTitle,
-  extractOriginalBody,
 } from "../../github/data/fetcher";
-import { createPrompt } from "../../create-prompt";
+import { createPrompt, generateDefaultPrompt } from "../../create-prompt";
 import { isEntityContext } from "../../github/context";
-import type { GitHubContext } from "../../github/context";
-import type { Octokits } from "../../github/api/client";
+import type { PreparedContext } from "../../create-prompt/types";
+import type { FetchDataResult } from "../../github/data/fetcher";
 import { parseAllowedTools } from "../agent/parse-tools";

 /**
- * Prepares the tag mode execution context.
+ * Tag mode implementation.
 *
- * Tag mode responds to @claude mentions, issue assignments, or labels.
- * Creates tracking comments showing progress and has full implementation capabilities.
+ * The traditional implementation mode that responds to @claude mentions,
+ * issue assignments, or labels. Creates tracking comments showing progress
+ * and has full implementation capabilities.
 */
-export async function prepareTagMode({
-  context,
-  octokit,
-  githubToken,
-}: {
-  context: GitHubContext;
-  octokit: Octokits;
-  githubToken: string;
-}) {
-  // Tag mode only handles entity-based events
-  if (!isEntityContext(context)) {
-    throw new Error("Tag mode requires entity context");
-  }
+export const tagMode: Mode = {
+  name: "tag",
+  description: "Traditional implementation mode triggered by @claude mentions",

-  // Check if actor is human
-  await checkHumanActor(octokit.rest, context);
-
-  // Create initial tracking comment
-  const commentData = await createInitialComment(octokit.rest, context);
-  const commentId = commentData.id;
-
-  const triggerTime = extractTriggerTimestamp(context);
-  const originalTitle = extractOriginalTitle(context);
-  const originalBody = extractOriginalBody(context);
-
-  const githubData = await fetchGitHubData({
-    octokits: octokit,
-    repository: `${context.repository.owner}/${context.repository.repo}`,
-    prNumber: context.entityNumber.toString(),
-    isPR: context.isPR,
-    triggerUsername: context.actor,
-    triggerTime,
-    originalTitle,
-    originalBody,
-    includeCommentsByActor: context.inputs.includeCommentsByActor,
-    excludeCommentsByActor: context.inputs.excludeCommentsByActor,
-  });
-
-  // Setup branch
-  const branchInfo = await setupBranch(octokit, githubData, context);
-
-  // Configure git authentication
-  // SSH signing takes precedence if provided
-  const useSshSigning = !!context.inputs.sshSigningKey;
-  const useApiCommitSigning = context.inputs.useCommitSigning && !useSshSigning;
-
-  if (useSshSigning) {
-    // Setup SSH signing for commits
-    await setupSshSigning(context.inputs.sshSigningKey);
-
-    // Still configure git auth for push operations (user/email and remote URL)
-    const user = {
-      login: context.inputs.botName,
-      id: parseInt(context.inputs.botId),
-    };
-    try {
-      await configureGitAuth(githubToken, context, user);
-    } catch (error) {
-      console.error("Failed to configure git authentication:", error);
-      throw error;
+  shouldTrigger(context) {
+    // Tag mode only handles entity events
+    if (!isEntityContext(context)) {
+      return false;
    }
-  } else if (!useApiCommitSigning) {
-    // Use bot_id and bot_name from inputs directly
-    const user = {
-      login: context.inputs.botName,
-      id: parseInt(context.inputs.botId),
+    return checkContainsTrigger(context);
+  },
+
+  prepareContext(context, data) {
+    return {
+      mode: "tag",
+      githubContext: context,
+      commentId: data?.commentId,
+      baseBranch: data?.baseBranch,
+      claudeBranch: data?.claudeBranch,
    };
+  },

-    try {
-      await configureGitAuth(githubToken, context, user);
-    } catch (error) {
-      console.error("Failed to configure git authentication:", error);
-      throw error;
-    }
-  }
+  getAllowedTools() {
+    return [];
+  },

-  // Create prompt file
-  await createPrompt(
-    commentId,
-    branchInfo.baseBranch,
-    branchInfo.claudeBranch,
-    githubData,
+  getDisallowedTools() {
+    return [];
+  },
+
+  shouldCreateTrackingComment() {
+    return true;
+  },
+
+  async prepare({
    context,
-  );
-
-  const userClaudeArgs = process.env.CLAUDE_ARGS || "";
-  const userAllowedMCPTools = parseAllowedTools(userClaudeArgs).filter((tool) =>
-    tool.startsWith("mcp__github_"),
-  );
-
-  const gitPushWrapper = `${process.env.GITHUB_ACTION_PATH}/scripts/git-push.sh`;
-
-  // Build claude_args for tag mode with required tools.
-  // Edit/MultiEdit/Write are intentionally omitted: acceptEdits permission mode (set below)
-  // auto-allows file edits inside $GITHUB_WORKSPACE and denies writes outside (e.g. ~/.bashrc).
-  // Listing them here would grant blanket write access to the whole runner (Asana 1213310082312048).
-  const tagModeTools = [
-    "Glob",
-    "Grep",
-    "LS",
-    "Read",
-    "mcp__github_comment__update_claude_comment",
-    "mcp__github_ci__get_ci_status",
-    "mcp__github_ci__get_workflow_run_details",
-    "mcp__github_ci__download_job_log",
-    ...userAllowedMCPTools,
-  ];
-
-  // Add git commands when using git CLI (no API commit signing, or SSH signing)
-  // SSH signing still uses git CLI, just with signing enabled
-  if (!useApiCommitSigning) {
-    tagModeTools.push(
-      "Bash(git add:*)",
-      "Bash(git commit:*)",
-      `Bash(${gitPushWrapper}:*)`,
-      "Bash(git rm:*)",
-    );
-  } else {
-    // When using API commit signing, use MCP file ops tools
-    tagModeTools.push(
-      "mcp__github_file_ops__commit_files",
-      "mcp__github_file_ops__delete_files",
-    );
-  }
-
-  // Get our GitHub MCP servers configuration
-  const ourMcpConfig = await prepareMcpConfig({
+    octokit,
    githubToken,
-    owner: context.repository.owner,
-    repo: context.repository.repo,
-    branch: branchInfo.claudeBranch || branchInfo.currentBranch,
-    baseBranch: branchInfo.baseBranch,
-    claudeCommentId: commentId.toString(),
-    allowedTools: Array.from(new Set(tagModeTools)),
-    mode: "tag",
-    context,
-  });
+  }: ModeOptions): Promise<ModeResult> {
+    // Tag mode only handles entity-based events
+    if (!isEntityContext(context)) {
+      throw new Error("Tag mode requires entity context");
+    }

-  // Build complete claude_args with multiple --mcp-config flags
-  let claudeArgs = "";
+    // Check if actor is human
+    await checkHumanActor(octokit.rest, context);

-  // Add our GitHub servers config
-  const escapedOurConfig = ourMcpConfig.replace(/'/g, "'\\''");
-  claudeArgs = `--mcp-config '${escapedOurConfig}'`;
+    // Create initial tracking comment
+    const commentData = await createInitialComment(octokit.rest, context);
+    const commentId = commentData.id;

-  // Add required tools for tag mode.
-  // acceptEdits: file edits auto-allowed inside cwd ($GITHUB_WORKSPACE), denied outside.
-  // Headless SDK has no prompt handler, so anything that falls through to "ask" is denied.
-  claudeArgs += ` --permission-mode acceptEdits --allowedTools "${tagModeTools.join(",")}"`;
+    const triggerTime = extractTriggerTimestamp(context);

-  // Append user's claude_args (which may have more --mcp-config flags)
-  if (userClaudeArgs) {
-    claudeArgs += ` ${userClaudeArgs}`;
-  }
+    const githubData = await fetchGitHubData({
+      octokits: octokit,
+      repository: `${context.repository.owner}/${context.repository.repo}`,
+      prNumber: context.entityNumber.toString(),
+      isPR: context.isPR,
+      triggerUsername: context.actor,
+      triggerTime,
+    });

-  return {
-    commentId,
-    branchInfo,
-    mcpConfig: ourMcpConfig,
-    claudeArgs: claudeArgs.trim(),
-  };
-}
+    // Setup branch
+    const branchInfo = await setupBranch(octokit, githubData, context);
+
+    // Configure git authentication if not using commit signing
+    if (!context.inputs.useCommitSigning) {
+      // Use bot_id and bot_name from inputs directly
+      const user = {
+        login: context.inputs.botName,
+        id: parseInt(context.inputs.botId),
+      };
+
+      try {
+        await configureGitAuth(githubToken, context, user);
+      } catch (error) {
+        console.error("Failed to configure git authentication:", error);
+        throw error;
+      }
+    }
+
+    // Create prompt file
+    const modeContext = this.prepareContext(context, {
+      commentId,
+      baseBranch: branchInfo.baseBranch,
+      claudeBranch: branchInfo.claudeBranch,
+    });
+
+    await createPrompt(tagMode, modeContext, githubData, context);
+
+    const userClaudeArgs = process.env.CLAUDE_ARGS || "";
+    const userAllowedMCPTools = parseAllowedTools(userClaudeArgs).filter(
+      (tool) => tool.startsWith("mcp__github_"),
+    );
+
+    // Build claude_args for tag mode with required tools
+    // Tag mode REQUIRES these tools to function properly
+    const tagModeTools = [
+      "Edit",
+      "MultiEdit",
+      "Glob",
+      "Grep",
+      "LS",
+      "Read",
+      "Write",
+      "mcp__github_comment__update_claude_comment",
+      "mcp__github_ci__get_ci_status",
+      "mcp__github_ci__get_workflow_run_details",
+      "mcp__github_ci__download_job_log",
+      ...userAllowedMCPTools,
+    ];
+
+    // Add git commands when not using commit signing
+    if (!context.inputs.useCommitSigning) {
+      tagModeTools.push(
+        "Bash(git add:*)",
+        "Bash(git commit:*)",
+        "Bash(git push:*)",
+        "Bash(git status:*)",
+        "Bash(git diff:*)",
+        "Bash(git log:*)",
+        "Bash(git rm:*)",
+      );
+    } else {
+      // When using commit signing, use MCP file ops tools
+      tagModeTools.push(
+        "mcp__github_file_ops__commit_files",
+        "mcp__github_file_ops__delete_files",
+      );
+    }
+
+    // Get our GitHub MCP servers configuration
+    const ourMcpConfig = await prepareMcpConfig({
+      githubToken,
+      owner: context.repository.owner,
+      repo: context.repository.repo,
+      branch: branchInfo.claudeBranch || branchInfo.currentBranch,
+      baseBranch: branchInfo.baseBranch,
+      claudeCommentId: commentId.toString(),
+      allowedTools: Array.from(new Set(tagModeTools)),
+      mode: "tag",
+      context,
+    });
+
+    // Build complete claude_args with multiple --mcp-config flags
+    let claudeArgs = "";
+
+    // Add our GitHub servers config
+    const escapedOurConfig = ourMcpConfig.replace(/'/g, "'\\''");
+    claudeArgs = `--mcp-config '${escapedOurConfig}'`;
+
+    // Add required tools for tag mode
+    claudeArgs += ` --allowedTools "${tagModeTools.join(",")}"`;
+
+    // Append user's claude_args (which may have more --mcp-config flags)
+    if (userClaudeArgs) {
+      claudeArgs += ` ${userClaudeArgs}`;
+    }
+
+    core.setOutput("claude_args", claudeArgs.trim());
+
+    return {
+      commentId,
+      branchInfo,
+      mcpConfig: ourMcpConfig,
+    };
+  },
+
+  generatePrompt(
+    context: PreparedContext,
+    githubData: FetchDataResult,
+    useCommitSigning: boolean,
+  ): string {
+    const defaultPrompt = generateDefaultPrompt(
+      context,
+      githubData,
+      useCommitSigning,
+    );
+
+    // If a custom prompt is provided, inject it into the tag mode prompt
+    if (context.githubContext?.inputs?.prompt) {
+      return (
+        defaultPrompt +
+        `
+
+<custom_instructions>
+${context.githubContext.inputs.prompt}
+</custom_instructions>`
+      );
+    }
+
+    return defaultPrompt;
+  },
+
+  getSystemPrompt() {
+    // Tag mode doesn't need additional system prompts
+    return undefined;
+  },
+};
--- a/src/modes/types.ts
+++ b/src/modes/types.ts
@ -0,0 +1,100 @@
+import type { GitHubContext } from "../github/context";
+import type { PreparedContext } from "../create-prompt/types";
+import type { FetchDataResult } from "../github/data/fetcher";
+import type { Octokits } from "../github/api/client";
+
+export type ModeName = "tag" | "agent";
+
+export type ModeContext = {
+  mode: ModeName;
+  githubContext: GitHubContext;
+  commentId?: number;
+  baseBranch?: string;
+  claudeBranch?: string;
+};
+
+export type ModeData = {
+  commentId?: number;
+  baseBranch?: string;
+  claudeBranch?: string;
+};
+
+/**
+ * Mode interface for claude-code-action execution modes.
+ * Each mode defines its own behavior for trigger detection, prompt generation,
+ * and tracking comment creation.
+ *
+ * Current modes include:
+ * - 'tag': Interactive mode triggered by @claude mentions
+ * - 'agent': Direct automation mode triggered by explicit prompts
+ */
+export type Mode = {
+  name: ModeName;
+  description: string;
+
+  /**
+   * Determines if this mode should trigger based on the GitHub context
+   */
+  shouldTrigger(context: GitHubContext): boolean;
+
+  /**
+   * Prepares the mode context with any additional data needed for prompt generation
+   */
+  prepareContext(context: GitHubContext, data?: ModeData): ModeContext;
+
+  /**
+   * Returns the list of tools that should be allowed for this mode
+   */
+  getAllowedTools(): string[];
+
+  /**
+   * Returns the list of tools that should be disallowed for this mode
+   */
+  getDisallowedTools(): string[];
+
+  /**
+   * Determines if this mode should create a tracking comment
+   */
+  shouldCreateTrackingComment(): boolean;
+
+  /**
+   * Generates the prompt for this mode.
+   * @returns The complete prompt string
+   */
+  generatePrompt(
+    context: PreparedContext,
+    githubData: FetchDataResult,
+    useCommitSigning: boolean,
+  ): string;
+
+  /**
+   * Prepares the GitHub environment for this mode.
+   * Each mode decides how to handle different event types.
+   * @returns PrepareResult with commentId, branchInfo, and mcpConfig
+   */
+  prepare(options: ModeOptions): Promise<ModeResult>;
+
+  /**
+   * Returns an optional system prompt to append to Claude's base system prompt.
+   * This allows modes to add mode-specific instructions.
+   * @returns The system prompt string or undefined if no additional prompt is needed
+   */
+  getSystemPrompt?(context: ModeContext): string | undefined;
+};
+
+// Define types for mode prepare method
+export type ModeOptions = {
+  context: GitHubContext;
+  octokit: Octokits;
+  githubToken: string;
+};
+
+export type ModeResult = {
+  commentId?: number;
+  branchInfo: {
+    baseBranch: string;
+    claudeBranch?: string;
+    currentBranch: string;
+  };
+  mcpConfig: string;
+};
--- a/src/prepare/index.ts
+++ b/src/prepare/index.ts
@ -0,0 +1,20 @@
+/**
+ * Main prepare module that delegates to the mode's prepare method
+ */
+
+import type { PrepareOptions, PrepareResult } from "./types";
+
+export async function prepare(options: PrepareOptions): Promise<PrepareResult> {
+  const { mode, context, octokit, githubToken } = options;
+
+  console.log(
+    `Preparing with mode: ${mode.name} for event: ${context.eventName}`,
+  );
+
+  // Delegate to the mode's prepare method
+  return mode.prepare({
+    context,
+    octokit,
+    githubToken,
+  });
+}
--- a/src/prepare/types.ts
+++ b/src/prepare/types.ts
@ -0,0 +1,20 @@
+import type { GitHubContext } from "../github/context";
+import type { Octokits } from "../github/api/client";
+import type { Mode } from "../modes/types";
+
+export type PrepareResult = {
+  commentId?: number;
+  branchInfo: {
+    baseBranch: string;
+    claudeBranch?: string;
+    currentBranch: string;
+  };
+  mcpConfig: string;
+};
+
+export type PrepareOptions = {
+  context: GitHubContext;
+  octokit: Octokits;
+  mode: Mode;
+  githubToken: string;
+};
--- a/src/utils/branch-template.ts
+++ b/src/utils/branch-template.ts
@ -1,99 +0,0 @@
-#!/usr/bin/env bun
-
-/**
- * Branch name template parsing and variable substitution utilities
- */
-
-const NUM_DESCRIPTION_WORDS = 5;
-
-/**
- * Extracts the first 5 words from a title and converts them to kebab-case
- */
-function extractDescription(
-  title: string,
-  numWords: number = NUM_DESCRIPTION_WORDS,
-): string {
-  if (!title || title.trim() === "") {
-    return "";
-  }
-
-  return title
-    .trim()
-    .split(/\s+/)
-    .slice(0, numWords) // Only first `numWords` words
-    .join("-")
-    .toLowerCase()
-    .replace(/[^a-z0-9-]/g, "") // Remove non-alphanumeric except hyphens
-    .replace(/-+/g, "-") // Replace multiple hyphens with single
-    .replace(/^-|-$/g, ""); // Remove leading/trailing hyphens
-}
-
-export interface BranchTemplateVariables {
-  prefix: string;
-  entityType: string;
-  entityNumber: number;
-  timestamp: string;
-  sha?: string;
-  label?: string;
-  description?: string;
-}
-
-/**
- * Replaces template variables in a branch name template
- * Template format: {{variableName}}
- */
-export function applyBranchTemplate(
-  template: string,
-  variables: BranchTemplateVariables,
-): string {
-  let result = template;
-
-  // Replace each variable
-  Object.entries(variables).forEach(([key, value]) => {
-    const placeholder = `{{${key}}}`;
-    const replacement = value ? String(value) : "";
-    result = result.replaceAll(placeholder, replacement);
-  });
-
-  return result;
-}
-
-/**
- * Generates a branch name from the provided `template` and set of `variables`. Uses a default format if the template is empty or produces an empty result.
- */
-export function generateBranchName(
-  template: string | undefined,
-  branchPrefix: string,
-  entityType: string,
-  entityNumber: number,
-  sha?: string,
-  label?: string,
-  title?: string,
-): string {
-  const now = new Date();
-
-  const variables: BranchTemplateVariables = {
-    prefix: branchPrefix,
-    entityType,
-    entityNumber,
-    timestamp: `${now.getFullYear()}${String(now.getMonth() + 1).padStart(2, "0")}${String(now.getDate()).padStart(2, "0")}-${String(now.getHours()).padStart(2, "0")}${String(now.getMinutes()).padStart(2, "0")}`,
-    sha: sha?.substring(0, 8), // First 8 characters of SHA
-    label: label || entityType, // Fall back to entityType if no label
-    description: title ? extractDescription(title) : undefined,
-  };
-
-  if (template?.trim()) {
-    const branchName = applyBranchTemplate(template, variables);
-
-    // Some templates could produce empty results- validate
-    if (branchName.trim().length > 0) return branchName;
-
-    console.log(
-      `Branch template '${template}' generated empty result, falling back to default format`,
-    );
-  }
-
-  const branchName = `${branchPrefix}${entityType}-${entityNumber}-${variables.timestamp}`;
-  // Kubernetes compatible: lowercase, max 50 chars, alphanumeric and hyphens only
-  return branchName.toLowerCase().substring(0, 50);
-}
--- a/src/utils/extract-user-request.ts
+++ b/src/utils/extract-user-request.ts
@ -1,32 +0,0 @@
-/**
- * Extracts the user's request from a trigger comment.
- *
- * Given a comment like "@claude /review-pr please check the auth module",
- * this extracts "/review-pr please check the auth module".
- *
- * @param commentBody - The full comment body containing the trigger phrase
- * @param triggerPhrase - The trigger phrase (e.g., "@claude")
- * @returns The user's request (text after the trigger phrase), or null if not found
- */
-export function extractUserRequest(
-  commentBody: string | undefined,
-  triggerPhrase: string,
-): string | null {
-  if (!commentBody) {
-    return null;
-  }
-
-  // Use string operations instead of regex for better performance and security
-  // (avoids potential ReDoS with large comment bodies)
-  const triggerIndex = commentBody
-    .toLowerCase()
-    .indexOf(triggerPhrase.toLowerCase());
-  if (triggerIndex === -1) {
-    return null;
-  }
-
-  const afterTrigger = commentBody
-    .substring(triggerIndex + triggerPhrase.length)
-    .trim();
-  return afterTrigger || null;
-}
--- a/src/utils/retry.ts
+++ b/src/utils/retry.ts
@ -3,7 +3,6 @@ export type RetryOptions = {
  initialDelayMs?: number;
  maxDelayMs?: number;
  backoffFactor?: number;
-  shouldRetry?: (error: Error) => boolean;
 };

 export async function retryWithBackoff<T>(
@ -15,7 +14,6 @@ export async function retryWithBackoff<T>(
    initialDelayMs = 5000,
    maxDelayMs = 20000,
    backoffFactor = 2,
-    shouldRetry,
  } = options;

  let delayMs = initialDelayMs;
@ -29,11 +27,6 @@ export async function retryWithBackoff<T>(
      lastError = error instanceof Error ? error : new Error(String(error));
      console.error(`Attempt ${attempt} failed:`, lastError.message);

-      if (shouldRetry && !shouldRetry(lastError)) {
-        console.error("Error is not retryable, giving up immediately");
-        throw lastError;
-      }
-
      if (attempt < maxAttempts) {
        console.log(`Retrying in ${delayMs / 1000} seconds...`);
        await new Promise((resolve) => setTimeout(resolve, delayMs));
--- a/test/actor-filter.test.ts
+++ b/test/actor-filter.test.ts
@ -1,172 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import {
-  parseActorFilter,
-  actorMatchesPattern,
-  shouldIncludeCommentByActor,
-} from "../src/github/utils/actor-filter";
-
-describe("parseActorFilter", () => {
-  test("parses comma-separated actors", () => {
-    expect(parseActorFilter("user1,user2,bot[bot]")).toEqual([
-      "user1",
-      "user2",
-      "bot[bot]",
-    ]);
-  });
-
-  test("handles empty string", () => {
-    expect(parseActorFilter("")).toEqual([]);
-  });
-
-  test("handles whitespace-only string", () => {
-    expect(parseActorFilter("   ")).toEqual([]);
-  });
-
-  test("trims whitespace", () => {
-    expect(parseActorFilter(" user1 , user2 ")).toEqual(["user1", "user2"]);
-  });
-
-  test("filters out empty entries", () => {
-    expect(parseActorFilter("user1,,user2")).toEqual(["user1", "user2"]);
-  });
-
-  test("handles single actor", () => {
-    expect(parseActorFilter("user1")).toEqual(["user1"]);
-  });
-
-  test("handles wildcard bot pattern", () => {
-    expect(parseActorFilter("*[bot]")).toEqual(["*[bot]"]);
-  });
-});
-
-describe("actorMatchesPattern", () => {
-  test("matches exact username", () => {
-    expect(actorMatchesPattern("john-doe", "john-doe")).toBe(true);
-  });
-
-  test("does not match different username", () => {
-    expect(actorMatchesPattern("john-doe", "jane-doe")).toBe(false);
-  });
-
-  test("matches wildcard bot pattern", () => {
-    expect(actorMatchesPattern("dependabot[bot]", "*[bot]")).toBe(true);
-    expect(actorMatchesPattern("renovate[bot]", "*[bot]")).toBe(true);
-    expect(actorMatchesPattern("github-actions[bot]", "*[bot]")).toBe(true);
-  });
-
-  test("does not match non-bot with wildcard", () => {
-    expect(actorMatchesPattern("john-doe", "*[bot]")).toBe(false);
-    expect(actorMatchesPattern("user-bot", "*[bot]")).toBe(false);
-  });
-
-  test("matches specific bot", () => {
-    expect(actorMatchesPattern("dependabot[bot]", "dependabot[bot]")).toBe(
-      true,
-    );
-    expect(actorMatchesPattern("renovate[bot]", "renovate[bot]")).toBe(true);
-  });
-
-  test("does not match different specific bot", () => {
-    expect(actorMatchesPattern("dependabot[bot]", "renovate[bot]")).toBe(false);
-  });
-
-  test("is case sensitive", () => {
-    expect(actorMatchesPattern("User1", "user1")).toBe(false);
-    expect(actorMatchesPattern("user1", "User1")).toBe(false);
-  });
-});
-
-describe("shouldIncludeCommentByActor", () => {
-  test("includes all when no filters", () => {
-    expect(shouldIncludeCommentByActor("user1", [], [])).toBe(true);
-    expect(shouldIncludeCommentByActor("bot[bot]", [], [])).toBe(true);
-  });
-
-  test("excludes when in exclude list", () => {
-    expect(shouldIncludeCommentByActor("bot[bot]", [], ["*[bot]"])).toBe(false);
-    expect(shouldIncludeCommentByActor("user1", [], ["user1"])).toBe(false);
-  });
-
-  test("includes when not in exclude list", () => {
-    expect(shouldIncludeCommentByActor("user1", [], ["user2"])).toBe(true);
-    expect(shouldIncludeCommentByActor("user1", [], ["*[bot]"])).toBe(true);
-  });
-
-  test("includes when in include list", () => {
-    expect(shouldIncludeCommentByActor("user1", ["user1", "user2"], [])).toBe(
-      true,
-    );
-    expect(shouldIncludeCommentByActor("user2", ["user1", "user2"], [])).toBe(
-      true,
-    );
-  });
-
-  test("excludes when not in include list", () => {
-    expect(shouldIncludeCommentByActor("user3", ["user1", "user2"], [])).toBe(
-      false,
-    );
-  });
-
-  test("exclusion takes priority over inclusion", () => {
-    expect(shouldIncludeCommentByActor("user1", ["user1"], ["user1"])).toBe(
-      false,
-    );
-    expect(
-      shouldIncludeCommentByActor("bot[bot]", ["*[bot]"], ["*[bot]"]),
-    ).toBe(false);
-  });
-
-  test("handles wildcard in include list", () => {
-    expect(shouldIncludeCommentByActor("dependabot[bot]", ["*[bot]"], [])).toBe(
-      true,
-    );
-    expect(shouldIncludeCommentByActor("renovate[bot]", ["*[bot]"], [])).toBe(
-      true,
-    );
-    expect(shouldIncludeCommentByActor("user1", ["*[bot]"], [])).toBe(false);
-  });
-
-  test("handles wildcard in exclude list", () => {
-    expect(shouldIncludeCommentByActor("dependabot[bot]", [], ["*[bot]"])).toBe(
-      false,
-    );
-    expect(shouldIncludeCommentByActor("renovate[bot]", [], ["*[bot]"])).toBe(
-      false,
-    );
-    expect(shouldIncludeCommentByActor("user1", [], ["*[bot]"])).toBe(true);
-  });
-
-  test("handles mixed include and exclude lists", () => {
-    // Include user1 and user2, but exclude user2
-    expect(
-      shouldIncludeCommentByActor("user1", ["user1", "user2"], ["user2"]),
-    ).toBe(true);
-    expect(
-      shouldIncludeCommentByActor("user2", ["user1", "user2"], ["user2"]),
-    ).toBe(false);
-    expect(
-      shouldIncludeCommentByActor("user3", ["user1", "user2"], ["user2"]),
-    ).toBe(false);
-  });
-
-  test("handles complex bot filtering", () => {
-    // Include all bots but exclude dependabot
-    expect(
-      shouldIncludeCommentByActor(
-        "renovate[bot]",
-        ["*[bot]"],
-        ["dependabot[bot]"],
-      ),
-    ).toBe(true);
-    expect(
-      shouldIncludeCommentByActor(
-        "dependabot[bot]",
-        ["*[bot]"],
-        ["dependabot[bot]"],
-      ),
-    ).toBe(false);
-    expect(
-      shouldIncludeCommentByActor("user1", ["*[bot]"], ["dependabot[bot]"]),
-    ).toBe(false);
-  });
-});
--- a/test/branch-template.test.ts
+++ b/test/branch-template.test.ts
@ -1,247 +0,0 @@
-#!/usr/bin/env bun
-
-import { describe, it, expect } from "bun:test";
-import {
-  applyBranchTemplate,
-  generateBranchName,
-} from "../src/utils/branch-template";
-
-describe("branch template utilities", () => {
-  describe("applyBranchTemplate", () => {
-    it("should replace all template variables", () => {
-      const template =
-        "{{prefix}}{{entityType}}-{{entityNumber}}-{{timestamp}}";
-      const variables = {
-        prefix: "feat/",
-        entityType: "issue",
-        entityNumber: 123,
-        timestamp: "20240301-1430",
-        sha: "abcd1234",
-      };
-
-      const result = applyBranchTemplate(template, variables);
-      expect(result).toBe("feat/issue-123-20240301-1430");
-    });
-
-    it("should handle custom templates with multiple variables", () => {
-      const template =
-        "{{prefix}}fix/{{entityType}}_{{entityNumber}}_{{timestamp}}_{{sha}}";
-      const variables = {
-        prefix: "claude-",
-        entityType: "pr",
-        entityNumber: 456,
-        timestamp: "20240301-1430",
-        sha: "abcd1234",
-      };
-
-      const result = applyBranchTemplate(template, variables);
-      expect(result).toBe("claude-fix/pr_456_20240301-1430_abcd1234");
-    });
-
-    it("should handle templates with missing variables gracefully", () => {
-      const template = "{{prefix}}{{entityType}}-{{missing}}-{{entityNumber}}";
-      const variables = {
-        prefix: "feat/",
-        entityType: "issue",
-        entityNumber: 123,
-        timestamp: "20240301-1430",
-      };
-
-      const result = applyBranchTemplate(template, variables);
-      expect(result).toBe("feat/issue-{{missing}}-123");
-    });
-  });
-
-  describe("generateBranchName", () => {
-    it("should use custom template when provided", () => {
-      const template = "{{prefix}}custom-{{entityType}}_{{entityNumber}}";
-      const result = generateBranchName(template, "feature/", "issue", 123);
-
-      expect(result).toBe("feature/custom-issue_123");
-    });
-
-    it("should use default format when template is empty", () => {
-      const result = generateBranchName("", "claude/", "issue", 123);
-
-      expect(result).toMatch(/^claude\/issue-123-\d{8}-\d{4}$/);
-    });
-
-    it("should use default format when template is undefined", () => {
-      const result = generateBranchName(undefined, "claude/", "pr", 456);
-
-      expect(result).toMatch(/^claude\/pr-456-\d{8}-\d{4}$/);
-    });
-
-    it("should preserve custom template formatting (no automatic lowercase/truncation)", () => {
-      const template = "{{prefix}}UPPERCASE_Branch-Name_{{entityNumber}}";
-      const result = generateBranchName(template, "Feature/", "issue", 123);
-
-      expect(result).toBe("Feature/UPPERCASE_Branch-Name_123");
-    });
-
-    it("should not truncate custom template results", () => {
-      const template =
-        "{{prefix}}very-long-branch-name-that-exceeds-the-maximum-allowed-length-{{entityNumber}}";
-      const result = generateBranchName(template, "feature/", "issue", 123);
-
-      expect(result).toBe(
-        "feature/very-long-branch-name-that-exceeds-the-maximum-allowed-length-123",
-      );
-    });
-
-    it("should apply Kubernetes-compatible transformations to default template only", () => {
-      const result = generateBranchName(undefined, "Feature/", "issue", 123);
-
-      expect(result).toMatch(/^feature\/issue-123-\d{8}-\d{4}$/);
-      expect(result.length).toBeLessThanOrEqual(50);
-    });
-
-    it("should handle SHA in template", () => {
-      const template = "{{prefix}}{{entityType}}-{{entityNumber}}-{{sha}}";
-      const result = generateBranchName(
-        template,
-        "fix/",
-        "pr",
-        789,
-        "abcdef123456",
-      );
-
-      expect(result).toBe("fix/pr-789-abcdef12");
-    });
-
-    it("should use label in template when provided", () => {
-      const template = "{{prefix}}{{label}}/{{entityNumber}}";
-      const result = generateBranchName(
-        template,
-        "feature/",
-        "issue",
-        123,
-        undefined,
-        "bug",
-      );
-
-      expect(result).toBe("feature/bug/123");
-    });
-
-    it("should fallback to entityType when label template is used but no label provided", () => {
-      const template = "{{prefix}}{{label}}-{{entityNumber}}";
-      const result = generateBranchName(template, "fix/", "pr", 456);
-
-      expect(result).toBe("fix/pr-456");
-    });
-
-    it("should handle template with both label and entityType", () => {
-      const template = "{{prefix}}{{label}}-{{entityType}}_{{entityNumber}}";
-      const result = generateBranchName(
-        template,
-        "dev/",
-        "issue",
-        789,
-        undefined,
-        "enhancement",
-      );
-
-      expect(result).toBe("dev/enhancement-issue_789");
-    });
-
-    it("should use description in template when provided", () => {
-      const template = "{{prefix}}{{description}}/{{entityNumber}}";
-      const result = generateBranchName(
-        template,
-        "feature/",
-        "issue",
-        123,
-        undefined,
-        undefined,
-        "Fix login bug with OAuth",
-      );
-
-      expect(result).toBe("feature/fix-login-bug-with-oauth/123");
-    });
-
-    it("should handle template with multiple variables including description", () => {
-      const template =
-        "{{prefix}}{{label}}/{{description}}-{{entityType}}_{{entityNumber}}";
-      const result = generateBranchName(
-        template,
-        "dev/",
-        "issue",
-        456,
-        undefined,
-        "bug",
-        "User authentication fails completely",
-      );
-
-      expect(result).toBe(
-        "dev/bug/user-authentication-fails-completely-issue_456",
-      );
-    });
-
-    it("should handle description with special characters in template", () => {
-      const template = "{{prefix}}{{description}}-{{entityNumber}}";
-      const result = generateBranchName(
-        template,
-        "fix/",
-        "pr",
-        789,
-        undefined,
-        undefined,
-        "Add: User Registration & Email Validation",
-      );
-
-      expect(result).toBe("fix/add-user-registration-email-789");
-    });
-
-    it("should truncate descriptions to exactly 5 words", () => {
-      const result = generateBranchName(
-        "{{prefix}}{{description}}/{{entityNumber}}",
-        "feature/",
-        "issue",
-        999,
-        undefined,
-        undefined,
-        "This is a very long title with many more than five words in it",
-      );
-      expect(result).toBe("feature/this-is-a-very-long/999");
-    });
-
-    it("should handle empty description in template", () => {
-      const template = "{{prefix}}{{description}}-{{entityNumber}}";
-      const result = generateBranchName(
-        template,
-        "test/",
-        "issue",
-        101,
-        undefined,
-        undefined,
-        "",
-      );
-
-      expect(result).toBe("test/-101");
-    });
-
-    it("should fallback to default format when template produces empty result", () => {
-      const template = "{{description}}"; // Will be empty if no title provided
-      const result = generateBranchName(template, "claude/", "issue", 123);
-
-      expect(result).toMatch(/^claude\/issue-123-\d{8}-\d{4}$/);
-      expect(result.length).toBeLessThanOrEqual(50);
-    });
-
-    it("should fallback to default format when template produces only whitespace", () => {
-      const template = "  {{description}}  "; // Will be "  " if description is empty
-      const result = generateBranchName(
-        template,
-        "fix/",
-        "pr",
-        456,
-        undefined,
-        undefined,
-        "",
-      );
-
-      expect(result).toMatch(/^fix\/pr-456-\d{8}-\d{4}$/);
-      expect(result.length).toBeLessThanOrEqual(50);
-    });
-  });
-});
--- a/test/create-prompt.test.ts
+++ b/test/create-prompt.test.ts
@ -1,34 +1,72 @@
 #!/usr/bin/env bun

-import { describe, test, expect, beforeAll } from "bun:test";
+import { describe, test, expect } from "bun:test";
 import {
  generatePrompt,
+  generateDefaultPrompt,
  getEventTypeAndContext,
  buildAllowedToolsString,
  buildDisallowedToolsString,
 } from "../src/create-prompt";
 import type { PreparedContext } from "../src/create-prompt";
-
-beforeAll(() => {
-  process.env.GITHUB_ACTION_PATH = "/test/action/path";
-});
+import type { Mode } from "../src/modes/types";

 describe("generatePrompt", () => {
+  // Create a mock tag mode that uses the default prompt
+  const mockTagMode: Mode = {
+    name: "tag",
+    description: "Tag mode",
+    shouldTrigger: () => true,
+    prepareContext: (context) => ({ mode: "tag", githubContext: context }),
+    getAllowedTools: () => [],
+    getDisallowedTools: () => [],
+    shouldCreateTrackingComment: () => true,
+    generatePrompt: (context, githubData, useCommitSigning) =>
+      generateDefaultPrompt(context, githubData, useCommitSigning),
+    prepare: async () => ({
+      commentId: 123,
+      branchInfo: {
+        baseBranch: "main",
+        currentBranch: "main",
+        claudeBranch: undefined,
+      },
+      mcpConfig: "{}",
+    }),
+  };
+
+  // Create a mock agent mode that passes through prompts
+  const mockAgentMode: Mode = {
+    name: "agent",
+    description: "Agent mode",
+    shouldTrigger: () => true,
+    prepareContext: (context) => ({ mode: "agent", githubContext: context }),
+    getAllowedTools: () => [],
+    getDisallowedTools: () => [],
+    shouldCreateTrackingComment: () => false,
+    generatePrompt: (context) => context.prompt || "",
+    prepare: async () => ({
+      commentId: undefined,
+      branchInfo: {
+        baseBranch: "main",
+        currentBranch: "main",
+        claudeBranch: undefined,
+      },
+      mcpConfig: "{}",
+    }),
+  };
+
  const mockGitHubData = {
    contextData: {
      title: "Test PR",
      body: "This is a test PR",
      author: { login: "testuser" },
      state: "OPEN",
-      labels: { nodes: [] },
      createdAt: "2023-01-01T00:00:00Z",
      additions: 15,
      deletions: 5,
      baseRefName: "main",
      headRefName: "feature-branch",
      headRefOid: "abc123",
-      isCrossRepository: false,
-      headRepository: { owner: { login: "testowner" }, name: "testrepo" },
      commits: {
        totalCount: 2,
        nodes: [
@ -140,7 +178,12 @@ describe("generatePrompt", () => {
      },
    };

-    const prompt = await generatePrompt(envVars, mockGitHubData, false, "tag");
+    const prompt = await generatePrompt(
+      envVars,
+      mockGitHubData,
+      false,
+      mockTagMode,
+    );

    expect(prompt).toContain("You are Claude, an AI assistant");
    expect(prompt).toContain("<event_type>GENERAL_COMMENT</event_type>");
@ -168,7 +211,12 @@ describe("generatePrompt", () => {
      },
    };

-    const prompt = await generatePrompt(envVars, mockGitHubData, false, "tag");
+    const prompt = await generatePrompt(
+      envVars,
+      mockGitHubData,
+      false,
+      mockTagMode,
+    );

    expect(prompt).toContain("<event_type>PR_REVIEW</event_type>");
    expect(prompt).toContain("<is_pr>true</is_pr>");
@ -194,7 +242,12 @@ describe("generatePrompt", () => {
      },
    };

-    const prompt = await generatePrompt(envVars, mockGitHubData, false, "tag");
+    const prompt = await generatePrompt(
+      envVars,
+      mockGitHubData,
+      false,
+      mockTagMode,
+    );

    expect(prompt).toContain("<event_type>ISSUE_CREATED</event_type>");
    expect(prompt).toContain(
@ -222,7 +275,12 @@ describe("generatePrompt", () => {
      },
    };

-    const prompt = await generatePrompt(envVars, mockGitHubData, false, "tag");
+    const prompt = await generatePrompt(
+      envVars,
+      mockGitHubData,
+      false,
+      mockTagMode,
+    );

    expect(prompt).toContain("<event_type>ISSUE_ASSIGNED</event_type>");
    expect(prompt).toContain(
@ -249,7 +307,12 @@ describe("generatePrompt", () => {
      },
    };

-    const prompt = await generatePrompt(envVars, mockGitHubData, false, "tag");
+    const prompt = await generatePrompt(
+      envVars,
+      mockGitHubData,
+      false,
+      mockTagMode,
+    );

    expect(prompt).toContain("<event_type>ISSUE_LABELED</event_type>");
    expect(prompt).toContain(
@ -275,7 +338,12 @@ describe("generatePrompt", () => {
      },
    };

-    const prompt = await generatePrompt(envVars, mockGitHubData, false, "tag");
+    const prompt = await generatePrompt(
+      envVars,
+      mockGitHubData,
+      false,
+      mockTagMode,
+    );

    expect(prompt).toContain("<event_type>PULL_REQUEST</event_type>");
    expect(prompt).toContain("<is_pr>true</is_pr>");
@ -299,7 +367,12 @@ describe("generatePrompt", () => {
      },
    };

-    const prompt = await generatePrompt(envVars, mockGitHubData, false, "tag");
+    const prompt = await generatePrompt(
+      envVars,
+      mockGitHubData,
+      false,
+      mockTagMode,
+    );

    // Verify prompt generates successfully without custom instructions
    expect(prompt).toContain("@claude please fix this");
@ -324,7 +397,7 @@ describe("generatePrompt", () => {
      envVars,
      mockGitHubData,
      false,
-      "agent",
+      mockAgentMode,
    );

    // Agent mode: Prompt is passed through as-is
@ -365,7 +438,7 @@ describe("generatePrompt", () => {
      envVars,
      mockGitHubData,
      false,
-      "agent",
+      mockAgentMode,
    );

    // v1.0: Variables are NOT substituted - prompt is passed as-is to Claude Code
@ -402,7 +475,6 @@ describe("generatePrompt", () => {
        body: "The login form is not working",
        author: { login: "testuser" },
        state: "OPEN",
-        labels: { nodes: [] },
        createdAt: "2023-01-01T00:00:00Z",
        comments: {
          nodes: [],
@ -414,7 +486,7 @@ describe("generatePrompt", () => {
      envVars,
      issueGitHubData,
      false,
-      "agent",
+      mockAgentMode,
    );

    // Agent mode: Prompt is passed through as-is
@ -439,7 +511,7 @@ describe("generatePrompt", () => {
      envVars,
      mockGitHubData,
      false,
-      "agent",
+      mockAgentMode,
    );

    // Agent mode: No substitution - passed as-is
@ -463,7 +535,12 @@ describe("generatePrompt", () => {
      },
    };

-    const prompt = await generatePrompt(envVars, mockGitHubData, false, "tag");
+    const prompt = await generatePrompt(
+      envVars,
+      mockGitHubData,
+      false,
+      mockTagMode,
+    );

    expect(prompt).toContain("You are Claude, an AI assistant");
    expect(prompt).toContain("<event_type>ISSUE_CREATED</event_type>");
@ -486,7 +563,12 @@ describe("generatePrompt", () => {
      },
    };

-    const prompt = await generatePrompt(envVars, mockGitHubData, false, "tag");
+    const prompt = await generatePrompt(
+      envVars,
+      mockGitHubData,
+      false,
+      mockTagMode,
+    );

    expect(prompt).toContain("<trigger_username>johndoe</trigger_username>");
    // With commit signing disabled, co-author info appears in git commit instructions
@ -508,10 +590,15 @@ describe("generatePrompt", () => {
      },
    };

-    const prompt = await generatePrompt(envVars, mockGitHubData, false, "tag");
+    const prompt = await generatePrompt(
+      envVars,
+      mockGitHubData,
+      false,
+      mockTagMode,
+    );

    // Should contain PR-specific instructions (git commands when not using signing)
-    expect(prompt).toContain("scripts/git-push.sh origin");
+    expect(prompt).toContain("git push");
    expect(prompt).toContain(
      "Always push to the existing branch when triggered on a PR",
    );
@ -539,7 +626,12 @@ describe("generatePrompt", () => {
      },
    };

-    const prompt = await generatePrompt(envVars, mockGitHubData, false, "tag");
+    const prompt = await generatePrompt(
+      envVars,
+      mockGitHubData,
+      false,
+      mockTagMode,
+    );

    // Should contain Issue-specific instructions
    expect(prompt).toContain(
@ -578,7 +670,12 @@ describe("generatePrompt", () => {
      },
    };

-    const prompt = await generatePrompt(envVars, mockGitHubData, false, "tag");
+    const prompt = await generatePrompt(
+      envVars,
+      mockGitHubData,
+      false,
+      mockTagMode,
+    );

    // Should contain the actual branch name with timestamp
    expect(prompt).toContain(
@ -608,7 +705,12 @@ describe("generatePrompt", () => {
      },
    };

-    const prompt = await generatePrompt(envVars, mockGitHubData, false, "tag");
+    const prompt = await generatePrompt(
+      envVars,
+      mockGitHubData,
+      false,
+      mockTagMode,
+    );

    // Should contain branch-specific instructions like issues
    expect(prompt).toContain(
@ -646,10 +748,15 @@ describe("generatePrompt", () => {
      },
    };

-    const prompt = await generatePrompt(envVars, mockGitHubData, false, "tag");
+    const prompt = await generatePrompt(
+      envVars,
+      mockGitHubData,
+      false,
+      mockTagMode,
+    );

    // Should contain open PR instructions (git commands when not using signing)
-    expect(prompt).toContain("scripts/git-push.sh origin");
+    expect(prompt).toContain("git push");
    expect(prompt).toContain(
      "Always push to the existing branch when triggered on a PR",
    );
@ -677,7 +784,12 @@ describe("generatePrompt", () => {
      },
    };

-    const prompt = await generatePrompt(envVars, mockGitHubData, false, "tag");
+    const prompt = await generatePrompt(
+      envVars,
+      mockGitHubData,
+      false,
+      mockTagMode,
+    );

    // Should contain new branch instructions
    expect(prompt).toContain(
@ -705,7 +817,12 @@ describe("generatePrompt", () => {
      },
    };

-    const prompt = await generatePrompt(envVars, mockGitHubData, false, "tag");
+    const prompt = await generatePrompt(
+      envVars,
+      mockGitHubData,
+      false,
+      mockTagMode,
+    );

    // Should contain new branch instructions
    expect(prompt).toContain(
@ -733,7 +850,12 @@ describe("generatePrompt", () => {
      },
    };

-    const prompt = await generatePrompt(envVars, mockGitHubData, false, "tag");
+    const prompt = await generatePrompt(
+      envVars,
+      mockGitHubData,
+      false,
+      mockTagMode,
+    );

    // Should contain new branch instructions
    expect(prompt).toContain(
@ -757,13 +879,18 @@ describe("generatePrompt", () => {
      },
    };

-    const prompt = await generatePrompt(envVars, mockGitHubData, false, "tag");
+    const prompt = await generatePrompt(
+      envVars,
+      mockGitHubData,
+      false,
+      mockTagMode,
+    );

    // Should have git command instructions
    expect(prompt).toContain("Use git commands via the Bash tool");
    expect(prompt).toContain("git add");
    expect(prompt).toContain("git commit");
-    expect(prompt).toContain("scripts/git-push.sh origin");
+    expect(prompt).toContain("git push");

    // Should use the minimal comment tool
    expect(prompt).toContain("mcp__github_comment__update_claude_comment");
@ -786,7 +913,12 @@ describe("generatePrompt", () => {
      },
    };

-    const prompt = await generatePrompt(envVars, mockGitHubData, true, "tag");
+    const prompt = await generatePrompt(
+      envVars,
+      mockGitHubData,
+      true,
+      mockTagMode,
+    );

    // Should have commit signing tool instructions
    expect(prompt).toContain("mcp__github_file_ops__commit_files");
@ -892,18 +1024,17 @@ describe("buildAllowedToolsString", () => {
    const result = buildAllowedToolsString();

    // The base tools should be in the result
-    // Edit/MultiEdit/Write are NOT in allowedTools — acceptEdits permission mode handles them
-    expect(result).not.toContain("Edit");
-    expect(result).not.toContain("Write");
+    expect(result).toContain("Edit");
    expect(result).toContain("Glob");
    expect(result).toContain("Grep");
    expect(result).toContain("LS");
    expect(result).toContain("Read");
+    expect(result).toContain("Write");

    // Default is no commit signing, so should have specific Bash git commands
    expect(result).toContain("Bash(git add:*)");
    expect(result).toContain("Bash(git commit:*)");
-    expect(result).toContain("scripts/git-push.sh:*)");
+    expect(result).toContain("Bash(git push:*)");
    expect(result).toContain("mcp__github_comment__update_claude_comment");

    // Should not have commit signing tools
@ -915,12 +1046,12 @@ describe("buildAllowedToolsString", () => {
    const result = buildAllowedToolsString([], false, false);

    // The base tools should be in the result
-    expect(result).not.toContain("Edit");
+    expect(result).toContain("Edit");
    expect(result).toContain("Glob");
    expect(result).toContain("Grep");
    expect(result).toContain("LS");
    expect(result).toContain("Read");
-    expect(result).not.toContain("Write");
+    expect(result).toContain("Write");

    // Should have specific Bash git commands for non-signing mode
    expect(result).toContain("Bash(git add:*)");
@ -937,7 +1068,7 @@ describe("buildAllowedToolsString", () => {
    const result = buildAllowedToolsString(customTools);

    // Base tools should be present
-    expect(result).toContain("Read");
+    expect(result).toContain("Edit");
    expect(result).toContain("Glob");

    // Custom tools should be appended
@ -957,7 +1088,7 @@ describe("buildAllowedToolsString", () => {
    const result = buildAllowedToolsString([], true);

    // Base tools should be present
-    expect(result).toContain("Read");
+    expect(result).toContain("Edit");
    expect(result).toContain("Glob");

    // GitHub Actions tools should be included
@ -971,7 +1102,7 @@ describe("buildAllowedToolsString", () => {
    const result = buildAllowedToolsString(customTools, true);

    // Base tools should be present
-    expect(result).toContain("Read");
+    expect(result).toContain("Edit");

    // Custom tools should be included
    expect(result).toContain("Tool1");
@ -987,12 +1118,12 @@ describe("buildAllowedToolsString", () => {
    const result = buildAllowedToolsString([], false, true);

    // Base tools should be present
-    expect(result).not.toContain("Edit");
+    expect(result).toContain("Edit");
    expect(result).toContain("Glob");
    expect(result).toContain("Grep");
    expect(result).toContain("LS");
    expect(result).toContain("Read");
-    expect(result).not.toContain("Write");
+    expect(result).toContain("Write");

    // Commit signing tools should be included
    expect(result).toContain("mcp__github_file_ops__commit_files");
@ -1008,17 +1139,20 @@ describe("buildAllowedToolsString", () => {
    const result = buildAllowedToolsString([], false, false);

    // Base tools should be present
-    expect(result).not.toContain("Edit");
+    expect(result).toContain("Edit");
    expect(result).toContain("Glob");
    expect(result).toContain("Grep");
    expect(result).toContain("LS");
    expect(result).toContain("Read");
-    expect(result).not.toContain("Write");
+    expect(result).toContain("Write");

    // Specific Bash git commands should be included
    expect(result).toContain("Bash(git add:*)");
    expect(result).toContain("Bash(git commit:*)");
-    expect(result).toContain("scripts/git-push.sh:*)");
+    expect(result).toContain("Bash(git push:*)");
+    expect(result).toContain("Bash(git status:*)");
+    expect(result).toContain("Bash(git diff:*)");
+    expect(result).toContain("Bash(git log:*)");
    expect(result).toContain("Bash(git rm:*)");

    // Comment tool from minimal server should be included
@ -1034,7 +1168,7 @@ describe("buildAllowedToolsString", () => {
    const result = buildAllowedToolsString(customTools, true, false);

    // Base tools should be present
-    expect(result).toContain("Read");
+    expect(result).toContain("Edit");
    expect(result).toContain("Bash(git add:*)");

    // Custom tools should be included
--- a/test/data-fetcher.test.ts
+++ b/test/data-fetcher.test.ts
@ -1,8 +1,6 @@
-import { describe, expect, it, jest, test } from "bun:test";
+import { describe, expect, it, jest } from "bun:test";
 import {
  extractTriggerTimestamp,
-  extractOriginalTitle,
-  extractOriginalBody,
  fetchGitHubData,
  filterCommentsToTriggerTime,
  filterReviewsToTriggerTime,
@ -11,7 +9,6 @@ import {
 import {
  createMockContext,
  mockIssueCommentContext,
-  mockPullRequestCommentContext,
  mockPullRequestReviewContext,
  mockPullRequestReviewCommentContext,
  mockPullRequestOpenedContext,
@ -66,96 +63,6 @@ describe("extractTriggerTimestamp", () => {
  });
 });

-describe("extractOriginalTitle", () => {
-  it("should extract title from IssueCommentEvent on PR", () => {
-    const title = extractOriginalTitle(mockPullRequestCommentContext);
-    expect(title).toBe("Fix: Memory leak in user service");
-  });
-
-  it("should extract title from PullRequestReviewEvent", () => {
-    const title = extractOriginalTitle(mockPullRequestReviewContext);
-    expect(title).toBe("Refactor: Improve error handling in API layer");
-  });
-
-  it("should extract title from PullRequestReviewCommentEvent", () => {
-    const title = extractOriginalTitle(mockPullRequestReviewCommentContext);
-    expect(title).toBe("Performance: Optimize search algorithm");
-  });
-
-  it("should extract title from pull_request event", () => {
-    const title = extractOriginalTitle(mockPullRequestOpenedContext);
-    expect(title).toBe("Feature: Add user authentication");
-  });
-
-  it("should extract title from issues event", () => {
-    const title = extractOriginalTitle(mockIssueOpenedContext);
-    expect(title).toBe("Bug: Application crashes on startup");
-  });
-
-  it("should return undefined for event without title", () => {
-    const context = createMockContext({
-      eventName: "issue_comment",
-      payload: {
-        comment: {
-          id: 123,
-          body: "test",
-        },
-      } as any,
-    });
-    const title = extractOriginalTitle(context);
-    expect(title).toBeUndefined();
-  });
-});
-
-describe("extractOriginalBody", () => {
-  it("should extract body from IssueCommentEvent on PR", () => {
-    const body = extractOriginalBody(mockPullRequestCommentContext);
-    expect(body).toBe("This PR fixes the memory leak issue reported in #788");
-  });
-
-  it("should extract body from PullRequestReviewEvent", () => {
-    const body = extractOriginalBody(mockPullRequestReviewContext);
-    expect(body).toBe(
-      "This PR improves error handling across all API endpoints",
-    );
-  });
-
-  it("should extract body from PullRequestReviewCommentEvent", () => {
-    const body = extractOriginalBody(mockPullRequestReviewCommentContext);
-    expect(body).toBe(
-      "This PR optimizes the search algorithm for better performance",
-    );
-  });
-
-  it("should extract body from pull_request event", () => {
-    const body = extractOriginalBody(mockPullRequestOpenedContext);
-    expect(body).toBe(
-      "## Summary\n\nThis PR adds JWT-based authentication to the API.\n\n## Changes\n\n- Added auth middleware\n- Added login endpoint\n- Added JWT token generation\n\n/claude please review the security aspects",
-    );
-  });
-
-  it("should extract body from issues event", () => {
-    const body = extractOriginalBody(mockIssueOpenedContext);
-    expect(body).toBe(
-      "## Description\n\nThe application crashes immediately after launching.\n\n## Steps to reproduce\n\n1. Install the app\n2. Launch it\n3. See crash\n\n/claude please help me fix this",
-    );
-  });
-
-  it("should return undefined for event without body", () => {
-    const context = createMockContext({
-      eventName: "issue_comment",
-      payload: {
-        comment: {
-          id: 123,
-          body: "test",
-        },
-      } as any,
-    });
-    const body = extractOriginalBody(context);
-    expect(body).toBeUndefined();
-  });
-});
-
 describe("filterCommentsToTriggerTime", () => {
  const createMockComment = (
    createdAt: string,
@ -1006,8 +913,6 @@ describe("fetchGitHubData integration with time filtering", () => {
            baseRefName: "main",
            headRefName: "feature",
            headRefOid: "abc123",
-            isCrossRepository: false,
-            headRepository: { owner: { login: "testowner" }, name: "testrepo" },
            createdAt: "2024-01-15T10:00:00Z",
            updatedAt: "2024-01-15T12:30:00Z", // Edited after trigger
            lastEditedAt: "2024-01-15T12:30:00Z", // Edited after trigger
@ -1040,393 +945,4 @@ describe("fetchGitHubData integration with time filtering", () => {
    );
    expect(hasPrBodyInMap).toBe(false);
  });
-
-  it("should use originalTitle when provided instead of fetched title", async () => {
-    const mockOctokits = {
-      graphql: jest.fn().mockResolvedValue({
-        repository: {
-          pullRequest: {
-            number: 123,
-            title: "Fetched Title From GraphQL",
-            body: "PR body",
-            author: { login: "author" },
-            createdAt: "2024-01-15T10:00:00Z",
-            additions: 10,
-            deletions: 5,
-            state: "OPEN",
-            commits: { totalCount: 1, nodes: [] },
-            files: { nodes: [] },
-            comments: { nodes: [] },
-            reviews: { nodes: [] },
-          },
-        },
-        user: { login: "trigger-user" },
-      }),
-      rest: jest.fn() as any,
-    };
-
-    const result = await fetchGitHubData({
-      octokits: mockOctokits as any,
-      repository: "test-owner/test-repo",
-      prNumber: "123",
-      isPR: true,
-      triggerUsername: "trigger-user",
-      originalTitle: "Original Title From Webhook",
-    });
-
-    expect(result.contextData.title).toBe("Original Title From Webhook");
-  });
-
-  it("should use fetched title when originalTitle is not provided", async () => {
-    const mockOctokits = {
-      graphql: jest.fn().mockResolvedValue({
-        repository: {
-          pullRequest: {
-            number: 123,
-            title: "Fetched Title From GraphQL",
-            body: "PR body",
-            author: { login: "author" },
-            createdAt: "2024-01-15T10:00:00Z",
-            additions: 10,
-            deletions: 5,
-            state: "OPEN",
-            commits: { totalCount: 1, nodes: [] },
-            files: { nodes: [] },
-            comments: { nodes: [] },
-            reviews: { nodes: [] },
-          },
-        },
-        user: { login: "trigger-user" },
-      }),
-      rest: jest.fn() as any,
-    };
-
-    const result = await fetchGitHubData({
-      octokits: mockOctokits as any,
-      repository: "test-owner/test-repo",
-      prNumber: "123",
-      isPR: true,
-      triggerUsername: "trigger-user",
-    });
-
-    expect(result.contextData.title).toBe("Fetched Title From GraphQL");
-  });
-
-  it("should use original title from webhook even if title was edited after trigger", async () => {
-    const mockOctokits = {
-      graphql: jest.fn().mockResolvedValue({
-        repository: {
-          pullRequest: {
-            number: 123,
-            title: "Edited Title (from GraphQL)",
-            body: "PR body",
-            author: { login: "author" },
-            createdAt: "2024-01-15T10:00:00Z",
-            lastEditedAt: "2024-01-15T12:30:00Z", // Edited after trigger
-            additions: 10,
-            deletions: 5,
-            state: "OPEN",
-            commits: { totalCount: 1, nodes: [] },
-            files: { nodes: [] },
-            comments: { nodes: [] },
-            reviews: { nodes: [] },
-          },
-        },
-        user: { login: "trigger-user" },
-      }),
-      rest: jest.fn() as any,
-    };
-
-    const result = await fetchGitHubData({
-      octokits: mockOctokits as any,
-      repository: "test-owner/test-repo",
-      prNumber: "123",
-      isPR: true,
-      triggerUsername: "trigger-user",
-      triggerTime: "2024-01-15T12:00:00Z",
-      originalTitle: "Original Title (from webhook at trigger time)",
-    });
-
-    expect(result.contextData.title).toBe(
-      "Original Title (from webhook at trigger time)",
-    );
-  });
-
-  it("should use originalBody when provided instead of fetched body", async () => {
-    const mockOctokits = {
-      graphql: jest.fn().mockResolvedValue({
-        repository: {
-          pullRequest: {
-            number: 123,
-            title: "Test PR",
-            body: "Malicious body injected after trigger",
-            author: { login: "author" },
-            createdAt: "2024-01-15T10:00:00Z",
-            additions: 10,
-            deletions: 5,
-            state: "OPEN",
-            commits: { totalCount: 1, nodes: [] },
-            files: { nodes: [] },
-            comments: { nodes: [] },
-            reviews: { nodes: [] },
-          },
-        },
-        user: { login: "trigger-user" },
-      }),
-      rest: jest.fn() as any,
-    };
-
-    const result = await fetchGitHubData({
-      octokits: mockOctokits as any,
-      repository: "test-owner/test-repo",
-      prNumber: "123",
-      isPR: true,
-      triggerUsername: "trigger-user",
-      originalBody: "Original safe body from webhook",
-    });
-
-    expect(result.contextData.body).toBe("Original safe body from webhook");
-  });
-
-  it("should use fetched body when originalBody is not provided", async () => {
-    const mockOctokits = {
-      graphql: jest.fn().mockResolvedValue({
-        repository: {
-          pullRequest: {
-            number: 123,
-            title: "Test PR",
-            body: "Fetched body from GraphQL",
-            author: { login: "author" },
-            createdAt: "2024-01-15T10:00:00Z",
-            additions: 10,
-            deletions: 5,
-            state: "OPEN",
-            commits: { totalCount: 1, nodes: [] },
-            files: { nodes: [] },
-            comments: { nodes: [] },
-            reviews: { nodes: [] },
-          },
-        },
-        user: { login: "trigger-user" },
-      }),
-      rest: jest.fn() as any,
-    };
-
-    const result = await fetchGitHubData({
-      octokits: mockOctokits as any,
-      repository: "test-owner/test-repo",
-      prNumber: "123",
-      isPR: true,
-      triggerUsername: "trigger-user",
-    });
-
-    expect(result.contextData.body).toBe("Fetched body from GraphQL");
-  });
-
-  it("should use original body from webhook even if body was edited after trigger (TOCTOU prevention)", async () => {
-    const mockOctokits = {
-      graphql: jest.fn().mockResolvedValue({
-        repository: {
-          pullRequest: {
-            number: 123,
-            title: "Test PR",
-            body: "Malicious body (edited after trigger via GraphQL)",
-            author: { login: "author" },
-            createdAt: "2024-01-15T10:00:00Z",
-            lastEditedAt: "2024-01-15T12:30:00Z", // Edited after trigger
-            additions: 10,
-            deletions: 5,
-            state: "OPEN",
-            commits: { totalCount: 1, nodes: [] },
-            files: { nodes: [] },
-            comments: { nodes: [] },
-            reviews: { nodes: [] },
-          },
-        },
-        user: { login: "trigger-user" },
-      }),
-      rest: jest.fn() as any,
-    };
-
-    const result = await fetchGitHubData({
-      octokits: mockOctokits as any,
-      repository: "test-owner/test-repo",
-      prNumber: "123",
-      isPR: true,
-      triggerUsername: "trigger-user",
-      triggerTime: "2024-01-15T12:00:00Z",
-      originalBody: "Original safe body (from webhook at trigger time)",
-    });
-
-    // Body should be from webhook, not the malicious GraphQL-fetched version
-    expect(result.contextData.body).toBe(
-      "Original safe body (from webhook at trigger time)",
-    );
-  });
-
-  it("should handle null originalBody by setting body to empty string", async () => {
-    const mockOctokits = {
-      graphql: jest.fn().mockResolvedValue({
-        repository: {
-          issue: {
-            number: 123,
-            title: "Test Issue",
-            body: "Some body from GraphQL",
-            author: { login: "author" },
-            createdAt: "2024-01-15T10:00:00Z",
-            state: "OPEN",
-            labels: { nodes: [] },
-            comments: { nodes: [] },
-          },
-        },
-        user: { login: "trigger-user" },
-      }),
-      rest: jest.fn() as any,
-    };
-
-    const result = await fetchGitHubData({
-      octokits: mockOctokits as any,
-      repository: "test-owner/test-repo",
-      prNumber: "123",
-      isPR: false,
-      triggerUsername: "trigger-user",
-      originalBody: null,
-    });
-
-    // null originalBody means the issue had no body at trigger time
-    expect(result.contextData.body).toBe("");
-  });
-
-  it("should use null originalBody over malicious GraphQL body edited after trigger", async () => {
-    const mockOctokits = {
-      graphql: jest.fn().mockResolvedValue({
-        repository: {
-          issue: {
-            number: 123,
-            title: "Test Issue",
-            body: "Malicious body added after trigger",
-            author: { login: "author" },
-            createdAt: "2024-01-15T10:00:00Z",
-            lastEditedAt: "2024-01-15T12:30:00Z", // Edited after trigger
-            state: "OPEN",
-            labels: { nodes: [] },
-            comments: { nodes: [] },
-          },
-        },
-        user: { login: "trigger-user" },
-      }),
-      rest: jest.fn() as any,
-    };
-
-    const result = await fetchGitHubData({
-      octokits: mockOctokits as any,
-      repository: "test-owner/test-repo",
-      prNumber: "123",
-      isPR: false,
-      triggerUsername: "trigger-user",
-      triggerTime: "2024-01-15T12:00:00Z",
-      originalBody: null,
-    });
-
-    // Webhook says no body at trigger time — attacker-added GraphQL body must not be used
-    expect(result.contextData.body).toBe("");
-  });
-});
-
-describe("filterCommentsByActor", () => {
-  test("filters out excluded actors", () => {
-    const comments = [
-      { author: { login: "user1" }, body: "comment1" },
-      { author: { login: "bot[bot]" }, body: "comment2" },
-      { author: { login: "user2" }, body: "comment3" },
-    ];
-
-    const { filterCommentsByActor } = require("../src/github/data/fetcher");
-    const filtered = filterCommentsByActor(comments, "", "*[bot]");
-    expect(filtered).toHaveLength(2);
-    expect(filtered.map((c: any) => c.author.login)).toEqual([
-      "user1",
-      "user2",
-    ]);
-  });
-
-  test("includes only specified actors", () => {
-    const comments = [
-      { author: { login: "user1" }, body: "comment1" },
-      { author: { login: "user2" }, body: "comment2" },
-      { author: { login: "user3" }, body: "comment3" },
-    ];
-
-    const { filterCommentsByActor } = require("../src/github/data/fetcher");
-    const filtered = filterCommentsByActor(comments, "user1,user2", "");
-    expect(filtered).toHaveLength(2);
-    expect(filtered.map((c: any) => c.author.login)).toEqual([
-      "user1",
-      "user2",
-    ]);
-  });
-
-  test("returns all when no filters", () => {
-    const comments = [
-      { author: { login: "user1" }, body: "comment1" },
-      { author: { login: "user2" }, body: "comment2" },
-    ];
-
-    const { filterCommentsByActor } = require("../src/github/data/fetcher");
-    const filtered = filterCommentsByActor(comments, "", "");
-    expect(filtered).toHaveLength(2);
-  });
-
-  test("exclusion takes priority", () => {
-    const comments = [
-      { author: { login: "user1" }, body: "comment1" },
-      { author: { login: "user2" }, body: "comment2" },
-    ];
-
-    const { filterCommentsByActor } = require("../src/github/data/fetcher");
-    const filtered = filterCommentsByActor(comments, "user1,user2", "user1");
-    expect(filtered).toHaveLength(1);
-    expect(filtered[0].author.login).toBe("user2");
-  });
-
-  test("filters multiple bot types", () => {
-    const comments = [
-      { author: { login: "user1" }, body: "comment1" },
-      { author: { login: "dependabot[bot]" }, body: "comment2" },
-      { author: { login: "renovate[bot]" }, body: "comment3" },
-      { author: { login: "user2" }, body: "comment4" },
-    ];
-
-    const { filterCommentsByActor } = require("../src/github/data/fetcher");
-    const filtered = filterCommentsByActor(comments, "", "*[bot]");
-    expect(filtered).toHaveLength(2);
-    expect(filtered.map((c: any) => c.author.login)).toEqual([
-      "user1",
-      "user2",
-    ]);
-  });
-
-  test("filters specific bot only", () => {
-    const comments = [
-      { author: { login: "dependabot[bot]" }, body: "comment1" },
-      { author: { login: "renovate[bot]" }, body: "comment2" },
-      { author: { login: "user1" }, body: "comment3" },
-    ];
-
-    const { filterCommentsByActor } = require("../src/github/data/fetcher");
-    const filtered = filterCommentsByActor(comments, "", "dependabot[bot]");
-    expect(filtered).toHaveLength(2);
-    expect(filtered.map((c: any) => c.author.login)).toEqual([
-      "renovate[bot]",
-      "user1",
-    ]);
-  });
-
-  test("handles empty comment array", () => {
-    const comments: any[] = [];
-
-    const { filterCommentsByActor } = require("../src/github/data/fetcher");
-    const filtered = filterCommentsByActor(comments, "user1", "");
-    expect(filtered).toHaveLength(0);
-  });
 });
--- a/test/data-formatter.test.ts
+++ b/test/data-formatter.test.ts
@ -24,15 +24,10 @@ describe("formatContext", () => {
      baseRefName: "main",
      headRefName: "feature/test",
      headRefOid: "abc123",
-      isCrossRepository: false,
-      headRepository: { owner: { login: "testowner" }, name: "testrepo" },
      createdAt: "2023-01-01T00:00:00Z",
      additions: 50,
      deletions: 30,
      state: "OPEN",
-      labels: {
-        nodes: [],
-      },
      commits: {
        totalCount: 3,
        nodes: [],
@ -68,9 +63,6 @@ Changed Files: 2 files`,
      author: { login: "test-user" },
      createdAt: "2023-01-01T00:00:00Z",
      state: "OPEN",
-      labels: {
-        nodes: [],
-      },
      comments: {
        nodes: [],
      },
--- a/test/extract-user-request.test.ts
+++ b/test/extract-user-request.test.ts
@ -1,77 +0,0 @@
-import { describe, test, expect } from "bun:test";
-import { extractUserRequest } from "../src/utils/extract-user-request";
-
-describe("extractUserRequest", () => {
-  test("extracts text after @claude trigger", () => {
-    expect(extractUserRequest("@claude /review-pr", "@claude")).toBe(
-      "/review-pr",
-    );
-  });
-
-  test("extracts slash command with arguments", () => {
-    expect(
-      extractUserRequest(
-        "@claude /review-pr please check the auth module",
-        "@claude",
-      ),
-    ).toBe("/review-pr please check the auth module");
-  });
-
-  test("handles trigger phrase with extra whitespace", () => {
-    expect(extractUserRequest("@claude    /review-pr", "@claude")).toBe(
-      "/review-pr",
-    );
-  });
-
-  test("handles trigger phrase at start of multiline comment", () => {
-    const comment = `@claude /review-pr
-Please review this PR carefully.
-Focus on security issues.`;
-    expect(extractUserRequest(comment, "@claude")).toBe(
-      `/review-pr
-Please review this PR carefully.
-Focus on security issues.`,
-    );
-  });
-
-  test("handles trigger phrase in middle of text", () => {
-    expect(
-      extractUserRequest("Hey team, @claude can you review this?", "@claude"),
-    ).toBe("can you review this?");
-  });
-
-  test("returns null for empty comment body", () => {
-    expect(extractUserRequest("", "@claude")).toBeNull();
-  });
-
-  test("returns null for undefined comment body", () => {
-    expect(extractUserRequest(undefined, "@claude")).toBeNull();
-  });
-
-  test("returns null when trigger phrase not found", () => {
-    expect(extractUserRequest("Please review this PR", "@claude")).toBeNull();
-  });
-
-  test("returns null when only trigger phrase with no request", () => {
-    expect(extractUserRequest("@claude", "@claude")).toBeNull();
-  });
-
-  test("handles custom trigger phrase", () => {
-    expect(extractUserRequest("/claude help me", "/claude")).toBe("help me");
-  });
-
-  test("handles trigger phrase with special regex characters", () => {
-    expect(
-      extractUserRequest("@claude[bot] do something", "@claude[bot]"),
-    ).toBe("do something");
-  });
-
-  test("is case insensitive", () => {
-    expect(extractUserRequest("@CLAUDE /review-pr", "@claude")).toBe(
-      "/review-pr",
-    );
-    expect(extractUserRequest("@Claude /review-pr", "@claude")).toBe(
-      "/review-pr",
-    );
-  });
-});
--- a/test/github-file-ops-path-validation.test.ts
+++ b/test/github-file-ops-path-validation.test.ts
@ -1,214 +0,0 @@
-import { describe, expect, it, beforeAll, afterAll } from "bun:test";
-import { validatePathWithinRepo } from "../src/mcp/path-validation";
-import { resolve } from "path";
-import { mkdir, writeFile, symlink, rm, realpath } from "fs/promises";
-import { tmpdir } from "os";
-
-describe("validatePathWithinRepo", () => {
-  // Use a real temp directory for tests that need filesystem access
-  let testDir: string;
-  let repoRoot: string;
-  let outsideDir: string;
-  // Real paths after symlink resolution (e.g., /tmp -> /private/tmp on macOS)
-  let realRepoRoot: string;
-
-  beforeAll(async () => {
-    // Create test directory structure
-    testDir = resolve(tmpdir(), `path-validation-test-${Date.now()}`);
-    repoRoot = resolve(testDir, "repo");
-    outsideDir = resolve(testDir, "outside");
-
-    await mkdir(repoRoot, { recursive: true });
-    await mkdir(resolve(repoRoot, "src"), { recursive: true });
-    await mkdir(outsideDir, { recursive: true });
-
-    // Create test files
-    await writeFile(resolve(repoRoot, "file.txt"), "inside repo");
-    await writeFile(resolve(repoRoot, "src", "main.js"), "console.log('hi')");
-    await writeFile(resolve(outsideDir, "secret.txt"), "sensitive data");
-
-    // Get real paths after symlink resolution
-    realRepoRoot = await realpath(repoRoot);
-  });
-
-  afterAll(async () => {
-    // Cleanup
-    await rm(testDir, { recursive: true, force: true });
-  });
-
-  describe("valid paths", () => {
-    it("should accept simple relative paths", async () => {
-      const result = await validatePathWithinRepo("file.txt", repoRoot);
-      expect(result).toBe(resolve(realRepoRoot, "file.txt"));
-    });
-
-    it("should accept nested relative paths", async () => {
-      const result = await validatePathWithinRepo("src/main.js", repoRoot);
-      expect(result).toBe(resolve(realRepoRoot, "src/main.js"));
-    });
-
-    it("should accept paths with single dot segments", async () => {
-      const result = await validatePathWithinRepo("./src/main.js", repoRoot);
-      expect(result).toBe(resolve(realRepoRoot, "src/main.js"));
-    });
-
-    it("should accept paths that use .. but resolve inside repo", async () => {
-      // src/../file.txt resolves to file.txt which is still inside repo
-      const result = await validatePathWithinRepo("src/../file.txt", repoRoot);
-      expect(result).toBe(resolve(realRepoRoot, "file.txt"));
-    });
-
-    it("should accept absolute paths within the repo root", async () => {
-      const absolutePath = resolve(repoRoot, "file.txt");
-      const result = await validatePathWithinRepo(absolutePath, repoRoot);
-      expect(result).toBe(resolve(realRepoRoot, "file.txt"));
-    });
-
-    it("should accept the repo root itself", async () => {
-      const result = await validatePathWithinRepo(".", repoRoot);
-      expect(result).toBe(realRepoRoot);
-    });
-
-    it("should handle new files (non-existent) in valid directories", async () => {
-      const result = await validatePathWithinRepo("src/newfile.js", repoRoot);
-      // For non-existent files, we validate the parent but return the initial path
-      // (can't realpath a file that doesn't exist yet)
-      expect(result).toBe(resolve(repoRoot, "src/newfile.js"));
-    });
-  });
-
-  describe("path traversal attacks", () => {
-    it("should reject simple parent directory traversal", async () => {
-      await expect(
-        validatePathWithinRepo("../outside/secret.txt", repoRoot),
-      ).rejects.toThrow(/resolves outside the repository root/);
-    });
-
-    it("should reject deeply nested parent directory traversal", async () => {
-      await expect(
-        validatePathWithinRepo("../../../etc/passwd", repoRoot),
-      ).rejects.toThrow(/resolves outside the repository root/);
-    });
-
-    it("should reject traversal hidden within path", async () => {
-      await expect(
-        validatePathWithinRepo("src/../../outside/secret.txt", repoRoot),
-      ).rejects.toThrow(/resolves outside the repository root/);
-    });
-
-    it("should reject traversal at the end of path", async () => {
-      await expect(
-        validatePathWithinRepo("src/../..", repoRoot),
-      ).rejects.toThrow(/resolves outside the repository root/);
-    });
-
-    it("should reject absolute paths outside the repo root", async () => {
-      await expect(
-        validatePathWithinRepo("/etc/passwd", repoRoot),
-      ).rejects.toThrow(/resolves outside the repository root/);
-    });
-
-    it("should reject absolute paths to sibling directories", async () => {
-      await expect(
-        validatePathWithinRepo(resolve(outsideDir, "secret.txt"), repoRoot),
-      ).rejects.toThrow(/resolves outside the repository root/);
-    });
-  });
-
-  describe("symlink attacks", () => {
-    it("should reject symlinks pointing outside the repo", async () => {
-      // Create a symlink inside the repo that points to a file outside
-      const symlinkPath = resolve(repoRoot, "evil-link");
-      await symlink(resolve(outsideDir, "secret.txt"), symlinkPath);
-
-      try {
-        // The symlink path looks like it's inside the repo, but points outside
-        await expect(
-          validatePathWithinRepo("evil-link", repoRoot),
-        ).rejects.toThrow(/resolves outside the repository root/);
-      } finally {
-        await rm(symlinkPath, { force: true });
-      }
-    });
-
-    it("should reject symlinks to parent directories", async () => {
-      // Create a symlink to the parent directory
-      const symlinkPath = resolve(repoRoot, "parent-link");
-      await symlink(testDir, symlinkPath);
-
-      try {
-        await expect(
-          validatePathWithinRepo("parent-link/outside/secret.txt", repoRoot),
-        ).rejects.toThrow(/resolves outside the repository root/);
-      } finally {
-        await rm(symlinkPath, { force: true });
-      }
-    });
-
-    it("should accept symlinks that resolve within the repo", async () => {
-      // Create a symlink inside the repo that points to another file inside
-      const symlinkPath = resolve(repoRoot, "good-link");
-      await symlink(resolve(repoRoot, "file.txt"), symlinkPath);
-
-      try {
-        const result = await validatePathWithinRepo("good-link", repoRoot);
-        // Should resolve to the actual file location
-        expect(result).toBe(resolve(realRepoRoot, "file.txt"));
-      } finally {
-        await rm(symlinkPath, { force: true });
-      }
-    });
-
-    it("should reject directory symlinks that escape the repo", async () => {
-      // Create a symlink to outside directory
-      const symlinkPath = resolve(repoRoot, "escape-dir");
-      await symlink(outsideDir, symlinkPath);
-
-      try {
-        await expect(
-          validatePathWithinRepo("escape-dir/secret.txt", repoRoot),
-        ).rejects.toThrow(/resolves outside the repository root/);
-      } finally {
-        await rm(symlinkPath, { force: true });
-      }
-    });
-  });
-
-  describe("edge cases", () => {
-    it("should handle empty path (current directory)", async () => {
-      const result = await validatePathWithinRepo("", repoRoot);
-      expect(result).toBe(realRepoRoot);
-    });
-
-    it("should handle paths with multiple consecutive slashes", async () => {
-      const result = await validatePathWithinRepo("src//main.js", repoRoot);
-      expect(result).toBe(resolve(realRepoRoot, "src/main.js"));
-    });
-
-    it("should handle paths with trailing slashes", async () => {
-      const result = await validatePathWithinRepo("src/", repoRoot);
-      expect(result).toBe(resolve(realRepoRoot, "src"));
-    });
-
-    it("should reject prefix attack (repo root as prefix but not parent)", async () => {
-      // Create a sibling directory with repo name as prefix
-      const evilDir = repoRoot + "-evil";
-      await mkdir(evilDir, { recursive: true });
-      await writeFile(resolve(evilDir, "file.txt"), "evil");
-
-      try {
-        await expect(
-          validatePathWithinRepo(resolve(evilDir, "file.txt"), repoRoot),
-        ).rejects.toThrow(/resolves outside the repository root/);
-      } finally {
-        await rm(evilDir, { recursive: true, force: true });
-      }
-    });
-
-    it("should throw error for non-existent repo root", async () => {
-      await expect(
-        validatePathWithinRepo("file.txt", "/nonexistent/repo"),
-      ).rejects.toThrow(/does not exist/);
-    });
-  });
-});
--- a/test/install-mcp-server.test.ts
+++ b/test/install-mcp-server.test.ts
@ -9,7 +9,6 @@ describe("prepareMcpConfig", () => {
  let consoleWarningSpy: any;
  let setFailedSpy: any;
  let processExitSpy: any;
-  let fetchSpy: any;

  // Create a mock context for tests
  const mockContext: ParsedGitHubContext = {
@ -32,17 +31,12 @@ describe("prepareMcpConfig", () => {
      labelTrigger: "",
      branchPrefix: "",
      useStickyComment: false,
-      classifyInlineComments: true,
      useCommitSigning: false,
-      sshSigningKey: "",
      botId: String(CLAUDE_APP_BOT_ID),
      botName: CLAUDE_BOT_LOGIN,
      allowedBots: "",
      allowedNonWriteUsers: "",
      trackProgress: false,
-      includeFixLinks: true,
-      includeCommentsByActor: "",
-      excludeCommentsByActor: "",
    },
  };

@ -68,10 +62,6 @@ describe("prepareMcpConfig", () => {
    processExitSpy = spyOn(process, "exit").mockImplementation(() => {
      throw new Error("Process exit");
    });
-    // Mock fetch so checkActionsReadPermission succeeds (returns 200 for actions API)
-    fetchSpy = spyOn(global, "fetch").mockResolvedValue(
-      new Response(JSON.stringify({ workflow_runs: [] }), { status: 200 }),
-    );

    // Set up required environment variables
    if (!process.env.GITHUB_ACTION_PATH) {
@ -84,7 +74,6 @@ describe("prepareMcpConfig", () => {
    consoleWarningSpy.mockRestore();
    setFailedSpy.mockRestore();
    processExitSpy.mockRestore();
-    fetchSpy.mockRestore();
  });

  test("should return comment server when commit signing is disabled", async () => {
@ -270,33 +259,6 @@ describe("prepareMcpConfig", () => {
    expect(parsed.mcpServers.github_ci).not.toBeDefined();
  });

-  test("should not include github_ci server when actions:read permission is missing", async () => {
-    process.env.DEFAULT_WORKFLOW_TOKEN = "workflow-token";
-    // Simulate 403 from actions API
-    fetchSpy.mockResolvedValue(
-      new Response(
-        JSON.stringify({ message: "Resource not accessible by integration" }),
-        { status: 403 },
-      ),
-    );
-
-    const result = await prepareMcpConfig({
-      githubToken: "test-token",
-      owner: "test-owner",
-      repo: "test-repo",
-      branch: "test-branch",
-      baseBranch: "main",
-      allowedTools: [],
-      mode: "tag",
-      context: mockPRContext,
-    });
-
-    const parsed = JSON.parse(result);
-    expect(parsed.mcpServers.github_ci).not.toBeDefined();
-
-    delete process.env.DEFAULT_WORKFLOW_TOKEN;
-  });
-
  test("should not include github_ci server when DEFAULT_WORKFLOW_TOKEN is missing", async () => {
    delete process.env.DEFAULT_WORKFLOW_TOKEN;

--- a/test/mockContext.ts
+++ b/test/mockContext.ts
@ -19,24 +19,18 @@ const defaultInputs = {
  labelTrigger: "",
  branchPrefix: "claude/",
  useStickyComment: false,
-  classifyInlineComments: true,
  useCommitSigning: false,
-  sshSigningKey: "",
  botId: String(CLAUDE_APP_BOT_ID),
  botName: CLAUDE_BOT_LOGIN,
  allowedBots: "",
  allowedNonWriteUsers: "",
  trackProgress: false,
-  includeFixLinks: true,
-  includeCommentsByActor: "",
-  excludeCommentsByActor: "",
 };

 const defaultRepository = {
  owner: "test-owner",
  repo: "test-repo",
  full_name: "test-owner/test-repo",
-  default_branch: "main",
 };

 type MockContextOverrides = Omit<Partial<ParsedGitHubContext>, "inputs"> & {
@ -59,12 +53,7 @@ export const createMockContext = (
  };

  const mergedInputs = overrides.inputs
-    ? {
-        ...defaultInputs,
-        ...overrides.inputs,
-        includeCommentsByActor: overrides.inputs.includeCommentsByActor ?? "",
-        excludeCommentsByActor: overrides.inputs.excludeCommentsByActor ?? "",
-      }
+    ? { ...defaultInputs, ...overrides.inputs }
    : defaultInputs;

  return { ...baseContext, ...overrides, inputs: mergedInputs };
@ -88,12 +77,7 @@ export const createMockAutomationContext = (
  };

  const mergedInputs = overrides.inputs
-    ? {
-        ...defaultInputs,
-        ...overrides.inputs,
-        includeCommentsByActor: overrides.inputs.includeCommentsByActor ?? "",
-        excludeCommentsByActor: overrides.inputs.excludeCommentsByActor ?? "",
-      }
+    ? { ...defaultInputs, ...overrides.inputs }
    : { ...defaultInputs };

  return { ...baseContext, ...overrides, inputs: mergedInputs };
--- a/test/modes/agent.test.ts
+++ b/test/modes/agent.test.ts
@ -7,17 +7,22 @@ import {
  spyOn,
  mock,
 } from "bun:test";
-import { prepareAgentMode } from "../../src/modes/agent";
-import { createMockAutomationContext } from "../mockContext";
+import { agentMode } from "../../src/modes/agent";
+import type { GitHubContext } from "../../src/github/context";
+import { createMockContext, createMockAutomationContext } from "../mockContext";
 import * as core from "@actions/core";
 import * as gitConfig from "../../src/github/operations/git-config";

 describe("Agent Mode", () => {
+  let mockContext: GitHubContext;
  let exportVariableSpy: any;
  let setOutputSpy: any;
  let configureGitAuthSpy: any;

  beforeEach(() => {
+    mockContext = createMockAutomationContext({
+      eventName: "workflow_dispatch",
+    });
    exportVariableSpy = spyOn(core, "exportVariable").mockImplementation(
      () => {},
    );
@ -40,11 +45,84 @@ describe("Agent Mode", () => {
    configureGitAuthSpy?.mockRestore();
  });

-  test("prepareAgentMode is exported as a function", () => {
-    expect(typeof prepareAgentMode).toBe("function");
+  test("agent mode has correct properties", () => {
+    expect(agentMode.name).toBe("agent");
+    expect(agentMode.description).toBe(
+      "Direct automation mode for explicit prompts",
+    );
+    expect(agentMode.shouldCreateTrackingComment()).toBe(false);
+    expect(agentMode.getAllowedTools()).toEqual([]);
+    expect(agentMode.getDisallowedTools()).toEqual([]);
  });

-  test("prepare passes through claude_args", async () => {
+  test("prepareContext returns minimal data", () => {
+    const context = agentMode.prepareContext(mockContext);
+
+    expect(context.mode).toBe("agent");
+    expect(context.githubContext).toBe(mockContext);
+    // Agent mode doesn't use comment tracking or branch management
+    expect(Object.keys(context)).toEqual(["mode", "githubContext"]);
+  });
+
+  test("agent mode only triggers when prompt is provided", () => {
+    // Should NOT trigger for automation events without prompt
+    const workflowDispatchContext = createMockAutomationContext({
+      eventName: "workflow_dispatch",
+    });
+    expect(agentMode.shouldTrigger(workflowDispatchContext)).toBe(false);
+
+    const scheduleContext = createMockAutomationContext({
+      eventName: "schedule",
+    });
+    expect(agentMode.shouldTrigger(scheduleContext)).toBe(false);
+
+    const repositoryDispatchContext = createMockAutomationContext({
+      eventName: "repository_dispatch",
+    });
+    expect(agentMode.shouldTrigger(repositoryDispatchContext)).toBe(false);
+
+    // Should NOT trigger for entity events without prompt
+    const entityEvents = [
+      "issue_comment",
+      "pull_request",
+      "pull_request_review",
+      "issues",
+    ] as const;
+
+    entityEvents.forEach((eventName) => {
+      const contextNoPrompt = createMockContext({ eventName });
+      expect(agentMode.shouldTrigger(contextNoPrompt)).toBe(false);
+    });
+
+    // Should trigger for ANY event when prompt is provided
+    const allEvents = [
+      "workflow_dispatch",
+      "repository_dispatch",
+      "schedule",
+      "issue_comment",
+      "pull_request",
+      "pull_request_review",
+      "issues",
+    ] as const;
+
+    allEvents.forEach((eventName) => {
+      const contextWithPrompt =
+        eventName === "workflow_dispatch" ||
+        eventName === "repository_dispatch" ||
+        eventName === "schedule"
+          ? createMockAutomationContext({
+              eventName,
+              inputs: { prompt: "Do something" },
+            })
+          : createMockContext({
+              eventName,
+              inputs: { prompt: "Do something" },
+            });
+      expect(agentMode.shouldTrigger(contextWithPrompt)).toBe(true);
+    });
+  });
+
+  test("prepare method passes through claude_args", async () => {
    // Clear any previous calls before this test
    exportVariableSpy.mockClear();
    setOutputSpy.mockClear();
@ -67,28 +145,30 @@ describe("Agent Mode", () => {
        users: {
          getAuthenticated: mock(() =>
            Promise.resolve({
-              data: { login: "test-user", id: 12345, type: "User" },
+              data: { login: "test-user", id: 12345 },
            }),
          ),
          getByUsername: mock(() =>
            Promise.resolve({
-              data: { login: "test-user", id: 12345, type: "User" },
+              data: { login: "test-user", id: 12345 },
            }),
          ),
        },
      },
    } as any;
-    const result = await prepareAgentMode({
+    const result = await agentMode.prepare({
      context: contextWithCustomArgs,
      octokit: mockOctokit,
      githubToken: "test-token",
    });

    // Verify claude_args includes user args (no MCP config in agent mode without allowed tools)
-    expect(result.claudeArgs).toBe("--model claude-sonnet-4 --max-turns 10");
-    expect(result.claudeArgs).not.toContain("--mcp-config");
+    const callArgs = setOutputSpy.mock.calls[0];
+    expect(callArgs[0]).toBe("claude_args");
+    expect(callArgs[1]).toBe("--model claude-sonnet-4 --max-turns 10");
+    expect(callArgs[1]).not.toContain("--mcp-config");

-    // Verify return structure - should fall back to repository.default_branch when no env vars set
+    // Verify return structure - should use "main" as fallback when no env vars set
    expect(result).toEqual({
      commentId: undefined,
      branchInfo: {
@ -97,7 +177,6 @@ describe("Agent Mode", () => {
        claudeBranch: undefined,
      },
      mcpConfig: expect.any(String),
-      claudeArgs: "--model claude-sonnet-4 --max-turns 10",
    });

    // Clean up
@ -108,120 +187,7 @@ describe("Agent Mode", () => {
      process.env.GITHUB_REF_NAME = originalRefName;
  });

-  test("prepare falls back to repository.default_branch when not 'main'", async () => {
-    const contextWithDevelop = createMockAutomationContext({
-      eventName: "workflow_dispatch",
-      repository: {
-        owner: "test-owner",
-        repo: "test-repo",
-        full_name: "test-owner/test-repo",
-        default_branch: "develop",
-      },
-    });
-
-    // Save and clear env vars that would otherwise override the fallback
-    const originalClaudeBranch = process.env.CLAUDE_BRANCH;
-    const originalHeadRef = process.env.GITHUB_HEAD_REF;
-    const originalRefName = process.env.GITHUB_REF_NAME;
-    delete process.env.CLAUDE_BRANCH;
-    delete process.env.GITHUB_HEAD_REF;
-    delete process.env.GITHUB_REF_NAME;
-
-    const mockOctokit = {
-      rest: {
-        users: {
-          getAuthenticated: mock(() =>
-            Promise.resolve({
-              data: { login: "test-user", id: 12345, type: "User" },
-            }),
-          ),
-          getByUsername: mock(() =>
-            Promise.resolve({
-              data: { login: "test-user", id: 12345, type: "User" },
-            }),
-          ),
-        },
-      },
-    } as any;
-
-    const result = await prepareAgentMode({
-      context: contextWithDevelop,
-      octokit: mockOctokit,
-      githubToken: "test-token",
-    });
-
-    expect(result.branchInfo.baseBranch).toBe("develop");
-    expect(result.branchInfo.currentBranch).toBe("develop");
-
-    // Restore env vars
-    if (originalClaudeBranch !== undefined)
-      process.env.CLAUDE_BRANCH = originalClaudeBranch;
-    if (originalHeadRef !== undefined)
-      process.env.GITHUB_HEAD_REF = originalHeadRef;
-    if (originalRefName !== undefined)
-      process.env.GITHUB_REF_NAME = originalRefName;
-  });
-
-  test("prepare rejects bot actors without allowed_bots", async () => {
-    const contextWithPrompts = createMockAutomationContext({
-      eventName: "workflow_dispatch",
-    });
-    contextWithPrompts.actor = "claude[bot]";
-    contextWithPrompts.inputs.allowedBots = "";
-
-    const mockOctokit = {
-      rest: {
-        users: {
-          getByUsername: mock(() =>
-            Promise.resolve({
-              data: { login: "claude[bot]", id: 12345, type: "Bot" },
-            }),
-          ),
-        },
-      },
-    } as any;
-
-    await expect(
-      prepareAgentMode({
-        context: contextWithPrompts,
-        octokit: mockOctokit,
-        githubToken: "test-token",
-      }),
-    ).rejects.toThrow(
-      "Workflow initiated by non-human actor: claude (type: Bot)",
-    );
-  });
-
-  test("prepare allows bot actors when in allowed_bots list", async () => {
-    const contextWithPrompts = createMockAutomationContext({
-      eventName: "workflow_dispatch",
-    });
-    contextWithPrompts.actor = "dependabot[bot]";
-    contextWithPrompts.inputs.allowedBots = "dependabot";
-
-    const mockOctokit = {
-      rest: {
-        users: {
-          getByUsername: mock(() =>
-            Promise.resolve({
-              data: { login: "dependabot[bot]", id: 12345, type: "Bot" },
-            }),
-          ),
-        },
-      },
-    } as any;
-
-    // Should not throw - bot is in allowed list
-    await expect(
-      prepareAgentMode({
-        context: contextWithPrompts,
-        octokit: mockOctokit,
-        githubToken: "test-token",
-      }),
-    ).resolves.toBeDefined();
-  });
-
-  test("prepare creates prompt file with correct content", async () => {
+  test("prepare method creates prompt file with correct content", async () => {
    const contextWithPrompts = createMockAutomationContext({
      eventName: "workflow_dispatch",
    });
@ -233,18 +199,18 @@ describe("Agent Mode", () => {
        users: {
          getAuthenticated: mock(() =>
            Promise.resolve({
-              data: { login: "test-user", id: 12345, type: "User" },
+              data: { login: "test-user", id: 12345 },
            }),
          ),
          getByUsername: mock(() =>
            Promise.resolve({
-              data: { login: "test-user", id: 12345, type: "User" },
+              data: { login: "test-user", id: 12345 },
            }),
          ),
        },
      },
    } as any;
-    const result = await prepareAgentMode({
+    await agentMode.prepare({
      context: contextWithPrompts,
      octokit: mockOctokit,
      githubToken: "test-token",
@ -254,7 +220,9 @@ describe("Agent Mode", () => {
    // but we can verify the method completes without errors
    // With our conditional MCP logic, agent mode with no allowed tools
    // should not include any MCP config
+    const callArgs = setOutputSpy.mock.calls[0];
+    expect(callArgs[0]).toBe("claude_args");
    // Should be empty or just whitespace when no MCP servers are included
-    expect(result.claudeArgs).not.toContain("--mcp-config");
+    expect(callArgs[1]).not.toContain("--mcp-config");
  });
 });
--- a/test/modes/detector.test.ts
+++ b/test/modes/detector.test.ts
@ -19,17 +19,12 @@ describe("detectMode with enhanced routing", () => {
      labelTrigger: "",
      branchPrefix: "claude/",
      useStickyComment: false,
-      classifyInlineComments: true,
      useCommitSigning: false,
-      sshSigningKey: "",
      botId: "123456",
      botName: "claude-bot",
      allowedBots: "",
      allowedNonWriteUsers: "",
      trackProgress: false,
-      includeFixLinks: true,
-      includeCommentsByActor: "",
-      excludeCommentsByActor: "",
    },
  };

--- a/test/modes/parse-tools.test.ts
+++ b/test/modes/parse-tools.test.ts
@ -35,44 +35,12 @@ describe("parseAllowedTools", () => {
    expect(parseAllowedTools("")).toEqual([]);
  });

-  test("handles --allowedTools followed by another --allowedTools flag", () => {
+  test("handles duplicate --allowedTools flags", () => {
    const args = "--allowedTools --allowedTools mcp__github__*";
-    // The second --allowedTools is consumed as a value of the first, then skipped.
-    // This is an edge case with malformed input - returns empty.
+    // Should not match the first one since the value is another flag
    expect(parseAllowedTools(args)).toEqual([]);
  });

-  test("parses multiple separate --allowed-tools flags", () => {
-    const args =
-      "--allowed-tools 'mcp__context7__*' --allowed-tools 'Read,Glob' --allowed-tools 'mcp__github_inline_comment__*'";
-    expect(parseAllowedTools(args)).toEqual([
-      "mcp__context7__*",
-      "Read",
-      "Glob",
-      "mcp__github_inline_comment__*",
-    ]);
-  });
-
-  test("parses multiple --allowed-tools flags on separate lines", () => {
-    const args = `--model 'claude-haiku'
--allowed-tools 'mcp__context7__*'
--allowed-tools 'Read,Glob,Grep'
--allowed-tools 'mcp__github_inline_comment__create_inline_comment'`;
-    expect(parseAllowedTools(args)).toEqual([
-      "mcp__context7__*",
-      "Read",
-      "Glob",
-      "Grep",
-      "mcp__github_inline_comment__create_inline_comment",
-    ]);
-  });
-
-  test("deduplicates tools from multiple flags", () => {
-    const args =
-      "--allowed-tools 'Read,Glob' --allowed-tools 'Glob,Grep' --allowed-tools 'Read'";
-    expect(parseAllowedTools(args)).toEqual(["Read", "Glob", "Grep"]);
-  });
-
  test("handles typo --alloedTools", () => {
    const args = "--alloedTools mcp__github__*";
    expect(parseAllowedTools(args)).toEqual([]);
--- a/test/modes/registry.test.ts
+++ b/test/modes/registry.test.ts
@ -0,0 +1,155 @@
+import { describe, test, expect } from "bun:test";
+import { getMode, isValidMode } from "../../src/modes/registry";
+import { agentMode } from "../../src/modes/agent";
+import { tagMode } from "../../src/modes/tag";
+import {
+  createMockContext,
+  createMockAutomationContext,
+  mockRepositoryDispatchContext,
+} from "../mockContext";
+
+describe("Mode Registry", () => {
+  const mockContext = createMockContext({
+    eventName: "issue_comment",
+    payload: {
+      action: "created",
+      comment: {
+        body: "Test comment without trigger",
+      },
+    } as any,
+  });
+
+  const mockWorkflowDispatchContext = createMockAutomationContext({
+    eventName: "workflow_dispatch",
+  });
+
+  const mockScheduleContext = createMockAutomationContext({
+    eventName: "schedule",
+  });
+
+  test("getMode auto-detects agent mode for issue_comment without trigger", () => {
+    const mode = getMode(mockContext);
+    // Agent mode is the default when no trigger is found
+    expect(mode).toBe(agentMode);
+    expect(mode.name).toBe("agent");
+  });
+
+  test("getMode auto-detects agent mode for workflow_dispatch", () => {
+    const mode = getMode(mockWorkflowDispatchContext);
+    expect(mode).toBe(agentMode);
+    expect(mode.name).toBe("agent");
+  });
+
+  // Removed test - explicit mode override no longer supported in v1.0
+
+  test("getMode auto-detects agent for workflow_dispatch", () => {
+    const mode = getMode(mockWorkflowDispatchContext);
+    expect(mode).toBe(agentMode);
+    expect(mode.name).toBe("agent");
+  });
+
+  test("getMode auto-detects agent for schedule event", () => {
+    const mode = getMode(mockScheduleContext);
+    expect(mode).toBe(agentMode);
+    expect(mode.name).toBe("agent");
+  });
+
+  test("getMode auto-detects agent for repository_dispatch event", () => {
+    const mode = getMode(mockRepositoryDispatchContext);
+    expect(mode).toBe(agentMode);
+    expect(mode.name).toBe("agent");
+  });
+
+  test("getMode auto-detects agent for repository_dispatch with client_payload", () => {
+    const contextWithPayload = createMockAutomationContext({
+      eventName: "repository_dispatch",
+      payload: {
+        action: "trigger-analysis",
+        client_payload: {
+          source: "external-system",
+          metadata: { priority: "high" },
+        },
+        repository: {
+          name: "test-repo",
+          owner: { login: "test-owner" },
+        },
+        sender: { login: "automation-user" },
+      },
+    });
+
+    const mode = getMode(contextWithPayload);
+    expect(mode).toBe(agentMode);
+    expect(mode.name).toBe("agent");
+  });
+
+  // Removed test - legacy mode names no longer supported in v1.0
+
+  test("getMode auto-detects agent mode for PR opened", () => {
+    const prContext = createMockContext({
+      eventName: "pull_request",
+      payload: { action: "opened" } as any,
+      isPR: true,
+    });
+    const mode = getMode(prContext);
+    expect(mode).toBe(agentMode);
+    expect(mode.name).toBe("agent");
+  });
+
+  test("getMode uses agent mode when prompt is provided, even with @claude mention", () => {
+    const contextWithPrompt = createMockContext({
+      eventName: "issue_comment",
+      payload: {
+        action: "created",
+        comment: {
+          body: "@claude please help",
+        },
+      } as any,
+      inputs: {
+        prompt: "/review",
+      } as any,
+    });
+    const mode = getMode(contextWithPrompt);
+    expect(mode).toBe(agentMode);
+    expect(mode.name).toBe("agent");
+  });
+
+  test("getMode uses tag mode for @claude mention without prompt", () => {
+    // Ensure PROMPT env var is not set (clean up from previous tests)
+    const originalPrompt = process.env.PROMPT;
+    delete process.env.PROMPT;
+
+    const contextWithMention = createMockContext({
+      eventName: "issue_comment",
+      payload: {
+        action: "created",
+        comment: {
+          body: "@claude please help",
+        },
+      } as any,
+      inputs: {
+        triggerPhrase: "@claude",
+        prompt: "",
+      } as any,
+    });
+    const mode = getMode(contextWithMention);
+    expect(mode).toBe(tagMode);
+    expect(mode.name).toBe("tag");
+
+    // Restore original value if it existed
+    if (originalPrompt !== undefined) {
+      process.env.PROMPT = originalPrompt;
+    }
+  });
+
+  // Removed test - explicit mode override no longer supported in v1.0
+
+  test("isValidMode returns true for all valid modes", () => {
+    expect(isValidMode("tag")).toBe(true);
+    expect(isValidMode("agent")).toBe(true);
+  });
+
+  test("isValidMode returns false for invalid mode", () => {
+    expect(isValidMode("invalid")).toBe(false);
+    expect(isValidMode("review")).toBe(false);
+  });
+});
--- a/test/modes/tag.test.ts
+++ b/test/modes/tag.test.ts
@ -1,8 +1,92 @@
-import { describe, test, expect } from "bun:test";
-import { prepareTagMode } from "../../src/modes/tag";
+import { describe, test, expect, beforeEach } from "bun:test";
+import { tagMode } from "../../src/modes/tag";
+import type { ParsedGitHubContext } from "../../src/github/context";
+import type { IssueCommentEvent } from "@octokit/webhooks-types";
+import { createMockContext } from "../mockContext";

 describe("Tag Mode", () => {
-  test("prepareTagMode is exported as a function", () => {
-    expect(typeof prepareTagMode).toBe("function");
+  let mockContext: ParsedGitHubContext;
+
+  beforeEach(() => {
+    mockContext = createMockContext({
+      eventName: "issue_comment",
+      isPR: false,
+    });
+  });
+
+  test("tag mode has correct properties", () => {
+    expect(tagMode.name).toBe("tag");
+    expect(tagMode.description).toBe(
+      "Traditional implementation mode triggered by @claude mentions",
+    );
+    expect(tagMode.shouldCreateTrackingComment()).toBe(true);
+  });
+
+  test("shouldTrigger delegates to checkContainsTrigger", () => {
+    const contextWithTrigger = createMockContext({
+      eventName: "issue_comment",
+      isPR: false,
+      inputs: {
+        ...createMockContext().inputs,
+        triggerPhrase: "@claude",
+      },
+      payload: {
+        comment: {
+          body: "Hey @claude, can you help?",
+        },
+      } as IssueCommentEvent,
+    });
+
+    expect(tagMode.shouldTrigger(contextWithTrigger)).toBe(true);
+
+    const contextWithoutTrigger = createMockContext({
+      eventName: "issue_comment",
+      isPR: false,
+      inputs: {
+        ...createMockContext().inputs,
+        triggerPhrase: "@claude",
+      },
+      payload: {
+        comment: {
+          body: "This is just a regular comment",
+        },
+      } as IssueCommentEvent,
+    });
+
+    expect(tagMode.shouldTrigger(contextWithoutTrigger)).toBe(false);
+  });
+
+  test("prepareContext includes all required data", () => {
+    const data = {
+      commentId: 123,
+      baseBranch: "main",
+      claudeBranch: "claude/fix-bug",
+    };
+
+    const context = tagMode.prepareContext(mockContext, data);
+
+    expect(context.mode).toBe("tag");
+    expect(context.githubContext).toBe(mockContext);
+    expect(context.commentId).toBe(123);
+    expect(context.baseBranch).toBe("main");
+    expect(context.claudeBranch).toBe("claude/fix-bug");
+  });
+
+  test("prepareContext works without data", () => {
+    const context = tagMode.prepareContext(mockContext);
+
+    expect(context.mode).toBe("tag");
+    expect(context.githubContext).toBe(mockContext);
+    expect(context.commentId).toBeUndefined();
+    expect(context.baseBranch).toBeUndefined();
+    expect(context.claudeBranch).toBeUndefined();
+  });
+
+  test("getAllowedTools returns empty array", () => {
+    expect(tagMode.getAllowedTools()).toEqual([]);
+  });
+
+  test("getDisallowedTools returns empty array", () => {
+    expect(tagMode.getDisallowedTools()).toEqual([]);
  });
 });
--- a/test/parse-permissions.test.ts
+++ b/test/parse-permissions.test.ts
@ -1,97 +0,0 @@
-import { describe, expect, test, beforeEach, afterEach } from "bun:test";
-import { parseAdditionalPermissions } from "../src/github/token";
-
-describe("parseAdditionalPermissions", () => {
-  let originalEnv: string | undefined;
-
-  beforeEach(() => {
-    originalEnv = process.env.ADDITIONAL_PERMISSIONS;
-  });
-
-  afterEach(() => {
-    if (originalEnv === undefined) {
-      delete process.env.ADDITIONAL_PERMISSIONS;
-    } else {
-      process.env.ADDITIONAL_PERMISSIONS = originalEnv;
-    }
-  });
-
-  test("returns undefined when env var is not set", () => {
-    delete process.env.ADDITIONAL_PERMISSIONS;
-    expect(parseAdditionalPermissions()).toBeUndefined();
-  });
-
-  test("returns undefined when env var is empty string", () => {
-    process.env.ADDITIONAL_PERMISSIONS = "";
-    expect(parseAdditionalPermissions()).toBeUndefined();
-  });
-
-  test("returns undefined when env var is only whitespace", () => {
-    process.env.ADDITIONAL_PERMISSIONS = "   \n  \n  ";
-    expect(parseAdditionalPermissions()).toBeUndefined();
-  });
-
-  test("parses single permission and merges with defaults", () => {
-    process.env.ADDITIONAL_PERMISSIONS = "actions: read";
-    expect(parseAdditionalPermissions()).toEqual({
-      contents: "write",
-      pull_requests: "write",
-      issues: "write",
-      actions: "read",
-    });
-  });
-
-  test("parses multiple permissions", () => {
-    process.env.ADDITIONAL_PERMISSIONS = "actions: read\nworkflows: write";
-    expect(parseAdditionalPermissions()).toEqual({
-      contents: "write",
-      pull_requests: "write",
-      issues: "write",
-      actions: "read",
-      workflows: "write",
-    });
-  });
-
-  test("additional permissions can override defaults", () => {
-    process.env.ADDITIONAL_PERMISSIONS = "contents: read";
-    expect(parseAdditionalPermissions()).toEqual({
-      contents: "read",
-      pull_requests: "write",
-      issues: "write",
-    });
-  });
-
-  test("handles extra whitespace around keys and values", () => {
-    process.env.ADDITIONAL_PERMISSIONS = "  actions :  read  ";
-    expect(parseAdditionalPermissions()).toEqual({
-      contents: "write",
-      pull_requests: "write",
-      issues: "write",
-      actions: "read",
-    });
-  });
-
-  test("skips empty lines", () => {
-    process.env.ADDITIONAL_PERMISSIONS =
-      "actions: read\n\n\nworkflows: write\n\n";
-    expect(parseAdditionalPermissions()).toEqual({
-      contents: "write",
-      pull_requests: "write",
-      issues: "write",
-      actions: "read",
-      workflows: "write",
-    });
-  });
-
-  test("skips lines without colons", () => {
-    process.env.ADDITIONAL_PERMISSIONS =
-      "actions: read\ninvalid line\nworkflows: write";
-    expect(parseAdditionalPermissions()).toEqual({
-      contents: "write",
-      pull_requests: "write",
-      issues: "write",
-      actions: "read",
-      workflows: "write",
-    });
-  });
-});
--- a/Show More
+++ b/Show More