fix: use proper type guards instead of manual property checks

Address review feedback by using isEntityContext() type guard instead of checking 'isPR' in context manually. This provides better type safety and uses the existing type guard infrastructure.
Merge branch 'main' into km/add-mcp-to-agent
2026-01-23 06:54:13 +08:00 · 2025-08-01 15:43:07 -07:00 · 2025-08-01 15:38:20 -07:00 · 2025-08-01 15:04:23 -07:00 · 2025-08-01 21:53:55 +00:00 · 2025-08-01 14:35:42 -07:00
46 changed files with 2635 additions and 708 deletions
--- a/.github/workflows/claude-review.yml
+++ b/.github/workflows/claude-review.yml
@@ -30,4 +30,4 @@ jobs:

            Be constructive and specific in your feedback. Give inline comments where applicable.
          anthropic_api_key: ${{ secrets.ANTHROPIC_API_KEY }}
-          allowed_tools: "mcp__github__create_pending_pull_request_review,mcp__github__add_pull_request_review_comment_to_pending_review,mcp__github__submit_pending_pull_request_review,mcp__github__get_pull_request_diff"
+          allowed_tools: "mcp__github__create_pending_pull_request_review,mcp__github__add_comment_to_pending_review,mcp__github__submit_pending_pull_request_review,mcp__github__get_pull_request_diff"
--- a/.github/workflows/issue-triage.yml
+++ b/.github/workflows/issue-triage.yml
@@ -32,7 +32,7 @@ jobs:
                  "--rm",
                  "-e",
                  "GITHUB_PERSONAL_ACCESS_TOKEN",
-                  "ghcr.io/github/github-mcp-server:sha-721fd3e"
+                  "ghcr.io/github/github-mcp-server:sha-efef8ae"
                ],
                "env": {
                  "GITHUB_PERSONAL_ACCESS_TOKEN": "${{ secrets.GITHUB_TOKEN }}"
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -1,10 +1,11 @@
 # CLAUDE.md

-This file provides guidance to Claude Code when working with code in this repository.
+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

@@ -17,42 +18,119 @@ 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
 ```

 ## Architecture Overview

-This is a GitHub Action that enables Claude to interact with GitHub PRs and issues. The action:
+This is a GitHub Action that enables Claude to interact with GitHub PRs and issues. The action operates in two main phases:

-1. **Trigger Detection**: Uses `check-trigger.ts` to determine if Claude should respond based on comment/issue content
-2. **Context Gathering**: Fetches GitHub data (PRs, issues, comments) via `github-data-fetcher.ts` and formats it using `github-data-formatter.ts`
-3. **AI Integration**: Supports multiple Claude providers (Anthropic API, AWS Bedrock, Google Vertex AI)
-4. **Prompt Creation**: Generates context-rich prompts using `create-prompt.ts`
-5. **MCP Server Integration**: Installs and configures GitHub MCP server for extended functionality
+### Phase 1: Preparation (`src/entrypoints/prepare.ts`)

-### Key Components
+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

- **Trigger System**: Responds to `/claude` comments or issue assignments
- **Authentication**: OIDC-based token exchange for secure GitHub interactions
- **Cloud Integration**: Supports direct Anthropic API, AWS Bedrock, and Google Vertex AI
- **GitHub Operations**: Creates branches, posts comments, and manages PRs/issues
+### Phase 2: Execution (`base-action/`)
+
+The `base-action/` directory contains the core Claude Code execution logic, which serves a dual purpose:
+
+- **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
+
+Execution steps:
+
+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
+
+### Key Architectural Components
+
+#### Mode System (`src/modes/`)
+
+- **Tag Mode** (`tag/`): Responds to `@claude` mentions and issue assignments
+- **Agent Mode** (`agent/`): Automated execution without trigger checking
+- 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/
-├── check-trigger.ts        # Determines if Claude should respond
-├── create-prompt.ts        # Generates contextual prompts
-├── github-data-fetcher.ts  # Retrieves GitHub data
-├── github-data-formatter.ts # Formats GitHub data for prompts
-├── install-mcp-server.ts  # Sets up GitHub MCP server
-├── update-comment-with-link.ts # Updates comments with job links
-└── types/
-    └── github.ts          # TypeScript types for GitHub data
+├── 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 Notes
+## Important Implementation Notes

- Actions are triggered by `@claude` comments or issue assignment unless a different trigger_phrase is specified
- The action creates branches for issues and pushes to PR branches directly
- All actions create OIDC tokens for secure authentication
- Progress is tracked through dynamic comment updates with checkboxes
+### 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 bypasses all trigger checking for automation scenarios
+
+### 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
+
+- 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/README.md
+++ b/README.md
@@ -145,6 +145,8 @@ jobs:
          # Or use OAuth token instead:
          # claude_code_oauth_token: ${{ secrets.CLAUDE_CODE_OAUTH_TOKEN }}
          github_token: ${{ secrets.GITHUB_TOKEN }}
+          # Optional: set execution mode (default: tag)
+          # mode: "tag"
          # Optional: add custom trigger phrase (default: @claude)
          # trigger_phrase: "/claude"
          # Optional: add assignee trigger for issues
@@ -165,40 +167,100 @@ 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\*     | -         |
-| `direct_prompt`                | Direct prompt for Claude to execute automatically without needing a trigger (for automated workflows)                | No       | -         |
-| `override_prompt`              | Complete replacement of Claude's prompt with custom template (supports variable substitution)                        | No       | -         |
-| `base_branch`                  | The base branch to use for creating new branches (e.g., 'main', 'develop')                                           | No       | -         |
-| `max_turns`                    | Maximum number of conversation turns Claude can take (limits back-and-forth exchanges)                               | No       | -         |
-| `timeout_minutes`              | Timeout in minutes for execution                                                                                     | No       | `30`      |
-| `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       | -         |
-| `model`                        | Model to use (provider-specific format required for Bedrock/Vertex)                                                  | No       | -         |
-| `fallback_model`               | Enable automatic fallback to specified model when primary model is unavailable                                       | No       | -         |
-| `anthropic_model`              | **DEPRECATED**: Use `model` instead. Kept for backward compatibility.                                                | 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`   |
-| `allowed_tools`                | Additional tools for Claude to use (the base GitHub tools will always be included)                                   | No       | ""        |
-| `disallowed_tools`             | Tools that Claude should never use                                                                                   | No       | ""        |
-| `custom_instructions`          | Additional custom instructions to include in the prompt for Claude                                                   | No       | ""        |
-| `mcp_config`                   | Additional MCP configuration (JSON string) that merges with the built-in GitHub MCP servers                          | No       | ""        |
-| `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/` |
-| `claude_env`                   | Custom environment variables to pass to Claude Code execution (YAML format)                                          | No       | ""        |
-| `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       | ""        |
-| `experimental_allowed_domains` | Restrict network access to these domains only (newline-separated).                                                   | No       | ""        |
-| `use_commit_signing`           | Enable commit signing using GitHub's commit signature verification. When false, Claude uses standard git commands    | No       | `false`   |
+| Input                          | Description                                                                                                                           | Required | Default   |
+| ------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------- | -------- | --------- |
+| `mode`                         | Execution mode: 'tag' (default - triggered by mentions/assignments), 'agent' (for automation), 'experimental-review' (for PR reviews) | No       | `tag`     |
+| `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\*     | -         |
+| `direct_prompt`                | Direct prompt for Claude to execute automatically without needing a trigger (for automated workflows)                                 | No       | -         |
+| `override_prompt`              | Complete replacement of Claude's prompt with custom template (supports variable substitution)                                         | No       | -         |
+| `base_branch`                  | The base branch to use for creating new branches (e.g., 'main', 'develop')                                                            | No       | -         |
+| `max_turns`                    | Maximum number of conversation turns Claude can take (limits back-and-forth exchanges)                                                | No       | -         |
+| `timeout_minutes`              | Timeout in minutes for execution                                                                                                      | No       | `30`      |
+| `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       | -         |
+| `model`                        | Model to use (provider-specific format required for Bedrock/Vertex)                                                                   | No       | -         |
+| `fallback_model`               | Enable automatic fallback to specified model when primary model is unavailable                                                        | No       | -         |
+| `anthropic_model`              | **DEPRECATED**: Use `model` instead. Kept for backward compatibility.                                                                 | 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`   |
+| `allowed_tools`                | Additional tools for Claude to use (the base GitHub tools will always be included)                                                    | No       | ""        |
+| `disallowed_tools`             | Tools that Claude should never use                                                                                                    | No       | ""        |
+| `custom_instructions`          | Additional custom instructions to include in the prompt for Claude                                                                    | No       | ""        |
+| `mcp_config`                   | Additional MCP configuration (JSON string) that merges with the built-in GitHub MCP servers                                           | No       | ""        |
+| `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/` |
+| `claude_env`                   | Custom environment variables to pass to Claude Code execution (YAML format)                                                           | No       | ""        |
+| `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       | ""        |
+| `experimental_allowed_domains` | Restrict network access to these domains only (newline-separated).                                                                    | No       | ""        |
+| `use_commit_signing`           | Enable commit signing using GitHub's commit signature verification. When false, Claude uses standard git commands                     | No       | `false`   |

 \*Required when using direct Anthropic API (default and when not using Bedrock or Vertex)

 > **Note**: This action is currently in beta. Features and APIs may change as we continue to improve the integration.

+## Execution Modes
+
+The action supports three execution modes, each optimized for different use cases:
+
+### Tag Mode (Default)
+
+The traditional implementation mode that responds to @claude mentions, issue assignments, or labels.
+
+- **Triggers**: `@claude` mentions, issue assignment, label application
+- **Features**: Creates tracking comments with progress checkboxes, full implementation capabilities
+- **Use case**: General-purpose code implementation and Q&A
+
+```yaml
+- uses: anthropics/claude-code-action@beta
+  with:
+    anthropic_api_key: ${{ secrets.ANTHROPIC_API_KEY }}
+    # mode: tag is the default
+```
+
+### Agent Mode
+
+For automation and scheduled tasks without trigger checking.
+
+- **Triggers**: Always runs (no trigger checking)
+- **Features**: Perfect for scheduled tasks, works with `override_prompt`
+- **Use case**: Maintenance tasks, automated reporting, scheduled checks
+
+```yaml
+- uses: anthropics/claude-code-action@beta
+  with:
+    mode: agent
+    anthropic_api_key: ${{ secrets.ANTHROPIC_API_KEY }}
+    override_prompt: |
+      Check for outdated dependencies and create an issue if any are found.
+```
+
+### Experimental Review Mode
+
+> **EXPERIMENTAL**: This mode is under active development and may change significantly. Use with caution in production workflows.
+
+Specialized mode for automated PR code reviews using GitHub's review API.
+
+- **Triggers**: Automatically on PR events (opened, synchronize, reopened) when configured in workflow
+- **Features**: Creates inline review comments with suggestions, batches feedback into a single review
+- **Use case**: Automated code reviews, security scanning, best practices enforcement
+
+```yaml
+- uses: anthropics/claude-code-action@beta
+  with:
+    mode: experimental-review
+    anthropic_api_key: ${{ secrets.ANTHROPIC_API_KEY }}
+    custom_instructions: |
+      Focus on security vulnerabilities, performance issues, and code quality.
+```
+
+Review mode automatically includes GitHub MCP tools for creating pending reviews and inline comments. See [`examples/claude-experimental-review-mode.yml`](./examples/claude-experimental-review-mode.yml) for a complete example.
+
+See [`examples/claude-modes.yml`](./examples/claude-modes.yml) for complete examples of available modes.
+
 ### Using Custom MCP Configuration

 The `mcp_config` input allows you to add custom MCP (Model Context Protocol) servers to extend Claude's capabilities. These servers merge with the built-in GitHub MCP servers.
--- a/action.yml
+++ b/action.yml
@@ -24,6 +24,12 @@ inputs:
    required: false
    default: "claude/"

+  # Mode configuration
+  mode:
+    description: "Execution mode for the action. Valid modes: 'tag' (default - triggered by mentions/assignments), 'agent' (for automation with no trigger checking), 'experimental-review' (experimental mode for code reviews with inline comments and suggestions)"
+    required: false
+    default: "tag"
+
  # Claude Code configuration
  model:
    description: "Model to use (provider-specific format required for Bedrock/Vertex)"
@@ -137,6 +143,7 @@ runs:
      run: |
        bun run ${GITHUB_ACTION_PATH}/src/entrypoints/prepare.ts
      env:
+        MODE: ${{ inputs.mode }}
        TRIGGER_PHRASE: ${{ inputs.trigger_phrase }}
        ASSIGNEE_TRIGGER: ${{ inputs.assignee_trigger }}
        LABEL_TRIGGER: ${{ inputs.label_trigger }}
@@ -151,51 +158,38 @@ runs:
        OVERRIDE_GITHUB_TOKEN: ${{ inputs.github_token }}
        GITHUB_RUN_ID: ${{ github.run_id }}
        USE_STICKY_COMMENT: ${{ inputs.use_sticky_comment }}
-        ACTIONS_TOKEN: ${{ github.token }}
+        DEFAULT_WORKFLOW_TOKEN: ${{ github.token }}
        ADDITIONAL_PERMISSIONS: ${{ inputs.additional_permissions }}
        USE_COMMIT_SIGNING: ${{ inputs.use_commit_signing }}

+    - name: Install Base Action Dependencies
+      if: steps.prepare.outputs.contains_trigger == 'true'
+      shell: bash
+      run: |
+        echo "Installing base-action dependencies..."
+        cd ${GITHUB_ACTION_PATH}/base-action
+        bun install
+        echo "Base-action dependencies installed"
+        cd -
+        # Install Claude Code globally
+        bun install -g @anthropic-ai/claude-code@1.0.66
+
    - name: Setup Network Restrictions
      if: steps.prepare.outputs.contains_trigger == 'true' && inputs.experimental_allowed_domains != ''
      shell: bash
      run: |
-        # Install and configure Squid proxy
-        sudo apt-get update && sudo apt-get install -y squid
-
-        echo "${{ inputs.experimental_allowed_domains }}" > $RUNNER_TEMP/whitelist.txt
-
-        # Configure Squid
-        sudo tee /etc/squid/squid.conf << EOF
-        http_port 127.0.0.1:3128
-        acl whitelist dstdomain "$RUNNER_TEMP/whitelist.txt"
-        acl localhost src 127.0.0.1/32
-        http_access allow localhost whitelist
-        http_access deny all
-        cache deny all
-        EOF
-
-        # Stop any existing squid instance and start with our config
-        sudo squid -k shutdown || true
-        sleep 2
-        sudo rm -f /run/squid.pid
-        sudo squid -N -d 1 &
-        sleep 5
-
-        # Set proxy environment variables
-        echo "http_proxy=http://127.0.0.1:3128" >> $GITHUB_ENV
-        echo "https_proxy=http://127.0.0.1:3128" >> $GITHUB_ENV
-        echo "HTTP_PROXY=http://127.0.0.1:3128" >> $GITHUB_ENV
-        echo "HTTPS_PROXY=http://127.0.0.1:3128" >> $GITHUB_ENV
+        chmod +x ${GITHUB_ACTION_PATH}/scripts/setup-network-restrictions.sh
+        ${GITHUB_ACTION_PATH}/scripts/setup-network-restrictions.sh
+      env:
+        EXPERIMENTAL_ALLOWED_DOMAINS: ${{ inputs.experimental_allowed_domains }}

    - name: Run Claude Code
      id: claude-code
      if: steps.prepare.outputs.contains_trigger == 'true'
      shell: bash
      run: |
+
        # Run the base-action
-        cd ${GITHUB_ACTION_PATH}/base-action
-        bun install
-        cd -
        bun run ${GITHUB_ACTION_PATH}/base-action/src/index.ts
      env:
        # Base-action inputs
--- a/base-action/action.yml
+++ b/base-action/action.yml
@@ -113,6 +113,10 @@ runs:
        cd ${GITHUB_ACTION_PATH}
        bun install

+    - name: Install Claude Code
+      shell: bash
+      run: bun install -g @anthropic-ai/claude-code@1.0.66
+
    - name: Run Claude Code Action
      shell: bash
      id: run_claude
--- a/base-action/bun.lock
+++ b/base-action/bun.lock
@@ -5,7 +5,6 @@
      "name": "@anthropic-ai/claude-code-base-action",
      "dependencies": {
        "@actions/core": "^1.10.1",
-        "@anthropic-ai/claude-code": "1.0.58",
      },
      "devDependencies": {
        "@types/bun": "^1.2.12",
@@ -24,39 +23,19 @@

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

-    "@anthropic-ai/claude-code": ["@anthropic-ai/claude-code@1.0.58", "", { "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-win32-x64": "^0.33.5" }, "bin": { "claude": "cli.js" } }, "sha512-XcfqklHSCuBRpVV9vZaAGvdJFAyVKb/UHz2VG9osvn1pRqY7e+HhIOU9X7LeI+c116QhmjglGwe+qz4jOC83CQ=="],
-
    "@fastify/busboy": ["@fastify/busboy@2.1.1", "", {}, "sha512-vBZP4NlzfOlerQTnba4aqZoMhE/a9HY7HRqoOPaETQcSQuWEIyZMHGfVu6w9wGtGK5fED5qRs2DteVCjOH60sA=="],

-    "@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=="],
+    "@types/bun": ["@types/bun@1.2.19", "", { "dependencies": { "bun-types": "1.2.19" } }, "sha512-d9ZCmrH3CJ2uYKXQIUuZ/pUnTqIvLDS0SK7pFmbx8ma+ziH/FRMoAq5bYpRG7y+w1gl+HgyNZbtqgMq4W4e2Lg=="],

-    "@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=="],
+    "@types/node": ["@types/node@20.19.9", "", { "dependencies": { "undici-types": "~6.21.0" } }, "sha512-cuVNgarYWZqxRJDQHEB58GEONhOK79QVR/qYx4S7kcUObQvUwvFnYxJuuHUKm2aieN9X3yZB4LZsuYNU1Qphsw=="],

-    "@img/sharp-libvips-darwin-arm64": ["@img/sharp-libvips-darwin-arm64@1.0.4", "", { "os": "darwin", "cpu": "arm64" }, "sha512-XblONe153h0O2zuFfTAbQYAX2JhYmDHeWikp1LM9Hul9gVPjFY427k6dFEcOL72O01QxQsWi761svJ/ev9xEDg=="],
+    "@types/react": ["@types/react@19.1.8", "", { "dependencies": { "csstype": "^3.0.2" } }, "sha512-AwAfQ2Wa5bCx9WP8nZL2uMZWod7J7/JSplxbTmBQ5ms6QpqNYm672H0Vu9ZVKVngQ+ii4R/byguVEUZQyeg44g=="],

-    "@img/sharp-libvips-darwin-x64": ["@img/sharp-libvips-darwin-x64@1.0.4", "", { "os": "darwin", "cpu": "x64" }, "sha512-xnGR8YuZYfJGmWPvmlunFaWJsb9T/AO2ykoP3Fz/0X5XV2aoYBPkX6xqCQvUTKKiLddarLaxpzNe+b1hjeWHAQ=="],
+    "bun-types": ["bun-types@1.2.19", "", { "dependencies": { "@types/node": "*" }, "peerDependencies": { "@types/react": "^19" } }, "sha512-uAOTaZSPuYsWIXRpj7o56Let0g/wjihKCkeRqUBhlLVM/Bt+Fj9xTo+LhC1OV1XDaGkz4hNC80et5xgy+9KTHQ=="],

-    "@img/sharp-libvips-linux-arm": ["@img/sharp-libvips-linux-arm@1.0.5", "", { "os": "linux", "cpu": "arm" }, "sha512-gvcC4ACAOPRNATg/ov8/MnbxFDJqf/pDePbBnuBDcjsI8PssmjoKMAz4LtLaVi+OnSb5FK/yIOamqDwGmXW32g=="],
+    "csstype": ["csstype@3.1.3", "", {}, "sha512-M1uQkMl8rQK/szD0LNhtqxIPLpimGm8sOBwU7lLnCpSbTyY3yeU1Vc7l4KT5zT4s/yOxHH5O7tIuuLOCnLADRw=="],

-    "@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-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-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.12", "", { "dependencies": { "bun-types": "1.2.12" } }, "sha512-lY/GQTXDGsolT/TiH72p1tuyUORuRrdV7VwOTOjDOt8uTBJQOJc5zz3ufwwDl0VBaoxotSk4LdP0hhjLJ6ypIQ=="],
-
-    "@types/node": ["@types/node@20.17.32", "", { "dependencies": { "undici-types": "~6.19.2" } }, "sha512-zeMXFn8zQ+UkjK4ws0RiOC9EWByyW1CcVmLe+2rQocXRsGEDxUCwPEIVgpsGcLHS/P8JkT0oa3839BRABS0oPw=="],
-
-    "bun-types": ["bun-types@1.2.12", "", { "dependencies": { "@types/node": "*" } }, "sha512-tvWMx5vPqbRXgE8WUZI94iS1xAYs8bkqESR9cxBB1Wi+urvfTrF1uzuDgBHFAdO0+d2lmsbG3HmeKMvUyj6pWA=="],
-
-    "prettier": ["prettier@3.5.3", "", { "bin": "bin/prettier.cjs" }, "sha512-QQtaxnoDJeAkDvDKWCLiwIXkTgRhwYDEQCghU9Z6q03iyek/rxRh/2lC3HB7P8sWT2xC/y5JDctPLBIGzHKbhw=="],
+    "prettier": ["prettier@3.5.3", "", { "bin": { "prettier": "bin/prettier.cjs" } }, "sha512-QQtaxnoDJeAkDvDKWCLiwIXkTgRhwYDEQCghU9Z6q03iyek/rxRh/2lC3HB7P8sWT2xC/y5JDctPLBIGzHKbhw=="],

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

@@ -64,6 +43,6 @@

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

-    "undici-types": ["undici-types@6.19.8", "", {}, "sha512-ve2KP6f/JnbPBFyobGHuerC9g1FYGn/F8n1LWTwNxCEzd6IfqTwUQcNXgEtmmQ6DlRrC1hrSrBnCZPokRrDHjw=="],
+    "undici-types": ["undici-types@6.21.0", "", {}, "sha512-iwDZqg0QAGrg9Rav5H4n0M64c3mkR59cJ6wQp+7C4nI0gsmExaedaYLNO44eT4AtBBwjbTiGPMlt2Md0T9H9JQ=="],
  }
 }
--- a/base-action/package.json
+++ b/base-action/package.json
@@ -10,8 +10,7 @@
    "typecheck": "tsc --noEmit"
  },
  "dependencies": {
-    "@actions/core": "^1.10.1",
-    "@anthropic-ai/claude-code": "1.0.58"
+    "@actions/core": "^1.10.1"
  },
  "devDependencies": {
    "@types/bun": "^1.2.12",
--- a/base-action/src/run-claude.ts
+++ b/base-action/src/run-claude.ts
@@ -1,12 +1,15 @@
 import * as core from "@actions/core";
-import { writeFile } from "fs/promises";
-import {
-  query,
-  type SDKMessage,
-  type Options,
-} from "@anthropic-ai/claude-code";
+import { exec } from "child_process";
+import { promisify } from "util";
+import { unlink, writeFile, stat } from "fs/promises";
+import { createWriteStream } from "fs";
+import { spawn } from "child_process";

+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 = ["-p", "--verbose", "--output-format", "stream-json"];

 export type ClaudeOptions = {
  allowedTools?: string;
@@ -21,7 +24,13 @@ export type ClaudeOptions = {
  model?: string;
 };

-export function parseCustomEnvVars(claudeEnv?: string): Record<string, string> {
+type PreparedConfig = {
+  claudeArgs: string[];
+  promptPath: string;
+  env: Record<string, string>;
+};
+
+function parseCustomEnvVars(claudeEnv?: string): Record<string, string> {
  if (!claudeEnv || claudeEnv.trim() === "") {
    return {};
  }
@@ -53,57 +62,18 @@ export function parseCustomEnvVars(claudeEnv?: string): Record<string, string> {
  return customEnv;
 }

-export function parseTools(toolsString?: string): string[] | undefined {
-  if (!toolsString || toolsString.trim() === "") {
-    return undefined;
-  }
-  return toolsString
-    .split(",")
-    .map((tool) => tool.trim())
-    .filter(Boolean);
-}
-
-export function parseMcpConfig(
-  mcpConfigString?: string,
-): Record<string, any> | undefined {
-  if (!mcpConfigString || mcpConfigString.trim() === "") {
-    return undefined;
-  }
-  try {
-    return JSON.parse(mcpConfigString);
-  } catch (e) {
-    core.warning(`Failed to parse MCP config: ${e}`);
-    return undefined;
-  }
-}
-
-export async function runClaude(promptPath: string, options: ClaudeOptions) {
-  // Read prompt from file
-  const prompt = await Bun.file(promptPath).text();
-
-  // Parse options
-  const customEnv = parseCustomEnvVars(options.claudeEnv);
-
-  // Apply custom environment variables
-  for (const [key, value] of Object.entries(customEnv)) {
-    process.env[key] = value;
-  }
-
-  // Set up SDK options
-  const sdkOptions: Options = {
-    cwd: process.cwd(),
-    // Use bun as the executable since we're in a Bun environment
-    executable: "bun",
-  };
+export function prepareRunConfig(
+  promptPath: string,
+  options: ClaudeOptions,
+): PreparedConfig {
+  const claudeArgs = [...BASE_ARGS];

  if (options.allowedTools) {
-    sdkOptions.allowedTools = parseTools(options.allowedTools);
+    claudeArgs.push("--allowedTools", options.allowedTools);
  }
-
  if (options.disallowedTools) {
-    sdkOptions.disallowedTools = parseTools(options.disallowedTools);
+    claudeArgs.push("--disallowedTools", options.disallowedTools);
  }
-
  if (options.maxTurns) {
    const maxTurnsNum = parseInt(options.maxTurns, 10);
    if (isNaN(maxTurnsNum) || maxTurnsNum <= 0) {
@@ -111,34 +81,23 @@ export async function runClaude(promptPath: string, options: ClaudeOptions) {
        `maxTurns must be a positive number, got: ${options.maxTurns}`,
      );
    }
-    sdkOptions.maxTurns = maxTurnsNum;
+    claudeArgs.push("--max-turns", options.maxTurns);
  }
-
  if (options.mcpConfig) {
-    const mcpConfig = parseMcpConfig(options.mcpConfig);
-    if (mcpConfig?.mcpServers) {
-      sdkOptions.mcpServers = mcpConfig.mcpServers;
-    }
+    claudeArgs.push("--mcp-config", options.mcpConfig);
  }
-
  if (options.systemPrompt) {
-    sdkOptions.customSystemPrompt = options.systemPrompt;
+    claudeArgs.push("--system-prompt", options.systemPrompt);
  }
-
  if (options.appendSystemPrompt) {
-    sdkOptions.appendSystemPrompt = options.appendSystemPrompt;
+    claudeArgs.push("--append-system-prompt", options.appendSystemPrompt);
  }
-
  if (options.fallbackModel) {
-    sdkOptions.fallbackModel = options.fallbackModel;
+    claudeArgs.push("--fallback-model", options.fallbackModel);
  }
-
  if (options.model) {
-    sdkOptions.model = options.model;
+    claudeArgs.push("--model", options.model);
  }
-
-  // Set up timeout
-  let timeoutMs = 10 * 60 * 1000; // Default 10 minutes
  if (options.timeoutMinutes) {
    const timeoutMinutesNum = parseInt(options.timeoutMinutes, 10);
    if (isNaN(timeoutMinutesNum) || timeoutMinutesNum <= 0) {
@@ -146,7 +105,126 @@ export async function runClaude(promptPath: string, options: ClaudeOptions) {
        `timeoutMinutes must be a positive number, got: ${options.timeoutMinutes}`,
      );
    }
-    timeoutMs = timeoutMinutesNum * 60 * 1000;
+  }
+
+  // Parse custom environment variables
+  const customEnv = parseCustomEnvVars(options.claudeEnv);
+
+  return {
+    claudeArgs,
+    promptPath,
+    env: customEnv,
+  };
+}
+
+export async function runClaude(promptPath: string, options: ClaudeOptions) {
+  const config = prepareRunConfig(promptPath, options);
+
+  // 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
+  if (Object.keys(config.env).length > 0) {
+    const envKeys = Object.keys(config.env).join(", ");
+    console.log(`Custom environment variables: ${envKeys}`);
+  }
+
+  // Output to console
+  console.log(`Running Claude with prompt from file: ${config.promptPath}`);
+
+  // 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();
+  });
+
+  const claudeProcess = spawn("claude", 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();
+  });
+
+  // Capture output for parsing execution metrics
+  let output = "";
+  claudeProcess.stdout.on("data", (data) => {
+    const text = data.toString();
+
+    // Try to parse as JSON and pretty print if it's on a single line
+    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 prettyJson = JSON.stringify(parsed, null, 2);
+        process.stdout.write(prettyJson);
+        if (index < lines.length - 1 || text.endsWith("\n")) {
+          process.stdout.write("\n");
+        }
+      } catch (e) {
+        // Not a JSON object, print as is
+        process.stdout.write(line);
+        if (index < lines.length - 1 || text.endsWith("\n")) {
+          process.stdout.write("\n");
+        }
+      }
+    });
+
+    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 with timeout
+  let timeoutMs = 10 * 60 * 1000; // Default 10 minutes
+  if (options.timeoutMinutes) {
+    timeoutMs = parseInt(options.timeoutMinutes, 10) * 60 * 1000;
  } else if (process.env.INPUT_TIMEOUT_MINUTES) {
    const envTimeout = parseInt(process.env.INPUT_TIMEOUT_MINUTES, 10);
    if (isNaN(envTimeout) || envTimeout <= 0) {
@@ -156,76 +234,98 @@ export async function runClaude(promptPath: string, options: ClaudeOptions) {
    }
    timeoutMs = envTimeout * 60 * 1000;
  }
+  const exitCode = await new Promise<number>((resolve) => {
+    let resolved = false;

-  // Create abort controller for timeout
-  const abortController = new AbortController();
-  const timeoutId = setTimeout(() => {
-    console.error(`Claude process timed out after ${timeoutMs / 1000} seconds`);
-    abortController.abort();
-  }, timeoutMs);
+    // Set a timeout for the process
+    const timeoutId = setTimeout(() => {
+      if (!resolved) {
+        console.error(
+          `Claude process timed out after ${timeoutMs / 1000} seconds`,
+        );
+        claudeProcess.kill("SIGTERM");
+        // Give it 5 seconds to terminate gracefully, then force kill
+        setTimeout(() => {
+          try {
+            claudeProcess.kill("SIGKILL");
+          } catch (e) {
+            // Process may already be dead
+          }
+        }, 5000);
+        resolved = true;
+        resolve(124); // Standard timeout exit code
+      }
+    }, timeoutMs);

-  sdkOptions.abortController = abortController;
+    claudeProcess.on("close", (code) => {
+      if (!resolved) {
+        clearTimeout(timeoutId);
+        resolved = true;
+        resolve(code || 0);
+      }
+    });

-  // Add stderr handler to capture CLI errors
-  sdkOptions.stderr = (data: string) => {
-    console.error("Claude CLI stderr:", data);
-  };
+    claudeProcess.on("error", (error) => {
+      if (!resolved) {
+        console.error("Claude process error:", error);
+        clearTimeout(timeoutId);
+        resolved = true;
+        resolve(1);
+      }
+    });
+  });

-  console.log(`Running Claude with prompt from file: ${promptPath}`);
-
-  // Log custom environment variables if any
-  if (Object.keys(customEnv).length > 0) {
-    const envKeys = Object.keys(customEnv).join(", ");
-    console.log(`Custom environment variables: ${envKeys}`);
+  // 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
  }

-  const messages: SDKMessage[] = [];
-  let executionFailed = false;
-
+  // Clean up pipe file
  try {
-    // Execute the query
-    for await (const message of query({
-      prompt,
-      abortController,
-      options: sdkOptions,
-    })) {
-      messages.push(message);
+    await unlink(PIPE_PATH);
+  } catch (e) {
+    // Ignore errors during cleanup
+  }

-      // Pretty print the message to stdout
-      const prettyJson = JSON.stringify(message, null, 2);
-      console.log(prettyJson);
+  // Set conclusion based on exit code
+  if (exitCode === 0) {
+    // Try to process the output and save execution metrics
+    try {
+      await writeFile("output.txt", output);

-      // Check if execution failed
-      if (message.type === "result" && message.is_error) {
-        executionFailed = true;
+      // Process output.txt into JSON and save to execution file
+      const { stdout: jsonOutput } = await execAsync("jq -s '.' output.txt");
+      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("conclusion", "success");
+    core.setOutput("execution_file", EXECUTION_FILE);
+  } else {
+    core.setOutput("conclusion", "failure");
+
+    // Still try to save execution file if we have output
+    if (output) {
+      try {
+        await writeFile("output.txt", output);
+        const { stdout: jsonOutput } = await execAsync("jq -s '.' output.txt");
+        await writeFile(EXECUTION_FILE, jsonOutput);
+        core.setOutput("execution_file", EXECUTION_FILE);
+      } catch (e) {
+        // Ignore errors when processing output during failure
      }
    }
-  } catch (error) {
-    console.error("Error during Claude execution:", error);
-    executionFailed = true;

-    // Add error to messages if it's not an abort
-    if (error instanceof Error && error.name !== "AbortError") {
-      throw error;
-    }
-  } finally {
-    clearTimeout(timeoutId);
-  }
-
-  // Save execution output
-  try {
-    await writeFile(EXECUTION_FILE, JSON.stringify(messages, null, 2));
-    console.log(`Log saved to ${EXECUTION_FILE}`);
-    core.setOutput("execution_file", EXECUTION_FILE);
-  } catch (e) {
-    core.warning(`Failed to save execution file: ${e}`);
-  }
-
-  // Set conclusion
-  if (executionFailed) {
-    core.setOutput("conclusion", "failure");
-    process.exit(1);
-  } else {
-    core.setOutput("conclusion", "success");
+    process.exit(exitCode);
  }
 }
--- a/base-action/test/run-claude.test.ts
+++ b/base-action/test/run-claude.test.ts
@@ -1,260 +1,297 @@
 #!/usr/bin/env bun

-import {
-  describe,
-  test,
-  expect,
-  beforeAll,
-  afterAll,
-  afterEach,
-} from "bun:test";
-import {
-  runClaude,
-  type ClaudeOptions,
-  parseCustomEnvVars,
-  parseTools,
-  parseMcpConfig,
-} from "../src/run-claude";
-import { writeFile, unlink } from "fs/promises";
-import { join } from "path";
+import { describe, test, expect } from "bun:test";
+import { prepareRunConfig, type ClaudeOptions } from "../src/run-claude";

-// Since we can't easily mock the SDK, let's focus on testing input validation
-// and error cases that happen before the SDK is called
+describe("prepareRunConfig", () => {
+  test("should prepare config with basic arguments", () => {
+    const options: ClaudeOptions = {};
+    const prepared = prepareRunConfig("/tmp/test-prompt.txt", options);

-describe("runClaude input validation", () => {
-  const testPromptPath = join(
-    process.env.RUNNER_TEMP || "/tmp",
-    "test-prompt-claude.txt",
-  );
-
-  // Create a test prompt file before tests
-  beforeAll(async () => {
-    await writeFile(testPromptPath, "Test prompt content");
+    expect(prepared.claudeArgs.slice(0, 4)).toEqual([
+      "-p",
+      "--verbose",
+      "--output-format",
+      "stream-json",
+    ]);
  });

-  // Clean up after tests
-  afterAll(async () => {
-    try {
-      await unlink(testPromptPath);
-    } catch (e) {
-      // Ignore if file doesn't exist
-    }
+  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 include allowed tools in command arguments", () => {
+    const options: ClaudeOptions = {
+      allowedTools: "Bash,Read",
+    };
+    const prepared = prepareRunConfig("/tmp/test-prompt.txt", options);
+
+    expect(prepared.claudeArgs).toContain("--allowedTools");
+    expect(prepared.claudeArgs).toContain("Bash,Read");
+  });
+
+  test("should include disallowed tools in command arguments", () => {
+    const options: ClaudeOptions = {
+      disallowedTools: "Bash,Read",
+    };
+    const prepared = prepareRunConfig("/tmp/test-prompt.txt", options);
+
+    expect(prepared.claudeArgs).toContain("--disallowedTools");
+    expect(prepared.claudeArgs).toContain("Bash,Read");
+  });
+
+  test("should include max turns in command arguments", () => {
+    const options: ClaudeOptions = {
+      maxTurns: "5",
+    };
+    const prepared = prepareRunConfig("/tmp/test-prompt.txt", options);
+
+    expect(prepared.claudeArgs).toContain("--max-turns");
+    expect(prepared.claudeArgs).toContain("5");
+  });
+
+  test("should include mcp config in command arguments", () => {
+    const options: ClaudeOptions = {
+      mcpConfig: "/path/to/mcp-config.json",
+    };
+    const prepared = prepareRunConfig("/tmp/test-prompt.txt", options);
+
+    expect(prepared.claudeArgs).toContain("--mcp-config");
+    expect(prepared.claudeArgs).toContain("/path/to/mcp-config.json");
+  });
+
+  test("should include system prompt in command arguments", () => {
+    const options: ClaudeOptions = {
+      systemPrompt: "You are a senior backend engineer.",
+    };
+    const prepared = prepareRunConfig("/tmp/test-prompt.txt", options);
+
+    expect(prepared.claudeArgs).toContain("--system-prompt");
+    expect(prepared.claudeArgs).toContain("You are a senior backend engineer.");
+  });
+
+  test("should include append system prompt in command arguments", () => {
+    const options: ClaudeOptions = {
+      appendSystemPrompt:
+        "After writing code, be sure to code review yourself.",
+    };
+    const prepared = prepareRunConfig("/tmp/test-prompt.txt", options);
+
+    expect(prepared.claudeArgs).toContain("--append-system-prompt");
+    expect(prepared.claudeArgs).toContain(
+      "After writing code, be sure to code review yourself.",
+    );
+  });
+
+  test("should include fallback model in command arguments", () => {
+    const options: ClaudeOptions = {
+      fallbackModel: "claude-sonnet-4-20250514",
+    };
+    const prepared = prepareRunConfig("/tmp/test-prompt.txt", options);
+
+    expect(prepared.claudeArgs).toContain("--fallback-model");
+    expect(prepared.claudeArgs).toContain("claude-sonnet-4-20250514");
+  });
+
+  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");
+  });
+
+  test("should not include optional arguments when not set", () => {
+    const options: ClaudeOptions = {};
+    const prepared = prepareRunConfig("/tmp/test-prompt.txt", options);
+
+    expect(prepared.claudeArgs).not.toContain("--allowedTools");
+    expect(prepared.claudeArgs).not.toContain("--disallowedTools");
+    expect(prepared.claudeArgs).not.toContain("--max-turns");
+    expect(prepared.claudeArgs).not.toContain("--mcp-config");
+    expect(prepared.claudeArgs).not.toContain("--system-prompt");
+    expect(prepared.claudeArgs).not.toContain("--append-system-prompt");
+    expect(prepared.claudeArgs).not.toContain("--fallback-model");
+  });
+
+  test("should preserve order of claude arguments", () => {
+    const options: ClaudeOptions = {
+      allowedTools: "Bash,Read",
+      maxTurns: "3",
+    };
+    const prepared = prepareRunConfig("/tmp/test-prompt.txt", options);
+
+    expect(prepared.claudeArgs).toEqual([
+      "-p",
+      "--verbose",
+      "--output-format",
+      "stream-json",
+      "--allowedTools",
+      "Bash,Read",
+      "--max-turns",
+      "3",
+    ]);
+  });
+
+  test("should preserve order with all options including fallback model", () => {
+    const options: ClaudeOptions = {
+      allowedTools: "Bash,Read",
+      disallowedTools: "Write",
+      maxTurns: "3",
+      mcpConfig: "/path/to/config.json",
+      systemPrompt: "You are a helpful assistant",
+      appendSystemPrompt: "Be concise",
+      fallbackModel: "claude-sonnet-4-20250514",
+    };
+    const prepared = prepareRunConfig("/tmp/test-prompt.txt", options);
+
+    expect(prepared.claudeArgs).toEqual([
+      "-p",
+      "--verbose",
+      "--output-format",
+      "stream-json",
+      "--allowedTools",
+      "Bash,Read",
+      "--disallowedTools",
+      "Write",
+      "--max-turns",
+      "3",
+      "--mcp-config",
+      "/path/to/config.json",
+      "--system-prompt",
+      "You are a helpful assistant",
+      "--append-system-prompt",
+      "Be concise",
+      "--fallback-model",
+      "claude-sonnet-4-20250514",
+    ]);
  });

  describe("maxTurns validation", () => {
-    test("should throw error for non-numeric maxTurns", async () => {
+    test("should accept valid maxTurns value", () => {
+      const options: ClaudeOptions = { maxTurns: "5" };
+      const prepared = prepareRunConfig("/tmp/test-prompt.txt", options);
+      expect(prepared.claudeArgs).toContain("--max-turns");
+      expect(prepared.claudeArgs).toContain("5");
+    });
+
+    test("should throw error for non-numeric maxTurns", () => {
      const options: ClaudeOptions = { maxTurns: "abc" };
-      await expect(runClaude(testPromptPath, options)).rejects.toThrow(
+      expect(() => prepareRunConfig("/tmp/test-prompt.txt", options)).toThrow(
        "maxTurns must be a positive number, got: abc",
      );
    });

-    test("should throw error for negative maxTurns", async () => {
+    test("should throw error for negative maxTurns", () => {
      const options: ClaudeOptions = { maxTurns: "-1" };
-      await expect(runClaude(testPromptPath, options)).rejects.toThrow(
+      expect(() => prepareRunConfig("/tmp/test-prompt.txt", options)).toThrow(
        "maxTurns must be a positive number, got: -1",
      );
    });

-    test("should throw error for zero maxTurns", async () => {
+    test("should throw error for zero maxTurns", () => {
      const options: ClaudeOptions = { maxTurns: "0" };
-      await expect(runClaude(testPromptPath, options)).rejects.toThrow(
+      expect(() => prepareRunConfig("/tmp/test-prompt.txt", options)).toThrow(
        "maxTurns must be a positive number, got: 0",
      );
    });
  });

  describe("timeoutMinutes validation", () => {
-    test("should throw error for non-numeric timeoutMinutes", async () => {
+    test("should accept valid timeoutMinutes value", () => {
+      const options: ClaudeOptions = { timeoutMinutes: "15" };
+      expect(() =>
+        prepareRunConfig("/tmp/test-prompt.txt", options),
+      ).not.toThrow();
+    });
+
+    test("should throw error for non-numeric timeoutMinutes", () => {
      const options: ClaudeOptions = { timeoutMinutes: "abc" };
-      await expect(runClaude(testPromptPath, options)).rejects.toThrow(
+      expect(() => prepareRunConfig("/tmp/test-prompt.txt", options)).toThrow(
        "timeoutMinutes must be a positive number, got: abc",
      );
    });

-    test("should throw error for negative timeoutMinutes", async () => {
+    test("should throw error for negative timeoutMinutes", () => {
      const options: ClaudeOptions = { timeoutMinutes: "-5" };
-      await expect(runClaude(testPromptPath, options)).rejects.toThrow(
+      expect(() => prepareRunConfig("/tmp/test-prompt.txt", options)).toThrow(
        "timeoutMinutes must be a positive number, got: -5",
      );
    });

-    test("should throw error for zero timeoutMinutes", async () => {
+    test("should throw error for zero timeoutMinutes", () => {
      const options: ClaudeOptions = { timeoutMinutes: "0" };
-      await expect(runClaude(testPromptPath, options)).rejects.toThrow(
+      expect(() => prepareRunConfig("/tmp/test-prompt.txt", options)).toThrow(
        "timeoutMinutes must be a positive number, got: 0",
      );
    });
  });

-  describe("environment variable validation from INPUT_TIMEOUT_MINUTES", () => {
-    const originalEnv = process.env.INPUT_TIMEOUT_MINUTES;
-
-    afterEach(() => {
-      // Restore original value
-      if (originalEnv !== undefined) {
-        process.env.INPUT_TIMEOUT_MINUTES = originalEnv;
-      } else {
-        delete process.env.INPUT_TIMEOUT_MINUTES;
-      }
+  describe("custom environment variables", () => {
+    test("should parse empty claudeEnv correctly", () => {
+      const options: ClaudeOptions = { claudeEnv: "" };
+      const prepared = prepareRunConfig("/tmp/test-prompt.txt", options);
+      expect(prepared.env).toEqual({});
    });

-    test("should throw error for invalid INPUT_TIMEOUT_MINUTES", async () => {
-      process.env.INPUT_TIMEOUT_MINUTES = "invalid";
+    test("should parse single environment variable", () => {
+      const options: ClaudeOptions = { claudeEnv: "API_KEY: secret123" };
+      const prepared = prepareRunConfig("/tmp/test-prompt.txt", options);
+      expect(prepared.env).toEqual({ API_KEY: "secret123" });
+    });
+
+    test("should parse multiple environment variables", () => {
+      const options: ClaudeOptions = {
+        claudeEnv: "API_KEY: secret123\nDEBUG: true\nUSER: testuser",
+      };
+      const prepared = prepareRunConfig("/tmp/test-prompt.txt", options);
+      expect(prepared.env).toEqual({
+        API_KEY: "secret123",
+        DEBUG: "true",
+        USER: "testuser",
+      });
+    });
+
+    test("should handle environment variables with spaces around values", () => {
+      const options: ClaudeOptions = {
+        claudeEnv: "API_KEY:  secret123  \n  DEBUG  :  true  ",
+      };
+      const prepared = prepareRunConfig("/tmp/test-prompt.txt", options);
+      expect(prepared.env).toEqual({
+        API_KEY: "secret123",
+        DEBUG: "true",
+      });
+    });
+
+    test("should skip empty lines and comments", () => {
+      const options: ClaudeOptions = {
+        claudeEnv:
+          "API_KEY: secret123\n\n# This is a comment\nDEBUG: true\n# Another comment",
+      };
+      const prepared = prepareRunConfig("/tmp/test-prompt.txt", options);
+      expect(prepared.env).toEqual({
+        API_KEY: "secret123",
+        DEBUG: "true",
+      });
+    });
+
+    test("should skip lines without colons", () => {
+      const options: ClaudeOptions = {
+        claudeEnv: "API_KEY: secret123\nINVALID_LINE\nDEBUG: true",
+      };
+      const prepared = prepareRunConfig("/tmp/test-prompt.txt", options);
+      expect(prepared.env).toEqual({
+        API_KEY: "secret123",
+        DEBUG: "true",
+      });
+    });
+
+    test("should handle undefined claudeEnv", () => {
      const options: ClaudeOptions = {};
-      await expect(runClaude(testPromptPath, options)).rejects.toThrow(
-        "INPUT_TIMEOUT_MINUTES must be a positive number, got: invalid",
-      );
+      const prepared = prepareRunConfig("/tmp/test-prompt.txt", options);
+      expect(prepared.env).toEqual({});
    });
-
-    test("should throw error for zero INPUT_TIMEOUT_MINUTES", async () => {
-      process.env.INPUT_TIMEOUT_MINUTES = "0";
-      const options: ClaudeOptions = {};
-      await expect(runClaude(testPromptPath, options)).rejects.toThrow(
-        "INPUT_TIMEOUT_MINUTES must be a positive number, got: 0",
-      );
-    });
-  });
-
-  // Note: We can't easily test the full execution flow without either:
-  // 1. Mocking the SDK (which seems difficult with Bun's current mocking capabilities)
-  // 2. Having a valid API key and actually calling the API (not suitable for unit tests)
-  // 3. Refactoring the code to be more testable (e.g., dependency injection)
-
-  // For now, we're testing what we can: input validation that happens before the SDK call
-});
-
-describe("parseCustomEnvVars", () => {
-  test("should parse empty string correctly", () => {
-    expect(parseCustomEnvVars("")).toEqual({});
-  });
-
-  test("should parse single environment variable", () => {
-    expect(parseCustomEnvVars("API_KEY: secret123")).toEqual({
-      API_KEY: "secret123",
-    });
-  });
-
-  test("should parse multiple environment variables", () => {
-    const input = "API_KEY: secret123\nDEBUG: true\nUSER: testuser";
-    expect(parseCustomEnvVars(input)).toEqual({
-      API_KEY: "secret123",
-      DEBUG: "true",
-      USER: "testuser",
-    });
-  });
-
-  test("should handle environment variables with spaces around values", () => {
-    const input = "API_KEY:  secret123  \n  DEBUG  :  true  ";
-    expect(parseCustomEnvVars(input)).toEqual({
-      API_KEY: "secret123",
-      DEBUG: "true",
-    });
-  });
-
-  test("should skip empty lines and comments", () => {
-    const input =
-      "API_KEY: secret123\n\n# This is a comment\nDEBUG: true\n# Another comment";
-    expect(parseCustomEnvVars(input)).toEqual({
-      API_KEY: "secret123",
-      DEBUG: "true",
-    });
-  });
-
-  test("should skip lines without colons", () => {
-    const input = "API_KEY: secret123\nINVALID_LINE\nDEBUG: true";
-    expect(parseCustomEnvVars(input)).toEqual({
-      API_KEY: "secret123",
-      DEBUG: "true",
-    });
-  });
-
-  test("should handle undefined input", () => {
-    expect(parseCustomEnvVars(undefined)).toEqual({});
-  });
-
-  test("should handle whitespace-only input", () => {
-    expect(parseCustomEnvVars("  \n  \t  ")).toEqual({});
-  });
-});
-
-describe("parseTools", () => {
-  test("should return undefined for empty string", () => {
-    expect(parseTools("")).toBeUndefined();
-  });
-
-  test("should return undefined for whitespace-only string", () => {
-    expect(parseTools("  \t  ")).toBeUndefined();
-  });
-
-  test("should return undefined for undefined input", () => {
-    expect(parseTools(undefined)).toBeUndefined();
-  });
-
-  test("should parse single tool", () => {
-    expect(parseTools("Bash")).toEqual(["Bash"]);
-  });
-
-  test("should parse multiple tools", () => {
-    expect(parseTools("Bash,Read,Write")).toEqual(["Bash", "Read", "Write"]);
-  });
-
-  test("should trim whitespace around tools", () => {
-    expect(parseTools(" Bash , Read , Write ")).toEqual([
-      "Bash",
-      "Read",
-      "Write",
-    ]);
-  });
-
-  test("should filter out empty tool names", () => {
-    expect(parseTools("Bash,,Read,,,Write")).toEqual(["Bash", "Read", "Write"]);
-  });
-});
-
-describe("parseMcpConfig", () => {
-  test("should return undefined for empty string", () => {
-    expect(parseMcpConfig("")).toBeUndefined();
-  });
-
-  test("should return undefined for whitespace-only string", () => {
-    expect(parseMcpConfig("  \t  ")).toBeUndefined();
-  });
-
-  test("should return undefined for undefined input", () => {
-    expect(parseMcpConfig(undefined)).toBeUndefined();
-  });
-
-  test("should parse valid JSON", () => {
-    const config = { "test-server": { command: "test", args: ["--test"] } };
-    expect(parseMcpConfig(JSON.stringify(config))).toEqual(config);
-  });
-
-  test("should return undefined for invalid JSON", () => {
-    // Check console warning is logged
-    const originalWarn = console.warn;
-    const warnings: string[] = [];
-    console.warn = (msg: string) => warnings.push(msg);
-
-    expect(parseMcpConfig("{ invalid json")).toBeUndefined();
-
-    console.warn = originalWarn;
-  });
-
-  test("should parse complex MCP config", () => {
-    const config = {
-      "github-mcp": {
-        command: "npx",
-        args: ["-y", "@modelcontextprotocol/server-github"],
-        env: {
-          GITHUB_TOKEN: "test-token",
-        },
-      },
-      "filesystem-mcp": {
-        command: "npx",
-        args: ["-y", "@modelcontextprotocol/server-filesystem", "/tmp"],
-      },
-    };
-    expect(parseMcpConfig(JSON.stringify(config))).toEqual(config);
  });
 });
--- a/bun.lock
+++ b/bun.lock
@@ -6,7 +6,6 @@
      "dependencies": {
        "@actions/core": "^1.10.1",
        "@actions/github": "^6.0.1",
-        "@anthropic-ai/claude-code": "1.0.57",
        "@modelcontextprotocol/sdk": "^1.11.0",
        "@octokit/graphql": "^8.2.2",
        "@octokit/rest": "^21.1.1",
@@ -34,43 +33,19 @@

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

-    "@anthropic-ai/claude-code": ["@anthropic-ai/claude-code@1.0.57", "", { "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-win32-x64": "^0.33.5" }, "bin": { "claude": "cli.js" } }, "sha512-zMymGZzjG+JO9iKC5N5pAy8AxyHIMPCL6U3HYCR3vCj5M+Y0s3GAMma6GkvCXWFixRN6KSZItKw3HbQiaIBYlw=="],
-
    "@fastify/busboy": ["@fastify/busboy@2.1.1", "", {}, "sha512-vBZP4NlzfOlerQTnba4aqZoMhE/a9HY7HRqoOPaETQcSQuWEIyZMHGfVu6w9wGtGK5fED5qRs2DteVCjOH60sA=="],

-    "@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-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-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.11.0", "", { "dependencies": { "content-type": "^1.0.5", "cors": "^2.8.5", "cross-spawn": "^7.0.3", "eventsource": "^3.0.2", "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-k/1pb70eD638anoi0e8wUGAlbMJXyvdV4p62Ko+EZ7eBe1xMx8Uhak1R5DgfoofsK5IBBnRwsYGTaLZl+6/+RQ=="],
+    "@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=="],

    "@octokit/auth-token": ["@octokit/auth-token@4.0.0", "", {}, "sha512-tY/msAuJo6ARbK6SPIxZrPBms3xPbfwBrulZe0Wtr/DIY9lje2HeV1uoebShn6mx7SjCHif6EjMvoREj+gZ+SA=="],

-    "@octokit/core": ["@octokit/core@5.2.1", "", { "dependencies": { "@octokit/auth-token": "^4.0.0", "@octokit/graphql": "^7.1.0", "@octokit/request": "^8.4.1", "@octokit/request-error": "^5.1.1", "@octokit/types": "^13.0.0", "before-after-hook": "^2.2.0", "universal-user-agent": "^6.0.0" } }, "sha512-dKYCMuPO1bmrpuogcjQ8z7ICCH3FP6WmxpwC03yjzGfZhj9fTJg6+bS1+UAplekbN2C+M61UNllGOOoAfGCrdQ=="],
+    "@octokit/core": ["@octokit/core@5.2.2", "", { "dependencies": { "@octokit/auth-token": "^4.0.0", "@octokit/graphql": "^7.1.0", "@octokit/request": "^8.4.1", "@octokit/request-error": "^5.1.1", "@octokit/types": "^13.0.0", "before-after-hook": "^2.2.0", "universal-user-agent": "^6.0.0" } }, "sha512-/g2d4sW9nUDJOMz3mabVQvOGhVa4e/BN/Um7yca9Bb2XTzPPnfTWHWQg+IsEYO7M3Vx+EXvaM/I2pJWIMun1bg=="],

    "@octokit/endpoint": ["@octokit/endpoint@9.0.6", "", { "dependencies": { "@octokit/types": "^13.1.0", "universal-user-agent": "^6.0.0" } }, "sha512-H1fNTMA57HbkFESSt3Y9+FBICv+0jFceJFPWDePYlR/iMGrwM5ph+Dd4XRQs+8X+PUFURLQgX9ChPfhJ/1uNQw=="],

    "@octokit/graphql": ["@octokit/graphql@8.2.2", "", { "dependencies": { "@octokit/request": "^9.2.3", "@octokit/types": "^14.0.0", "universal-user-agent": "^7.0.0" } }, "sha512-Yi8hcoqsrXGdt0yObxbebHXFOiUA+2v3n53epuOg1QUgOB6c4XzvisBNVXJSl8RYA5KrDuSL2yq9Qmqe5N0ryA=="],

-    "@octokit/openapi-types": ["@octokit/openapi-types@25.0.0", "", {}, "sha512-FZvktFu7HfOIJf2BScLKIEYjDsw6RKc7rBJCdvCTfKsVnx2GEB/Nbzjr29DUdb7vQhlzS/j8qDzdditP0OC6aw=="],
+    "@octokit/openapi-types": ["@octokit/openapi-types@25.1.0", "", {}, "sha512-idsIggNXUKkk0+BExUn1dQ92sfysJrje03Q0bv0e+KPLrvyqZF8MnBpFz8UNfYDwB3Ie7Z0TByjWfzxt7vseaA=="],

    "@octokit/plugin-paginate-rest": ["@octokit/plugin-paginate-rest@9.2.2", "", { "dependencies": { "@octokit/types": "^12.6.0" }, "peerDependencies": { "@octokit/core": "5" } }, "sha512-u3KYkGF7GcZnSD/3UP0S7K5XUFT2FkOQdcfXZGZQPGv3lm4F2Xbf71lvjldr8c1H3nNbF+33cLEkWYbokGWqiQ=="],

@@ -84,18 +59,20 @@

    "@octokit/rest": ["@octokit/rest@21.1.1", "", { "dependencies": { "@octokit/core": "^6.1.4", "@octokit/plugin-paginate-rest": "^11.4.2", "@octokit/plugin-request-log": "^5.3.1", "@octokit/plugin-rest-endpoint-methods": "^13.3.0" } }, "sha512-sTQV7va0IUVZcntzy1q3QqPm/r8rWtDCqpRAmb8eXXnKkjoQEtFe3Nt5GTVsHft+R6jJoHeSiVLcgcvhtue/rg=="],

-    "@octokit/types": ["@octokit/types@14.0.0", "", { "dependencies": { "@octokit/openapi-types": "^25.0.0" } }, "sha512-VVmZP0lEhbo2O1pdq63gZFiGCKkm8PPp8AUOijlwPO6hojEVjspA0MWKP7E4hbvGxzFKNqKr6p0IYtOH/Wf/zA=="],
+    "@octokit/types": ["@octokit/types@14.1.0", "", { "dependencies": { "@octokit/openapi-types": "^25.1.0" } }, "sha512-1y6DgTy8Jomcpu33N+p5w58l6xyt55Ar2I91RPiIA0xCJBXyUAhXCcmZaDWSANiha7R9a6qJJ2CRomGPZ6f46g=="],

    "@octokit/webhooks-types": ["@octokit/webhooks-types@7.6.1", "", {}, "sha512-S8u2cJzklBC0FgTwWVLaM8tMrDuDMVE4xiTK4EYXM9GntyvrdbSoxqDQa+Fh57CCNApyIpyeqPhhFEmHPfrXgw=="],

    "@types/bun": ["@types/bun@1.2.11", "", { "dependencies": { "bun-types": "1.2.11" } }, "sha512-ZLbbI91EmmGwlWTRWuV6J19IUiUC5YQ3TCEuSHI3usIP75kuoA8/0PVF+LTrbEnVc8JIhpElWOxv1ocI1fJBbw=="],

-    "@types/node": ["@types/node@20.17.44", "", { "dependencies": { "undici-types": "~6.19.2" } }, "sha512-50sE4Ibb4BgUMxHrcJQSAU0Fu7fLcTdwcXwRzEF7wnVMWvImFLg2Rxc7SW0vpvaJm4wvhoWEZaQiPpBpocZiUA=="],
+    "@types/node": ["@types/node@20.19.9", "", { "dependencies": { "undici-types": "~6.21.0" } }, "sha512-cuVNgarYWZqxRJDQHEB58GEONhOK79QVR/qYx4S7kcUObQvUwvFnYxJuuHUKm2aieN9X3yZB4LZsuYNU1Qphsw=="],

    "@types/node-fetch": ["@types/node-fetch@2.6.12", "", { "dependencies": { "@types/node": "*", "form-data": "^4.0.0" } }, "sha512-8nneRWKCg3rMtF69nLQJnOYUcbafYeFSjqkw3jCRLsqkWFlHaoQrr5mXmofFGOx3DKn7UfmBMyov8ySvLRVldA=="],

    "accepts": ["accepts@2.0.0", "", { "dependencies": { "mime-types": "^3.0.0", "negotiator": "^1.0.0" } }, "sha512-5cvg6CtKwfgdmVqY1WIiXKc3Q1bkRqGLi+2W/6ao+6Y7gu/RCwRuAhGEzh5B4KlszSuTLgZYuqFqo5bImjNKng=="],

+    "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=="],
+
    "asynckit": ["asynckit@0.4.0", "", {}, "sha512-Oei9OH4tRh0YqU3GxhX79dM/mwVgvbZJaSNaRk+bshkj0S5cfHcgYakreBjrHwatXKbz+IoIdYLxrKim2MjW0Q=="],

    "before-after-hook": ["before-after-hook@2.2.3", "", {}, "sha512-NzUnlZexiaH/46WDhANlyR2bXRopNg4F/zuSA3OpZnllCUgRaOF2znDioDWrmbNVsuZk6l9pMquQB38cfBZwkQ=="],
@@ -126,7 +103,7 @@

    "data-uri-to-buffer": ["data-uri-to-buffer@4.0.1", "", {}, "sha512-0R9ikRb668HB7QDxT1vkpuUBtqc53YyAwMwGeUFKRojY/NWKvdZ+9UYtRfGmhqNbRkTSVpMbmyhXipFFv2cb/A=="],

-    "debug": ["debug@4.4.0", "", { "dependencies": { "ms": "^2.1.3" } }, "sha512-6WTZ/IxCY/T6BALoZHaE4ctp9xm+Z5kY/pzYaCHRFeyVhojxlrm+46y68HA6hr0TcwEssoxNiDEUJQjfPZ/RYA=="],
+    "debug": ["debug@4.4.1", "", { "dependencies": { "ms": "^2.1.3" } }, "sha512-KcKCqiftBJcZr++7ykoDIEwSa3XWowTfNPo92BYxjXiyYEVrUQh2aLyhxBCwww+heortUFxEJYcRzosstTEBYQ=="],

    "delayed-stream": ["delayed-stream@1.0.0", "", {}, "sha512-ZySD7Nf91aLB0RxL4KGrKHBXl7Eds1DAmEdcoVawXnLD7SDhpNgtuII2aAkg7a7QS41jxPSZ17p4VdGnMHk3MQ=="],

@@ -152,21 +129,25 @@

    "etag": ["etag@1.8.1", "", {}, "sha512-aIL5Fx7mawVa300al2BnEE4iNvo1qETxLrPI/o05L7z6go7fCw1J6EQmbK4FmJ2AS7kgVF/KEZWufBfdClMcPg=="],

-    "eventsource": ["eventsource@3.0.6", "", { "dependencies": { "eventsource-parser": "^3.0.1" } }, "sha512-l19WpE2m9hSuyP06+FbuUUf1G+R0SFLrtQfbRb9PRr+oimOfxQhgGCbVaXg5IvZyyTThJsxh6L/srkMiCeBPDA=="],
+    "eventsource": ["eventsource@3.0.7", "", { "dependencies": { "eventsource-parser": "^3.0.1" } }, "sha512-CRT1WTyuQoD771GW56XEZFQ/ZoSfWid1alKGDYMmkt2yl8UXrVR4pspqWNEcqKvVIzg6PAltWjxcSSPrboA4iA=="],

-    "eventsource-parser": ["eventsource-parser@3.0.1", "", {}, "sha512-VARTJ9CYeuQYb0pZEPbzi740OWFgpHe7AYJ2WFZVnUDUQp5Dk2yJUgF36YsZ81cOyxT0QxmXD2EQpapAouzWVA=="],
+    "eventsource-parser": ["eventsource-parser@3.0.3", "", {}, "sha512-nVpZkTMM9rF6AQ9gPJpFsNAMt48wIzB5TQgiTLdHiuO8XEDhUgZEhqKlZWXbIzo9VmJ/HvysHqEaVeD5v9TPvA=="],

    "express": ["express@5.1.0", "", { "dependencies": { "accepts": "^2.0.0", "body-parser": "^2.2.0", "content-disposition": "^1.0.0", "content-type": "^1.0.5", "cookie": "^0.7.1", "cookie-signature": "^1.2.1", "debug": "^4.4.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-DT9ck5YIRU+8GYzzU5kT3eHGA5iL+1Zd0EutOmTE9Dtk+Tvuzd23VBU+ec7HPNSTxXYO55gPV/hq4pSBJDjFpA=="],

-    "express-rate-limit": ["express-rate-limit@7.5.0", "", { "peerDependencies": { "express": "^4.11 || 5 || ^5.0.0-beta.1" } }, "sha512-eB5zbQh5h+VenMPM3fh+nw1YExi5nMr6HUCR62ELSP11huvxm/Uir1H1QEyTkk5QX6A58pX6NmaTMceKZ0Eodg=="],
+    "express-rate-limit": ["express-rate-limit@7.5.1", "", { "peerDependencies": { "express": ">= 4.11" } }, "sha512-7iN8iPMDzOMHPUYllBEsQdWVB6fPDMPqwjBaFrgr4Jgr/+okjvzAy+UHlYYL/Vs0OsOrMkwS6PJDkFlJwoxUnw=="],

    "fast-content-type-parse": ["fast-content-type-parse@2.0.1", "", {}, "sha512-nGqtvLrj5w0naR6tDPfB4cUmYCqouzyQiz6C5y/LtcDllJdrcc6WaWW6iXyIIOErTa/XRybj28aasdn4LkVk6Q=="],

+    "fast-deep-equal": ["fast-deep-equal@3.1.3", "", {}, "sha512-f3qQ9oQy9j2AhBe/H9VC91wLmKBCCU/gDOnKNAYG5hswO7BLKj09Hc5HYNz9cGI++xlpDCIgDaitVs03ATR84Q=="],
+
+    "fast-json-stable-stringify": ["fast-json-stable-stringify@2.1.0", "", {}, "sha512-lhd/wF+Lk98HZoTCtlVraHtfh5XYijIjalXck7saUtuanSDyLMxnHhSXEDJqHxD7msR8D0uCmqlkwjCV8xvwHw=="],
+
    "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=="],

-    "form-data": ["form-data@4.0.2", "", { "dependencies": { "asynckit": "^0.4.0", "combined-stream": "^1.0.8", "es-set-tostringtag": "^2.1.0", "mime-types": "^2.1.12" } }, "sha512-hGfm/slu0ZabnNt4oaRZ6uREyfCj6P4fT/n6A1rGV+Z0VdGXjfOhVUpkn6qVQONHGIFwmveGXyDs75+nr6FM8w=="],
+    "form-data": ["form-data@4.0.4", "", { "dependencies": { "asynckit": "^0.4.0", "combined-stream": "^1.0.8", "es-set-tostringtag": "^2.1.0", "hasown": "^2.0.2", "mime-types": "^2.1.12" } }, "sha512-KrGhL9Q4zjj0kiUt5OO4Mr/A/jlI2jDYs5eHBpYHPcBEVSiipAvn2Ko2HnPe20rmcuuvMHNdZFp+4IlGTMF0Ow=="],

    "formdata-polyfill": ["formdata-polyfill@4.0.10", "", { "dependencies": { "fetch-blob": "^3.1.2" } }, "sha512-buewHzMvYL29jdeQTVILecSaZKnt/RJWjoZCF5OW60Z67/GmSLBkOFM7qh1PI3zFNtJbaZL5eQu1vLfazOwj4g=="],

@@ -200,6 +181,8 @@

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

+    "json-schema-traverse": ["json-schema-traverse@0.4.1", "", {}, "sha512-xbbCH5dCYU5T8LcEhhuh7HJ88HXuW3qsI3Y0zOZFKfZEHcpWiHU/Jxzk629Brsab/mMiHQti9wMP+845RPe3Vg=="],
+
    "math-intrinsics": ["math-intrinsics@1.1.0", "", {}, "sha512-/IXtbwEk5HTPyEwyKX6hGkYXxM9nbj64B+ilVJnC/R6B0pH5G4V3b0pVbL7DBj4tkhBAppbQUlf6F6Xl9LHu1g=="],

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

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

+    "punycode": ["punycode@2.3.1", "", {}, "sha512-vYt7UD1U9Wg6138shLtLOvdAu+8DsC/ilFtEVHcH+wydcSpNE20AfSOduf6MkRFahL5FY7X1oU7nKVZFtfq8Fg=="],
+
    "qs": ["qs@6.14.0", "", { "dependencies": { "side-channel": "^1.1.0" } }, "sha512-YWWTjgABSKcvs/nWBi9PycY/JiPJqOD4JA6o9Sej2AtvSGarXxKC3OQSk4pAarbdQlKAh5D4FCQkJNkW+GAn3w=="],

    "range-parser": ["range-parser@1.2.1", "", {}, "sha512-Hrgsx+orqoygnmhFbKaHE6c296J+HTAQXoxEF6gNupROmmGJRoyzfG3ccAveqCBrwr/2yxQ5BVd/GTl5agOwSg=="],
@@ -280,12 +265,14 @@

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

-    "undici-types": ["undici-types@6.19.8", "", {}, "sha512-ve2KP6f/JnbPBFyobGHuerC9g1FYGn/F8n1LWTwNxCEzd6IfqTwUQcNXgEtmmQ6DlRrC1hrSrBnCZPokRrDHjw=="],
+    "undici-types": ["undici-types@6.21.0", "", {}, "sha512-iwDZqg0QAGrg9Rav5H4n0M64c3mkR59cJ6wQp+7C4nI0gsmExaedaYLNO44eT4AtBBwjbTiGPMlt2Md0T9H9JQ=="],

-    "universal-user-agent": ["universal-user-agent@7.0.2", "", {}, "sha512-0JCqzSKnStlRRQfCdowvqy3cy0Dvtlb8xecj/H8JFZuCze4rwjPZQOgvFvn0Ws/usCHQFGpyr+pB9adaGwXn4Q=="],
+    "universal-user-agent": ["universal-user-agent@7.0.3", "", {}, "sha512-TmnEAEAsBJVZM/AADELsK76llnwcf9vMKuPz8JflO1frO8Lchitr0fNaN9d+Ap0BjKtqWqd/J17qeDnXh8CL2A=="],

    "unpipe": ["unpipe@1.0.0", "", {}, "sha512-pjy2bYhSsufwWlKwPc+l3cN7+wuJlK6uz0YdJEOlQDbl6jo/YlPi4mb8agUkVC8BF7V8NuzeyPNqRksA3hztKQ=="],

+    "uri-js": ["uri-js@4.4.1", "", { "dependencies": { "punycode": "^2.1.0" } }, "sha512-7rKUyy33Q1yc98pQ1DAmLtwX109F7TIfWlW1Ydo8Wl1ii1SeHieeh0HHfPeL2fMXK6z0s8ecKs9frCuLJvndBg=="],
+
    "vary": ["vary@1.1.2", "", {}, "sha512-BNGbWLfd0eUPabhkXUVm0j8uuvREyTh5ovRa/dyow/BqAbZJyC+5fU+IzQOzmAKzYqYRAISoRhdQr3eIZ/PXqg=="],

    "web-streams-polyfill": ["web-streams-polyfill@3.3.3", "", {}, "sha512-d2JWLCivmZYTSIoge9MsgFCZrt571BikcWGYkjC1khllbTeDlGqZ2D8vD8E/lJa8WGWbb7Plm8/XJYV7IJHZZw=="],
@@ -294,9 +281,9 @@

    "wrappy": ["wrappy@1.0.2", "", {}, "sha512-l4Sp/DRseor9wL6EvV2+TuQn63dMkPjZ/sp9XkghTEbV9KlPS1xUsZ3u7/IQO4wxtcFB4bgpQPRcR3QCvezPcQ=="],

-    "zod": ["zod@3.24.4", "", {}, "sha512-OdqJE9UDRPwWsrHjLN2F8bPxvwJBK22EHLWtanu0LSYr5YqzsaaW3RMgmjwr8Rypg5k+meEJdSPXJZXE/yqOMg=="],
+    "zod": ["zod@3.25.76", "", {}, "sha512-gzUt/qt81nXsFGKIFcC3YnfEAx5NkunCfnDlvuBSSFS02bcXu4Lmea0AFIUwbLWxWPx3d9p8S5QoaujKcNQxcQ=="],

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

    "@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=="],

@@ -308,11 +295,11 @@

    "@octokit/endpoint/universal-user-agent": ["universal-user-agent@6.0.1", "", {}, "sha512-yCzhz6FN2wU1NiiQRogkTQszlQSlpWaw8SvVegAc+bDxbzHgh1vX8uIe8OYyMH6DwH+sdTJsgMl36+mSMdRJIQ=="],

-    "@octokit/graphql/@octokit/request": ["@octokit/request@9.2.3", "", { "dependencies": { "@octokit/endpoint": "^10.1.4", "@octokit/request-error": "^6.1.8", "@octokit/types": "^14.0.0", "fast-content-type-parse": "^2.0.0", "universal-user-agent": "^7.0.2" } }, "sha512-Ma+pZU8PXLOEYzsWf0cn/gY+ME57Wq8f49WTXA8FMHp2Ps9djKw//xYJ1je8Hm0pR2lU9FUGeJRWOtxq6olt4w=="],
+    "@octokit/graphql/@octokit/request": ["@octokit/request@9.2.4", "", { "dependencies": { "@octokit/endpoint": "^10.1.4", "@octokit/request-error": "^6.1.8", "@octokit/types": "^14.0.0", "fast-content-type-parse": "^2.0.0", "universal-user-agent": "^7.0.2" } }, "sha512-q8ybdytBmxa6KogWlNa818r0k1wlqzNC+yNkcQDECHvQo8Vmstrg18JwqJHdJdUiHD2sjlwBgSm9kHkOKe2iyA=="],

    "@octokit/plugin-paginate-rest/@octokit/types": ["@octokit/types@12.6.0", "", { "dependencies": { "@octokit/openapi-types": "^20.0.0" } }, "sha512-1rhSOfRa6H9w4YwK0yrf5faDaDTb+yLyBUKOCV4xtCDB5VmIPqd/v9yr9o6SAzOAlRxMiRiCic6JVM1/kunVkw=="],

-    "@octokit/plugin-request-log/@octokit/core": ["@octokit/core@6.1.5", "", { "dependencies": { "@octokit/auth-token": "^5.0.0", "@octokit/graphql": "^8.2.2", "@octokit/request": "^9.2.3", "@octokit/request-error": "^6.1.8", "@octokit/types": "^14.0.0", "before-after-hook": "^3.0.2", "universal-user-agent": "^7.0.0" } }, "sha512-vvmsN0r7rguA+FySiCsbaTTobSftpIDIpPW81trAmsv9TGxg3YCujAxRYp/Uy8xmDgYCzzgulG62H7KYUFmeIg=="],
+    "@octokit/plugin-request-log/@octokit/core": ["@octokit/core@6.1.6", "", { "dependencies": { "@octokit/auth-token": "^5.0.0", "@octokit/graphql": "^8.2.2", "@octokit/request": "^9.2.3", "@octokit/request-error": "^6.1.8", "@octokit/types": "^14.0.0", "before-after-hook": "^3.0.2", "universal-user-agent": "^7.0.0" } }, "sha512-kIU8SLQkYWGp3pVKiYzA5OSaNF5EE03P/R8zEmmrG6XwOg5oBjXyQVVIauQ0dgau4zYhpZEhJrvIYt6oM+zZZA=="],

    "@octokit/plugin-rest-endpoint-methods/@octokit/types": ["@octokit/types@12.6.0", "", { "dependencies": { "@octokit/openapi-types": "^20.0.0" } }, "sha512-1rhSOfRa6H9w4YwK0yrf5faDaDTb+yLyBUKOCV4xtCDB5VmIPqd/v9yr9o6SAzOAlRxMiRiCic6JVM1/kunVkw=="],

@@ -322,7 +309,7 @@

    "@octokit/request-error/@octokit/types": ["@octokit/types@13.10.0", "", { "dependencies": { "@octokit/openapi-types": "^24.2.0" } }, "sha512-ifLaO34EbbPj0Xgro4G5lP5asESjwHracYJvVaPIyXMuiuXLlhic3S47cBdTb+jfODkTE5YtGCLt3Ay3+J97sA=="],

-    "@octokit/rest/@octokit/core": ["@octokit/core@6.1.5", "", { "dependencies": { "@octokit/auth-token": "^5.0.0", "@octokit/graphql": "^8.2.2", "@octokit/request": "^9.2.3", "@octokit/request-error": "^6.1.8", "@octokit/types": "^14.0.0", "before-after-hook": "^3.0.2", "universal-user-agent": "^7.0.0" } }, "sha512-vvmsN0r7rguA+FySiCsbaTTobSftpIDIpPW81trAmsv9TGxg3YCujAxRYp/Uy8xmDgYCzzgulG62H7KYUFmeIg=="],
+    "@octokit/rest/@octokit/core": ["@octokit/core@6.1.6", "", { "dependencies": { "@octokit/auth-token": "^5.0.0", "@octokit/graphql": "^8.2.2", "@octokit/request": "^9.2.3", "@octokit/request-error": "^6.1.8", "@octokit/types": "^14.0.0", "before-after-hook": "^3.0.2", "universal-user-agent": "^7.0.0" } }, "sha512-kIU8SLQkYWGp3pVKiYzA5OSaNF5EE03P/R8zEmmrG6XwOg5oBjXyQVVIauQ0dgau4zYhpZEhJrvIYt6oM+zZZA=="],

    "@octokit/rest/@octokit/plugin-paginate-rest": ["@octokit/plugin-paginate-rest@11.6.0", "", { "dependencies": { "@octokit/types": "^13.10.0" }, "peerDependencies": { "@octokit/core": ">=6" } }, "sha512-n5KPteiF7pWKgBIBJSk8qzoZWcUkza2O6A0za97pMGVrGfPdltxrfmfF5GucHYvHGZD8BdaZmmHGz5cX/3gdpw=="],

@@ -348,7 +335,7 @@

    "@octokit/plugin-request-log/@octokit/core/@octokit/auth-token": ["@octokit/auth-token@5.1.2", "", {}, "sha512-JcQDsBdg49Yky2w2ld20IHAlwr8d/d8N6NiOXbtuoPCqzbsiJgF633mVUw3x4mo0H5ypataQIX7SFu3yy44Mpw=="],

-    "@octokit/plugin-request-log/@octokit/core/@octokit/request": ["@octokit/request@9.2.3", "", { "dependencies": { "@octokit/endpoint": "^10.1.4", "@octokit/request-error": "^6.1.8", "@octokit/types": "^14.0.0", "fast-content-type-parse": "^2.0.0", "universal-user-agent": "^7.0.2" } }, "sha512-Ma+pZU8PXLOEYzsWf0cn/gY+ME57Wq8f49WTXA8FMHp2Ps9djKw//xYJ1je8Hm0pR2lU9FUGeJRWOtxq6olt4w=="],
+    "@octokit/plugin-request-log/@octokit/core/@octokit/request": ["@octokit/request@9.2.4", "", { "dependencies": { "@octokit/endpoint": "^10.1.4", "@octokit/request-error": "^6.1.8", "@octokit/types": "^14.0.0", "fast-content-type-parse": "^2.0.0", "universal-user-agent": "^7.0.2" } }, "sha512-q8ybdytBmxa6KogWlNa818r0k1wlqzNC+yNkcQDECHvQo8Vmstrg18JwqJHdJdUiHD2sjlwBgSm9kHkOKe2iyA=="],

    "@octokit/plugin-request-log/@octokit/core/@octokit/request-error": ["@octokit/request-error@6.1.8", "", { "dependencies": { "@octokit/types": "^14.0.0" } }, "sha512-WEi/R0Jmq+IJKydWlKDmryPcmdYSVjL3ekaiEL1L9eo1sUnqMJ+grqmC9cjk7CA7+b2/T397tO5d8YLOH3qYpQ=="],

@@ -362,7 +349,7 @@

    "@octokit/rest/@octokit/core/@octokit/auth-token": ["@octokit/auth-token@5.1.2", "", {}, "sha512-JcQDsBdg49Yky2w2ld20IHAlwr8d/d8N6NiOXbtuoPCqzbsiJgF633mVUw3x4mo0H5ypataQIX7SFu3yy44Mpw=="],

-    "@octokit/rest/@octokit/core/@octokit/request": ["@octokit/request@9.2.3", "", { "dependencies": { "@octokit/endpoint": "^10.1.4", "@octokit/request-error": "^6.1.8", "@octokit/types": "^14.0.0", "fast-content-type-parse": "^2.0.0", "universal-user-agent": "^7.0.2" } }, "sha512-Ma+pZU8PXLOEYzsWf0cn/gY+ME57Wq8f49WTXA8FMHp2Ps9djKw//xYJ1je8Hm0pR2lU9FUGeJRWOtxq6olt4w=="],
+    "@octokit/rest/@octokit/core/@octokit/request": ["@octokit/request@9.2.4", "", { "dependencies": { "@octokit/endpoint": "^10.1.4", "@octokit/request-error": "^6.1.8", "@octokit/types": "^14.0.0", "fast-content-type-parse": "^2.0.0", "universal-user-agent": "^7.0.2" } }, "sha512-q8ybdytBmxa6KogWlNa818r0k1wlqzNC+yNkcQDECHvQo8Vmstrg18JwqJHdJdUiHD2sjlwBgSm9kHkOKe2iyA=="],

    "@octokit/rest/@octokit/core/@octokit/request-error": ["@octokit/request-error@6.1.8", "", { "dependencies": { "@octokit/types": "^14.0.0" } }, "sha512-WEi/R0Jmq+IJKydWlKDmryPcmdYSVjL3ekaiEL1L9eo1sUnqMJ+grqmC9cjk7CA7+b2/T397tO5d8YLOH3qYpQ=="],

--- a/examples/claude-auto-review.yml
+++ b/examples/claude-auto-review.yml
@@ -35,4 +35,4 @@ jobs:

            Provide constructive feedback with specific suggestions for improvement.
            Use inline comments to highlight specific areas of concern.
-          # allowed_tools: "mcp__github__create_pending_pull_request_review,mcp__github__add_pull_request_review_comment_to_pending_review,mcp__github__submit_pending_pull_request_review,mcp__github__get_pull_request_diff"
+          # allowed_tools: "mcp__github__create_pending_pull_request_review,mcp__github__add_comment_to_pending_review,mcp__github__submit_pending_pull_request_review,mcp__github__get_pull_request_diff"
--- a/examples/claude-experimental-review-mode.yml
+++ b/examples/claude-experimental-review-mode.yml
@@ -0,0 +1,45 @@
+name: Claude Experimental Review Mode
+
+on:
+  pull_request:
+    types: [opened, synchronize]
+  issue_comment:
+    types: [created]
+
+jobs:
+  code-review:
+    # Run on PR events, or when someone comments "@claude review" on a PR
+    if: |
+      github.event_name == 'pull_request' ||
+      (github.event_name == 'issue_comment' && 
+       github.event.issue.pull_request && 
+       contains(github.event.comment.body, '@claude review'))
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      pull-requests: write
+      issues: write
+      id-token: write
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0 # Full history for better diff analysis
+
+      - name: Code Review with Claude
+        uses: anthropics/claude-code-action@beta
+        with:
+          mode: experimental-review
+          anthropic_api_key: ${{ secrets.ANTHROPIC_API_KEY }}
+          # github_token not needed - uses default GITHUB_TOKEN for GitHub operations
+          timeout_minutes: "30"
+          custom_instructions: |
+            Focus on:
+            - Code quality and maintainability
+            - Security vulnerabilities
+            - Performance issues
+            - Best practices and design patterns
+            - Test coverage gaps
+
+            Be constructive and provide specific suggestions for improvements.
+            Use GitHub's suggestion format when proposing code changes.
--- a/examples/claude-modes.yml
+++ b/examples/claude-modes.yml
@@ -0,0 +1,56 @@
+name: Claude Mode Examples
+
+on:
+  # Common events for both modes
+  issue_comment:
+    types: [created]
+  issues:
+    types: [opened, labeled]
+  pull_request:
+    types: [opened]
+
+jobs:
+  # Tag Mode (Default) - Traditional implementation
+  tag-mode-example:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+      pull-requests: write
+      issues: write
+      id-token: write
+    steps:
+      - uses: anthropics/claude-code-action@beta
+        with:
+          anthropic_api_key: ${{ secrets.ANTHROPIC_API_KEY }}
+          # Tag mode (default) behavior:
+          # - Scans for @claude mentions in comments, issues, and PRs
+          # - Only acts when trigger phrase is found
+          # - Creates tracking comments with progress checkboxes
+          # - Perfect for: Interactive Q&A, on-demand code changes
+
+  # Agent Mode - Automation without triggers
+  agent-mode-auto-review:
+    # Automatically review every new PR
+    if: github.event_name == 'pull_request' && github.event.action == 'opened'
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      pull-requests: write
+      issues: write
+      id-token: write
+    steps:
+      - uses: anthropics/claude-code-action@beta
+        with:
+          mode: agent
+          anthropic_api_key: ${{ secrets.ANTHROPIC_API_KEY }}
+          override_prompt: |
+            Review this PR for code quality. Focus on:
+            - Potential bugs or logic errors
+            - Security concerns
+            - Performance issues
+
+            Provide specific, actionable feedback.
+          # Agent mode behavior:
+          # - NO @claude mention needed - runs immediately
+          # - Enables true automation (impossible with tag mode)
+          # - Perfect for: CI/CD integration, automatic reviews, label-based workflows
--- a/examples/claude.yml
+++ b/examples/claude.yml
@@ -36,6 +36,7 @@ jobs:
          # Or use OAuth token instead:
          # claude_code_oauth_token: ${{ secrets.CLAUDE_CODE_OAUTH_TOKEN }}
          timeout_minutes: "60"
+          # mode: tag  # Default: responds to @claude mentions
          # Optional: Restrict network access to specific domains only
          # experimental_allowed_domains: |
          #   .anthropic.com
--- a/examples/workflow-dispatch-agent.yml
+++ b/examples/workflow-dispatch-agent.yml
@@ -0,0 +1,40 @@
+name: Claude Commit Analysis
+
+on:
+  workflow_dispatch:
+    inputs:
+      analysis_type:
+        description: "Type of analysis to perform"
+        required: true
+        type: choice
+        options:
+          - summarize-commit
+          - security-review
+        default: "summarize-commit"
+
+jobs:
+  analyze-commit:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      pull-requests: write
+      issues: write
+      id-token: write
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 2 # Need at least 2 commits to analyze the latest
+
+      - name: Run Claude Analysis
+        uses: anthropics/claude-code-action@beta
+        with:
+          mode: agent
+          anthropic_api_key: ${{ secrets.ANTHROPIC_API_KEY }}
+          override_prompt: |
+            Analyze the latest commit in this repository.
+
+            ${{ github.event.inputs.analysis_type == 'summarize-commit' && 'Task: Provide a clear, concise summary of what changed in the latest commit. Include the commit message, files changed, and the purpose of the changes.' || '' }}
+
+            ${{ github.event.inputs.analysis_type == 'security-review' && 'Task: Review the latest commit for potential security vulnerabilities. Check for exposed secrets, insecure coding patterns, dependency vulnerabilities, or any other security concerns. Provide specific recommendations if issues are found.' || '' }}
--- a/package.json
+++ b/package.json
@@ -12,7 +12,6 @@
  "dependencies": {
    "@actions/core": "^1.10.1",
    "@actions/github": "^6.0.1",
-    "@anthropic-ai/claude-code": "1.0.57",
    "@modelcontextprotocol/sdk": "^1.11.0",
    "@octokit/graphql": "^8.2.2",
    "@octokit/rest": "^21.1.1",
--- a/scripts/setup-network-restrictions.sh
+++ b/scripts/setup-network-restrictions.sh
@@ -0,0 +1,123 @@
+#!/bin/bash
+
+# Setup Network Restrictions with Squid Proxy
+# This script sets up a Squid proxy to restrict network access to whitelisted domains only.
+
+set -e
+
+# Check if experimental_allowed_domains is provided
+if [ -z "$EXPERIMENTAL_ALLOWED_DOMAINS" ]; then
+  echo "ERROR: EXPERIMENTAL_ALLOWED_DOMAINS environment variable is required"
+  exit 1
+fi
+
+# Check required environment variables
+if [ -z "$RUNNER_TEMP" ]; then
+  echo "ERROR: RUNNER_TEMP environment variable is required"
+  exit 1
+fi
+
+if [ -z "$GITHUB_ENV" ]; then
+  echo "ERROR: GITHUB_ENV environment variable is required"
+  exit 1
+fi
+
+echo "Setting up network restrictions with Squid proxy..."
+
+SQUID_START_TIME=$(date +%s.%N)
+
+# Create whitelist file
+echo "$EXPERIMENTAL_ALLOWED_DOMAINS" > $RUNNER_TEMP/whitelist.txt
+
+# Ensure each domain has proper format
+# If domain doesn't start with a dot and isn't an IP, add the dot for subdomain matching
+mv $RUNNER_TEMP/whitelist.txt $RUNNER_TEMP/whitelist.txt.orig
+while IFS= read -r domain; do
+  if [ -n "$domain" ]; then
+    # Trim whitespace
+    domain=$(echo "$domain" | xargs)
+    # If it's not empty and doesn't start with a dot, add one
+    if [[ "$domain" != .* ]] && [[ ! "$domain" =~ ^[0-9]+\.[0-9]+\.[0-9]+\.[0-9]+$ ]]; then
+      echo ".$domain" >> $RUNNER_TEMP/whitelist.txt
+    else
+      echo "$domain" >> $RUNNER_TEMP/whitelist.txt
+    fi
+  fi
+done < $RUNNER_TEMP/whitelist.txt.orig
+
+# Create Squid config with whitelist
+echo "http_port 3128" > $RUNNER_TEMP/squid.conf
+echo "" >> $RUNNER_TEMP/squid.conf
+echo "# Define ACLs" >> $RUNNER_TEMP/squid.conf
+echo "acl whitelist dstdomain \"/etc/squid/whitelist.txt\"" >> $RUNNER_TEMP/squid.conf
+echo "acl localnet src 127.0.0.1/32" >> $RUNNER_TEMP/squid.conf
+echo "acl localnet src 172.17.0.0/16" >> $RUNNER_TEMP/squid.conf
+echo "acl SSL_ports port 443" >> $RUNNER_TEMP/squid.conf
+echo "acl Safe_ports port 80" >> $RUNNER_TEMP/squid.conf
+echo "acl Safe_ports port 443" >> $RUNNER_TEMP/squid.conf
+echo "acl CONNECT method CONNECT" >> $RUNNER_TEMP/squid.conf
+echo "" >> $RUNNER_TEMP/squid.conf
+echo "# Deny requests to certain unsafe ports" >> $RUNNER_TEMP/squid.conf
+echo "http_access deny !Safe_ports" >> $RUNNER_TEMP/squid.conf
+echo "" >> $RUNNER_TEMP/squid.conf
+echo "# Only allow CONNECT to SSL ports" >> $RUNNER_TEMP/squid.conf
+echo "http_access deny CONNECT !SSL_ports" >> $RUNNER_TEMP/squid.conf
+echo "" >> $RUNNER_TEMP/squid.conf
+echo "# Allow localhost" >> $RUNNER_TEMP/squid.conf
+echo "http_access allow localhost" >> $RUNNER_TEMP/squid.conf
+echo "" >> $RUNNER_TEMP/squid.conf
+echo "# Allow localnet access to whitelisted domains" >> $RUNNER_TEMP/squid.conf
+echo "http_access allow localnet whitelist" >> $RUNNER_TEMP/squid.conf
+echo "" >> $RUNNER_TEMP/squid.conf
+echo "# Deny everything else" >> $RUNNER_TEMP/squid.conf
+echo "http_access deny all" >> $RUNNER_TEMP/squid.conf
+
+echo "Starting Squid proxy..."
+# First, remove any existing container
+sudo docker rm -f squid-proxy 2>/dev/null || true
+
+# Ensure whitelist file is not empty (Squid fails with empty files)
+if [ ! -s "$RUNNER_TEMP/whitelist.txt" ]; then
+  echo "WARNING: Whitelist file is empty, adding a dummy entry"
+  echo ".example.com" >> $RUNNER_TEMP/whitelist.txt
+fi
+
+# Use sudo to prevent Claude from stopping the container
+CONTAINER_ID=$(sudo docker run -d \
+  --name squid-proxy \
+  -p 127.0.0.1:3128:3128 \
+  -v $RUNNER_TEMP/squid.conf:/etc/squid/squid.conf:ro \
+  -v $RUNNER_TEMP/whitelist.txt:/etc/squid/whitelist.txt:ro \
+  ubuntu/squid:latest 2>&1) || {
+  echo "ERROR: Failed to start Squid container"
+  exit 1
+}
+
+# Wait for proxy to be ready (usually < 1 second)
+READY=false
+for i in {1..30}; do
+  if nc -z 127.0.0.1 3128 2>/dev/null; then
+    TOTAL_TIME=$(echo "scale=3; $(date +%s.%N) - $SQUID_START_TIME" | bc)
+    echo "Squid proxy ready in ${TOTAL_TIME}s"
+    READY=true
+    break
+  fi
+  sleep 0.1
+done
+
+if [ "$READY" != "true" ]; then
+  echo "ERROR: Squid proxy failed to start within 3 seconds"
+  echo "Container logs:"
+  sudo docker logs squid-proxy 2>&1 || true
+  echo "Container status:"
+  sudo docker ps -a | grep squid-proxy || true
+  exit 1
+fi
+
+# Set proxy environment variables
+echo "http_proxy=http://127.0.0.1:3128" >> $GITHUB_ENV
+echo "https_proxy=http://127.0.0.1:3128" >> $GITHUB_ENV
+echo "HTTP_PROXY=http://127.0.0.1:3128" >> $GITHUB_ENV
+echo "HTTPS_PROXY=http://127.0.0.1:3128" >> $GITHUB_ENV
+
+echo "Network restrictions setup completed successfully"
--- a/src/create-prompt/index.ts
+++ b/src/create-prompt/index.ts
@@ -20,6 +20,7 @@ import {
 import type { ParsedGitHubContext } from "../github/context";
 import type { CommonFields, PreparedContext, EventData } from "./types";
 import { GITHUB_SERVER_URL } from "../github/api/config";
+import type { Mode, ModeContext } from "../modes/types";
 export type { CommonFields, PreparedContext } from "./types";

 const BASE_ALLOWED_TOOLS = [
@@ -480,8 +481,14 @@ function substitutePromptVariables(
        : "",
    PR_TITLE: eventData.isPR && contextData?.title ? contextData.title : "",
    ISSUE_TITLE: !eventData.isPR && contextData?.title ? contextData.title : "",
-    PR_BODY: eventData.isPR && contextData?.body ? contextData.body : "",
-    ISSUE_BODY: !eventData.isPR && contextData?.body ? contextData.body : "",
+    PR_BODY:
+      eventData.isPR && contextData?.body
+        ? formatBody(contextData.body, githubData.imageUrlMap)
+        : "",
+    ISSUE_BODY:
+      !eventData.isPR && contextData?.body
+        ? formatBody(contextData.body, githubData.imageUrlMap)
+        : "",
    PR_COMMENTS: eventData.isPR
      ? formatComments(comments, githubData.imageUrlMap)
      : "",
@@ -523,6 +530,7 @@ export function generatePrompt(
  context: PreparedContext,
  githubData: FetchDataResult,
  useCommitSigning: boolean,
+  mode: Mode,
 ): string {
  if (context.overridePrompt) {
    return substitutePromptVariables(
@@ -532,6 +540,19 @@ export function generatePrompt(
    );
  }

+  // Use the mode's prompt generator
+  return mode.generatePrompt(context, githubData, useCommitSigning);
+}
+
+/**
+ * Generates the default prompt for tag mode
+ * @internal
+ */
+export function generateDefaultPrompt(
+  context: PreparedContext,
+  githubData: FetchDataResult,
+  useCommitSigning: boolean = false,
+): string {
  const {
    contextData,
    comments,
@@ -580,23 +601,28 @@ ${formattedBody}
 ${formattedComments || "No comments"}
 </comments>

-<review_comments>
-${eventData.isPR ? formattedReviewComments || "No review comments" : ""}
-</review_comments>
+${
+  eventData.isPR
+    ? `<review_comments>
+${formattedReviewComments || "No review comments"}
+</review_comments>`
+    : ""
+}

-<changed_files>
-${eventData.isPR ? formattedChangedFiles || "No files changed" : ""}
-</changed_files>${imagesInfo}
+${
+  eventData.isPR
+    ? `<changed_files>
+${formattedChangedFiles || "No files changed"}
+</changed_files>`
+    : ""
+}${imagesInfo}

 <event_type>${eventType}</event_type>
 <is_pr>${eventData.isPR ? "true" : "false"}</is_pr>
 <trigger_context>${triggerContext}</trigger_context>
 <repository>${context.repository}</repository>
-${
-  eventData.isPR
-    ? `<pr_number>${eventData.prNumber}</pr_number>`
-    : `<issue_number>${eventData.issueNumber ?? ""}</issue_number>`
-}
+${eventData.isPR && eventData.prNumber ? `<pr_number>${eventData.prNumber}</pr_number>` : ""}
+${!eventData.isPR && eventData.issueNumber ? `<issue_number>${eventData.issueNumber}</issue_number>` : ""}
 <claude_comment_id>${context.claudeCommentId}</claude_comment_id>
 <trigger_username>${context.triggerUsername ?? "Unknown"}</trigger_username>
 <trigger_display_name>${githubData.triggerDisplayName ?? context.triggerUsername ?? "Unknown"}</trigger_display_name>
@@ -788,29 +814,40 @@ f. If you are unable to complete certain steps, such as running a linter or test
 }

 export async function createPrompt(
-  claudeCommentId: number,
-  baseBranch: string | undefined,
-  claudeBranch: string | undefined,
+  mode: Mode,
+  modeContext: ModeContext,
  githubData: FetchDataResult,
  context: ParsedGitHubContext,
 ) {
  try {
+    // 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.toString(),
-      baseBranch,
-      claudeBranch,
+      claudeCommentId,
+      modeContext.baseBranch,
+      modeContext.claudeBranch,
    );

    await mkdir(`${process.env.RUNNER_TEMP}/claude-prompts`, {
      recursive: true,
    });

-    // Generate the prompt
+    // Generate the prompt directly
    const promptContent = generatePrompt(
      preparedContext,
      githubData,
      context.inputs.useCommitSigning,
+      mode,
    );

    // Log the final prompt to console
@@ -828,14 +865,29 @@ export async function createPrompt(
    const hasActionsReadPermission =
      context.inputs.additionalPermissions.get("actions") === "read" &&
      context.isPR;
+
+    // Get mode-specific tools
+    const modeAllowedTools = mode.getAllowedTools();
+    const modeDisallowedTools = mode.getDisallowedTools();
+
+    // Combine with existing allowed tools
+    const combinedAllowedTools = [
+      ...context.inputs.allowedTools,
+      ...modeAllowedTools,
+    ];
+    const combinedDisallowedTools = [
+      ...context.inputs.disallowedTools,
+      ...modeDisallowedTools,
+    ];
+
    const allAllowedTools = buildAllowedToolsString(
-      context.inputs.allowedTools,
+      combinedAllowedTools,
      hasActionsReadPermission,
      context.inputs.useCommitSigning,
    );
    const allDisallowedTools = buildDisallowedToolsString(
-      context.inputs.disallowedTools,
-      context.inputs.allowedTools,
+      combinedDisallowedTools,
+      combinedAllowedTools,
    );

    core.exportVariable("ALLOWED_TOOLS", allAllowedTools);
--- a/src/entrypoints/format-turns.ts
+++ b/src/entrypoints/format-turns.ts
@@ -3,21 +3,21 @@
 import { readFileSync, existsSync } from "fs";
 import { exit } from "process";

-export interface ToolUse {
+export type ToolUse = {
  type: string;
  name?: string;
  input?: Record<string, any>;
  id?: string;
-}
+};

-export interface ToolResult {
+export type ToolResult = {
  type: string;
  tool_use_id?: string;
  content?: any;
  is_error?: boolean;
-}
+};

-export interface ContentItem {
+export type ContentItem = {
  type: string;
  text?: string;
  tool_use_id?: string;
@@ -26,17 +26,17 @@ export interface ContentItem {
  name?: string;
  input?: Record<string, any>;
  id?: string;
-}
+};

-export interface Message {
+export type Message = {
  content: ContentItem[];
  usage?: {
    input_tokens?: number;
    output_tokens?: number;
  };
-}
+};

-export interface Turn {
+export type Turn = {
  type: string;
  subtype?: string;
  message?: Message;
@@ -44,16 +44,16 @@ export interface Turn {
  cost_usd?: number;
  duration_ms?: number;
  result?: string;
-}
+};

-export interface GroupedContent {
+export type GroupedContent = {
  type: string;
  tools_count?: number;
  data?: Turn;
  text_parts?: string[];
  tool_calls?: { tool_use: ToolUse; tool_result?: ToolResult }[];
  usage?: Record<string, number>;
-}
+};

 export function detectContentType(content: any): string {
  const contentStr = String(content).trim();
@@ -372,8 +372,12 @@ export function formatGroupedContent(groupedContent: GroupedContent[]): string {
      const usage = item.usage || {};
      if (Object.keys(usage).length > 0) {
        const inputTokens = usage.input_tokens || 0;
+        const cacheCreationTokens = usage.cache_creation_input_tokens || 0;
+        const cacheReadTokens = usage.cache_read_input_tokens || 0;
+        const totalInputTokens =
+          inputTokens + cacheCreationTokens + cacheReadTokens;
        const outputTokens = usage.output_tokens || 0;
-        markdown += `*Token usage: ${inputTokens} input, ${outputTokens} output*\n\n`;
+        markdown += `*Token usage: ${totalInputTokens} input, ${outputTokens} output*\n\n`;
      }

      // Only add separator if this section had content
@@ -393,7 +397,7 @@ export function formatGroupedContent(groupedContent: GroupedContent[]): string {
      markdown += "---\n\n";
    } else if (itemType === "final_result") {
      const data = item.data || {};
-      const cost = (data as any).cost_usd || 0;
+      const cost = (data as any).total_cost_usd || (data as any).cost_usd || 0;
      const duration = (data as any).duration_ms || 0;
      const resultText = (data as any).result || "";

--- a/src/entrypoints/prepare.ts
+++ b/src/entrypoints/prepare.ts
@@ -7,98 +7,80 @@

 import * as core from "@actions/core";
 import { setupGitHubToken } from "../github/token";
-import { checkTriggerAction } from "../github/validation/trigger";
-import { checkHumanActor } from "../github/validation/actor";
 import { checkWritePermissions } from "../github/validation/permissions";
-import { createInitialComment } from "../github/operations/comments/create-initial";
-import { setupBranch } from "../github/operations/branch";
-import { configureGitAuth } from "../github/operations/git-config";
-import { prepareMcpConfig } from "../mcp/install-mcp-server";
-import { createPrompt } from "../create-prompt";
 import { createOctokit } from "../github/api/client";
-import { fetchGitHubData } from "../github/data/fetcher";
-import { parseGitHubContext } from "../github/context";
+import { parseGitHubContext, isEntityContext } from "../github/context";
+import { getMode, isValidMode, DEFAULT_MODE } from "../modes/registry";
+import type { ModeName } from "../modes/types";
+import { prepare } from "../prepare";

 async function run() {
  try {
-    // Step 1: Setup GitHub token
-    const githubToken = await setupGitHubToken();
+    // Step 1: Get mode first to determine authentication method
+    const modeInput = process.env.MODE || DEFAULT_MODE;
+
+    // Validate mode input
+    if (!isValidMode(modeInput)) {
+      throw new Error(`Invalid mode: ${modeInput}`);
+    }
+    const validatedMode: ModeName = modeInput;
+
+    // Step 2: Setup GitHub token based on mode
+    let githubToken: string;
+    if (validatedMode === "experimental-review") {
+      // For experimental-review mode, use the default GitHub Action token
+      githubToken = process.env.DEFAULT_WORKFLOW_TOKEN || "";
+      if (!githubToken) {
+        throw new Error(
+          "DEFAULT_WORKFLOW_TOKEN not found for experimental-review mode",
+        );
+      }
+      console.log("Using default GitHub Action token for review mode");
+      core.setOutput("GITHUB_TOKEN", githubToken);
+    } else {
+      // For other modes, use the existing token exchange
+      githubToken = await setupGitHubToken();
+    }
    const octokit = createOctokit(githubToken);

    // Step 2: Parse GitHub context (once for all operations)
    const context = parseGitHubContext();

-    // Step 3: Check write permissions
-    const hasWritePermissions = await checkWritePermissions(
-      octokit.rest,
-      context,
-    );
-    if (!hasWritePermissions) {
-      throw new Error(
-        "Actor does not have write permissions to the repository",
+    // Step 3: Check write permissions (only for entity contexts)
+    if (isEntityContext(context)) {
+      const hasWritePermissions = await checkWritePermissions(
+        octokit.rest,
+        context,
      );
+      if (!hasWritePermissions) {
+        throw new Error(
+          "Actor does not have write permissions to the repository",
+        );
+      }
    }

-    // Step 4: Check trigger conditions
-    const containsTrigger = await checkTriggerAction(context);
+    // Step 4: Get mode and check trigger conditions
+    const mode = getMode(validatedMode, context);
+    const containsTrigger = mode.shouldTrigger(context);
+
+    // Set output for action.yml to check
+    core.setOutput("contains_trigger", containsTrigger.toString());

    if (!containsTrigger) {
      console.log("No trigger found, skipping remaining steps");
      return;
    }

-    // Step 5: Check if actor is human
-    await checkHumanActor(octokit.rest, context);
-
-    // Step 6: Create initial tracking comment
-    const commentData = await createInitialComment(octokit.rest, context);
-    const commentId = commentData.id;
-
-    // Step 7: Fetch GitHub data (once for both branch setup and prompt creation)
-    const githubData = await fetchGitHubData({
-      octokits: octokit,
-      repository: `${context.repository.owner}/${context.repository.repo}`,
-      prNumber: context.entityNumber.toString(),
-      isPR: context.isPR,
-      triggerUsername: context.actor,
-    });
-
-    // Step 8: Setup branch
-    const branchInfo = await setupBranch(octokit, githubData, context);
-
-    // Step 9: Configure git authentication if not using commit signing
-    if (!context.inputs.useCommitSigning) {
-      try {
-        await configureGitAuth(githubToken, context, commentData.user);
-      } catch (error) {
-        console.error("Failed to configure git authentication:", error);
-        throw error;
-      }
-    }
-
-    // Step 10: Create prompt file
-    await createPrompt(
-      commentId,
-      branchInfo.baseBranch,
-      branchInfo.claudeBranch,
-      githubData,
+    // Step 5: Use the new modular prepare function
+    const result = await prepare({
      context,
-    );
-
-    // Step 11: Get MCP configuration
-    const additionalMcpConfig = process.env.MCP_CONFIG || "";
-    const mcpConfig = await prepareMcpConfig({
+      octokit,
+      mode,
      githubToken,
-      owner: context.repository.owner,
-      repo: context.repository.repo,
-      branch: branchInfo.claudeBranch || branchInfo.currentBranch,
-      baseBranch: branchInfo.baseBranch,
-      additionalMcpConfig,
-      claudeCommentId: commentId.toString(),
-      allowedTools: context.inputs.allowedTools,
-      context,
    });
-    core.setOutput("mcp_config", mcpConfig);
+
+    // Set the MCP config output
+    core.setOutput("mcp_config", result.mcpConfig);
  } catch (error) {
    const errorMessage = error instanceof Error ? error.message : String(error);
    core.setFailed(`Prepare step failed with error: ${errorMessage}`);
--- a/src/entrypoints/update-comment-link.ts
+++ b/src/entrypoints/update-comment-link.ts
@@ -9,6 +9,7 @@ import {
 import {
  parseGitHubContext,
  isPullRequestReviewCommentEvent,
+  isEntityContext,
 } from "../github/context";
 import { GITHUB_SERVER_URL } from "../github/api/config";
 import { checkAndCommitOrDeleteBranch } from "../github/operations/branch-cleanup";
@@ -23,7 +24,14 @@ async function run() {
    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 { owner, repo } = context.repository;
+
    const octokit = createOctokit(githubToken);

    const serverUrl = GITHUB_SERVER_URL;
--- a/src/github/api/queries/github.ts
+++ b/src/github/api/queries/github.ts
@@ -46,6 +46,7 @@ export const PR_QUERY = `
              login
            }
            createdAt
+            isMinimized
          }
        }
        reviews(first: 100) {
@@ -69,6 +70,7 @@ export const PR_QUERY = `
                  login
                }
                createdAt
+                isMinimized
              }
            }
          }
@@ -98,6 +100,7 @@ export const ISSUE_QUERY = `
              login
            }
            createdAt
+            isMinimized
          }
        }
      }
--- a/src/github/context.ts
+++ b/src/github/context.ts
@@ -7,10 +7,54 @@ import type {
  PullRequestReviewEvent,
  PullRequestReviewCommentEvent,
 } from "@octokit/webhooks-types";
+// Custom types for GitHub Actions events that aren't webhooks
+export type WorkflowDispatchEvent = {
+  action?: never;
+  inputs?: Record<string, any>;
+  ref?: string;
+  repository: {
+    name: string;
+    owner: {
+      login: string;
+    };
+  };
+  sender: {
+    login: string;
+  };
+  workflow: string;
+};

-export type ParsedGitHubContext = {
+export type ScheduleEvent = {
+  action?: never;
+  schedule?: string;
+  repository: {
+    name: string;
+    owner: {
+      login: string;
+    };
+  };
+};
+import type { ModeName } from "../modes/types";
+import { DEFAULT_MODE, isValidMode } from "../modes/registry";
+
+// Event name constants for better maintainability
+const ENTITY_EVENT_NAMES = [
+  "issues",
+  "issue_comment",
+  "pull_request",
+  "pull_request_review",
+  "pull_request_review_comment",
+] as const;
+
+const AUTOMATION_EVENT_NAMES = ["workflow_dispatch", "schedule"] as const;
+
+// Derive types from constants for better maintainability
+type EntityEventName = (typeof ENTITY_EVENT_NAMES)[number];
+type AutomationEventName = (typeof AUTOMATION_EVENT_NAMES)[number];
+
+// Common fields shared by all context types
+type BaseContext = {
  runId: string;
-  eventName: string;
  eventAction?: string;
  repository: {
    owner: string;
@@ -18,15 +62,8 @@ export type ParsedGitHubContext = {
    full_name: string;
  };
  actor: string;
-  payload:
-    | IssuesEvent
-    | IssueCommentEvent
-    | PullRequestEvent
-    | PullRequestReviewEvent
-    | PullRequestReviewCommentEvent;
-  entityNumber: number;
-  isPR: boolean;
  inputs: {
+    mode: ModeName;
    triggerPhrase: string;
    assigneeTrigger: string;
    labelTrigger: string;
@@ -43,12 +80,38 @@ export type ParsedGitHubContext = {
  };
 };

-export function parseGitHubContext(): ParsedGitHubContext {
+// Context for entity-based events (issues, PRs, comments)
+export type ParsedGitHubContext = BaseContext & {
+  eventName: EntityEventName;
+  payload:
+    | IssuesEvent
+    | IssueCommentEvent
+    | PullRequestEvent
+    | PullRequestReviewEvent
+    | PullRequestReviewCommentEvent;
+  entityNumber: number;
+  isPR: boolean;
+};
+
+// Context for automation events (workflow_dispatch, schedule)
+export type AutomationContext = BaseContext & {
+  eventName: AutomationEventName;
+  payload: WorkflowDispatchEvent | ScheduleEvent;
+};
+
+// Union type for all contexts
+export type GitHubContext = ParsedGitHubContext | AutomationContext;
+
+export function parseGitHubContext(): GitHubContext {
  const context = github.context;

+  const modeInput = process.env.MODE ?? DEFAULT_MODE;
+  if (!isValidMode(modeInput)) {
+    throw new Error(`Invalid mode: ${modeInput}.`);
+  }
+
  const commonFields = {
    runId: process.env.GITHUB_RUN_ID!,
-    eventName: context.eventName,
    eventAction: context.payload.action,
    repository: {
      owner: context.repo.owner,
@@ -57,6 +120,7 @@ export function parseGitHubContext(): ParsedGitHubContext {
    },
    actor: context.actor,
    inputs: {
+      mode: modeInput as ModeName,
      triggerPhrase: process.env.TRIGGER_PHRASE ?? "@claude",
      assigneeTrigger: process.env.ASSIGNEE_TRIGGER ?? "",
      labelTrigger: process.env.LABEL_TRIGGER ?? "",
@@ -77,49 +141,69 @@ export function parseGitHubContext(): ParsedGitHubContext {

  switch (context.eventName) {
    case "issues": {
+      const payload = context.payload as IssuesEvent;
      return {
        ...commonFields,
-        payload: context.payload as IssuesEvent,
-        entityNumber: (context.payload as IssuesEvent).issue.number,
+        eventName: "issues",
+        payload,
+        entityNumber: payload.issue.number,
        isPR: false,
      };
    }
    case "issue_comment": {
+      const payload = context.payload as IssueCommentEvent;
      return {
        ...commonFields,
-        payload: context.payload as IssueCommentEvent,
-        entityNumber: (context.payload as IssueCommentEvent).issue.number,
-        isPR: Boolean(
-          (context.payload as IssueCommentEvent).issue.pull_request,
-        ),
+        eventName: "issue_comment",
+        payload,
+        entityNumber: payload.issue.number,
+        isPR: Boolean(payload.issue.pull_request),
      };
    }
    case "pull_request": {
+      const payload = context.payload as PullRequestEvent;
      return {
        ...commonFields,
-        payload: context.payload as PullRequestEvent,
-        entityNumber: (context.payload as PullRequestEvent).pull_request.number,
+        eventName: "pull_request",
+        payload,
+        entityNumber: payload.pull_request.number,
        isPR: true,
      };
    }
    case "pull_request_review": {
+      const payload = context.payload as PullRequestReviewEvent;
      return {
        ...commonFields,
-        payload: context.payload as PullRequestReviewEvent,
-        entityNumber: (context.payload as PullRequestReviewEvent).pull_request
-          .number,
+        eventName: "pull_request_review",
+        payload,
+        entityNumber: payload.pull_request.number,
        isPR: true,
      };
    }
    case "pull_request_review_comment": {
+      const payload = context.payload as PullRequestReviewCommentEvent;
      return {
        ...commonFields,
-        payload: context.payload as PullRequestReviewCommentEvent,
-        entityNumber: (context.payload as PullRequestReviewCommentEvent)
-          .pull_request.number,
+        eventName: "pull_request_review_comment",
+        payload,
+        entityNumber: payload.pull_request.number,
        isPR: true,
      };
    }
+    case "workflow_dispatch": {
+      return {
+        ...commonFields,
+        eventName: "workflow_dispatch",
+        payload: context.payload as unknown as WorkflowDispatchEvent,
+      };
+    }
+    case "schedule": {
+      return {
+        ...commonFields,
+        eventName: "schedule",
+        payload: context.payload as unknown as ScheduleEvent,
+      };
+    }
    default:
      throw new Error(`Unsupported event type: ${context.eventName}`);
  }
@@ -153,37 +237,53 @@ export function parseAdditionalPermissions(s: string): Map<string, string> {
 }

 export function isIssuesEvent(
-  context: ParsedGitHubContext,
+  context: GitHubContext,
 ): context is ParsedGitHubContext & { payload: IssuesEvent } {
  return context.eventName === "issues";
 }

 export function isIssueCommentEvent(
-  context: ParsedGitHubContext,
+  context: GitHubContext,
 ): context is ParsedGitHubContext & { payload: IssueCommentEvent } {
  return context.eventName === "issue_comment";
 }

 export function isPullRequestEvent(
-  context: ParsedGitHubContext,
+  context: GitHubContext,
 ): context is ParsedGitHubContext & { payload: PullRequestEvent } {
  return context.eventName === "pull_request";
 }

 export function isPullRequestReviewEvent(
-  context: ParsedGitHubContext,
+  context: GitHubContext,
 ): context is ParsedGitHubContext & { payload: PullRequestReviewEvent } {
  return context.eventName === "pull_request_review";
 }

 export function isPullRequestReviewCommentEvent(
-  context: ParsedGitHubContext,
+  context: GitHubContext,
 ): context is ParsedGitHubContext & { payload: PullRequestReviewCommentEvent } {
  return context.eventName === "pull_request_review_comment";
 }

 export function isIssuesAssignedEvent(
-  context: ParsedGitHubContext,
+  context: GitHubContext,
 ): context is ParsedGitHubContext & { payload: IssuesAssignedEvent } {
  return isIssuesEvent(context) && context.eventAction === "assigned";
 }
+
+// Type guard to check if context is an entity context (has entityNumber and isPR)
+export function isEntityContext(
+  context: GitHubContext,
+): context is ParsedGitHubContext {
+  return ENTITY_EVENT_NAMES.includes(context.eventName as EntityEventName);
+}
+
+// Type guard to check if context is an automation context
+export function isAutomationContext(
+  context: GitHubContext,
+): context is AutomationContext {
+  return AUTOMATION_EVENT_NAMES.includes(
+    context.eventName as AutomationEventName,
+  );
+}
--- a/src/github/data/fetcher.ts
+++ b/src/github/data/fetcher.ts
@@ -134,7 +134,7 @@ export async function fetchGitHubData({

  // Prepare all comments for image processing
  const issueComments: CommentWithImages[] = comments
-    .filter((c) => c.body)
+    .filter((c) => c.body && !c.isMinimized)
    .map((c) => ({
      type: "issue_comment" as const,
      id: c.databaseId,
@@ -154,7 +154,7 @@ export async function fetchGitHubData({
  const reviewComments: CommentWithImages[] =
    reviewData?.nodes
      ?.flatMap((r) => r.comments?.nodes ?? [])
-      .filter((c) => c.body)
+      .filter((c) => c.body && !c.isMinimized)
      .map((c) => ({
        type: "review_comment" as const,
        id: c.databaseId,
--- a/src/github/data/formatter.ts
+++ b/src/github/data/formatter.ts
@@ -50,6 +50,7 @@ export function formatComments(
  imageUrlMap?: Map<string, string>,
 ): string {
  return comments
+    .filter((comment) => !comment.isMinimized)
    .map((comment) => {
      let body = comment.body;

@@ -96,6 +97,7 @@ export function formatReviewComments(
      review.comments.nodes.length > 0
    ) {
      const comments = review.comments.nodes
+        .filter((comment) => !comment.isMinimized)
        .map((comment) => {
          let body = comment.body;

@@ -110,7 +112,9 @@ export function formatReviewComments(
          return `  [Comment on ${comment.path}:${comment.line || "?"}]: ${body}`;
        })
        .join("\n");
-      reviewOutput += `\n${comments}`;
+      if (comments) {
+        reviewOutput += `\n${comments}`;
+      }
    }

    return reviewOutput;
--- a/src/github/types.ts
+++ b/src/github/types.ts
@@ -10,6 +10,7 @@ export type GitHubComment = {
  body: string;
  author: GitHubAuthor;
  createdAt: string;
+  isMinimized?: boolean;
 };

 export type GitHubReviewComment = GitHubComment & {
--- a/src/mcp/install-mcp-server.ts
+++ b/src/mcp/install-mcp-server.ts
@@ -1,6 +1,7 @@
 import * as core from "@actions/core";
-import { GITHUB_API_URL } from "../github/api/config";
-import type { ParsedGitHubContext } from "../github/context";
+import { GITHUB_API_URL, GITHUB_SERVER_URL } from "../github/api/config";
+import type { GitHubContext } from "../github/context";
+import { isEntityContext } from "../github/context";
 import { Octokit } from "@octokit/rest";

 type PrepareConfigParams = {
@@ -12,7 +13,7 @@ type PrepareConfigParams = {
  additionalMcpConfig?: string;
  claudeCommentId?: string;
  allowedTools: string[];
-  context: ParsedGitHubContext;
+  context: GitHubContext;
 };

 async function checkActionsReadPermission(
@@ -115,7 +116,7 @@ export async function prepareMcpConfig(
    const hasActionsReadPermission =
      context.inputs.additionalPermissions.get("actions") === "read";

-    if (context.isPR && hasActionsReadPermission) {
+    if (isEntityContext(context) && context.isPR && hasActionsReadPermission) {
      // Verify the token actually has actions:read permission
      const actuallyHasPermission = await checkActionsReadPermission(
        process.env.ACTIONS_TOKEN || "",
@@ -141,7 +142,9 @@ export async function prepareMcpConfig(
          GITHUB_TOKEN: process.env.ACTIONS_TOKEN,
          REPO_OWNER: owner,
          REPO_NAME: repo,
-          PR_NUMBER: context.entityNumber.toString(),
+          PR_NUMBER: isEntityContext(context)
+            ? context.entityNumber?.toString() || ""
+            : "",
          RUNNER_TEMP: process.env.RUNNER_TEMP || "/tmp",
        },
      };
@@ -156,10 +159,13 @@ export async function prepareMcpConfig(
          "--rm",
          "-e",
          "GITHUB_PERSONAL_ACCESS_TOKEN",
-          "ghcr.io/github/github-mcp-server:sha-721fd3e", // https://github.com/github/github-mcp-server/releases/tag/v0.6.0
+          "-e",
+          "GITHUB_HOST",
+          "ghcr.io/github/github-mcp-server:sha-efef8ae", // https://github.com/github/github-mcp-server/releases/tag/v0.9.0
        ],
        env: {
          GITHUB_PERSONAL_ACCESS_TOKEN: githubToken,
+          GITHUB_HOST: GITHUB_SERVER_URL,
        },
      };
    }
--- a/src/modes/agent/index.ts
+++ b/src/modes/agent/index.ts
@@ -0,0 +1,111 @@
+import * as core from "@actions/core";
+import type { Mode, ModeOptions, ModeResult } from "../types";
+import { isAutomationContext } from "../../github/context";
+import type { PreparedContext } from "../../create-prompt/types";
+import { prepareMcpConfig } from "../../mcp/install-mcp-server";
+
+/**
+ * Agent mode implementation.
+ *
+ * This mode is specifically designed for automation events (workflow_dispatch and schedule).
+ * It bypasses the standard trigger checking and comment tracking used by tag mode,
+ * making it ideal for scheduled tasks and manual workflow runs.
+ */
+export const agentMode: Mode = {
+  name: "agent",
+  description: "Automation mode for workflow_dispatch and schedule events",
+
+  shouldTrigger(context) {
+    // Only trigger for automation events
+    return isAutomationContext(context);
+  },
+
+  prepareContext(context) {
+    // Agent mode doesn't use comment tracking or branch management
+    return {
+      mode: "agent",
+      githubContext: context,
+    };
+  },
+
+  getAllowedTools() {
+    return [];
+  },
+
+  getDisallowedTools() {
+    return [];
+  },
+
+  shouldCreateTrackingComment() {
+    return false;
+  },
+
+  async prepare({ context, githubToken }: ModeOptions): Promise<ModeResult> {
+    // Agent mode handles automation events (workflow_dispatch, schedule) only
+
+    // Agent mode doesn't need to create prompt files here - handled by createPrompt
+
+    // Export tool environment variables for agent mode
+    const baseTools = [
+      "Edit",
+      "MultiEdit",
+      "Glob",
+      "Grep",
+      "LS",
+      "Read",
+      "Write",
+    ];
+
+    // Add user-specified tools
+    const allowedTools = [...baseTools, ...context.inputs.allowedTools];
+    const disallowedTools = [
+      "WebSearch",
+      "WebFetch",
+      ...context.inputs.disallowedTools,
+    ];
+
+    // Export as INPUT_ prefixed variables for the base action
+    core.exportVariable("INPUT_ALLOWED_TOOLS", allowedTools.join(","));
+    core.exportVariable("INPUT_DISALLOWED_TOOLS", disallowedTools.join(","));
+
+    // Get MCP configuration using the same setup as other modes
+    const additionalMcpConfig = process.env.MCP_CONFIG || "";
+    const mcpConfig = await prepareMcpConfig({
+      githubToken,
+      owner: context.repository.owner,
+      repo: context.repository.repo,
+      branch: "", // Agent mode doesn't use branches
+      baseBranch: "",
+      additionalMcpConfig,
+      claudeCommentId: undefined, // Agent mode doesn't track comments
+      allowedTools: [...baseTools, ...context.inputs.allowedTools],
+      context,
+    });
+
+    core.setOutput("mcp_config", mcpConfig);
+
+    return {
+      commentId: undefined,
+      branchInfo: {
+        baseBranch: "",
+        currentBranch: "",
+        claudeBranch: undefined,
+      },
+      mcpConfig: mcpConfig,
+    };
+  },
+
+  generatePrompt(context: PreparedContext): string {
+    // Agent mode uses override or direct prompt, no GitHub data needed
+    if (context.overridePrompt) {
+      return context.overridePrompt;
+    }
+
+    if (context.directPrompt) {
+      return context.directPrompt;
+    }
+
+    // Minimal fallback - repository is a string in PreparedContext
+    return `Repository: ${context.repository}`;
+  },
+};
--- a/src/modes/registry.ts
+++ b/src/modes/registry.ts
@@ -0,0 +1,66 @@
+/**
+ * Mode Registry for claude-code-action
+ *
+ * This module provides access to all available execution modes.
+ *
+ * To add a new mode:
+ * 1. Add the mode name to VALID_MODES below
+ * 2. Create the mode implementation in a new directory (e.g., src/modes/new-mode/)
+ * 3. Import and add it to the modes object below
+ * 4. Update action.yml description to mention the new mode
+ */
+
+import type { Mode, ModeName } from "./types";
+import { tagMode } from "./tag";
+import { agentMode } from "./agent";
+import { reviewMode } from "./review";
+import type { GitHubContext } from "../github/context";
+import { isAutomationContext } from "../github/context";
+
+export const DEFAULT_MODE = "tag" as const;
+export const VALID_MODES = ["tag", "agent", "experimental-review"] as const;
+
+/**
+ * All available modes.
+ * Add new modes here as they are created.
+ */
+const modes = {
+  tag: tagMode,
+  agent: agentMode,
+  "experimental-review": reviewMode,
+} as const satisfies Record<ModeName, Mode>;
+
+/**
+ * Retrieves a mode by name and validates it can handle the event type.
+ * @param name The mode name to retrieve
+ * @param context The GitHub context to validate against
+ * @returns The requested mode
+ * @throws Error if the mode is not found or cannot handle the event
+ */
+export function getMode(name: ModeName, context: GitHubContext): Mode {
+  const mode = modes[name];
+  if (!mode) {
+    const validModes = VALID_MODES.join("', '");
+    throw new Error(
+      `Invalid mode '${name}'. Valid modes are: '${validModes}'. Please check your workflow configuration.`,
+    );
+  }
+
+  // Validate mode can handle the event type
+  if (name === "tag" && isAutomationContext(context)) {
+    throw new Error(
+      `Tag mode cannot handle ${context.eventName} events. Use 'agent' mode for automation events.`,
+    );
+  }
+
+  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 {
+  return VALID_MODES.includes(name as ModeName);
+}
--- a/src/modes/review/index.ts
+++ b/src/modes/review/index.ts
@@ -0,0 +1,352 @@
+import * as core from "@actions/core";
+import type { Mode, ModeOptions, ModeResult } from "../types";
+import { checkContainsTrigger } from "../../github/validation/trigger";
+import { prepareMcpConfig } from "../../mcp/install-mcp-server";
+import { fetchGitHubData } from "../../github/data/fetcher";
+import type { FetchDataResult } from "../../github/data/fetcher";
+import { createPrompt } from "../../create-prompt";
+import type { PreparedContext } from "../../create-prompt";
+import { isEntityContext, isPullRequestEvent } from "../../github/context";
+import {
+  formatContext,
+  formatBody,
+  formatComments,
+  formatReviewComments,
+  formatChangedFilesWithSHA,
+} from "../../github/data/formatter";
+
+/**
+ * Review mode implementation.
+ *
+ * Code review mode that uses the default GitHub Action token
+ * and focuses on providing inline comments and suggestions.
+ * Automatically includes GitHub MCP tools for review operations.
+ */
+export const reviewMode: Mode = {
+  name: "experimental-review",
+  description:
+    "Experimental code review mode for inline comments and suggestions",
+
+  shouldTrigger(context) {
+    if (!isEntityContext(context)) {
+      return false;
+    }
+
+    // Review mode only works on PRs
+    if (!context.isPR) {
+      return false;
+    }
+
+    // For pull_request events, only trigger on specific actions
+    if (isPullRequestEvent(context)) {
+      const allowedActions = ["opened", "synchronize", "reopened"];
+      const action = context.payload.action;
+      return allowedActions.includes(action);
+    }
+
+    // For other events (comments), check for trigger phrase
+    return checkContainsTrigger(context);
+  },
+
+  prepareContext(context, data) {
+    return {
+      mode: "experimental-review",
+      githubContext: context,
+      commentId: data?.commentId,
+      baseBranch: data?.baseBranch,
+      claudeBranch: data?.claudeBranch,
+    };
+  },
+
+  getAllowedTools() {
+    return [
+      // Context tools - to know who the current user is
+      "mcp__github__get_me",
+      // Core review tools
+      "mcp__github__create_pending_pull_request_review",
+      "mcp__github__add_comment_to_pending_review",
+      "mcp__github__submit_pending_pull_request_review",
+      "mcp__github__delete_pending_pull_request_review",
+      "mcp__github__create_and_submit_pull_request_review",
+      // Comment tools
+      "mcp__github__add_issue_comment",
+      // PR information tools
+      "mcp__github__get_pull_request",
+      "mcp__github__get_pull_request_reviews",
+      "mcp__github__get_pull_request_status",
+    ];
+  },
+
+  getDisallowedTools() {
+    return [];
+  },
+
+  shouldCreateTrackingComment() {
+    return false; // Review mode uses the review body instead of a tracking comment
+  },
+
+  generatePrompt(
+    context: PreparedContext,
+    githubData: FetchDataResult,
+  ): string {
+    // Support overridePrompt
+    if (context.overridePrompt) {
+      return context.overridePrompt;
+    }
+
+    const {
+      contextData,
+      comments,
+      changedFilesWithSHA,
+      reviewData,
+      imageUrlMap,
+    } = githubData;
+    const { eventData } = context;
+
+    const formattedContext = formatContext(contextData, true); // Reviews are always for PRs
+    const formattedComments = formatComments(comments, imageUrlMap);
+    const formattedReviewComments = formatReviewComments(
+      reviewData,
+      imageUrlMap,
+    );
+    const formattedChangedFiles =
+      formatChangedFilesWithSHA(changedFilesWithSHA);
+    const formattedBody = contextData?.body
+      ? formatBody(contextData.body, imageUrlMap)
+      : "No description provided";
+
+    return `You are Claude, an AI assistant specialized in code reviews for GitHub pull requests. You are operating in REVIEW MODE, which means you should focus on providing thorough code review feedback using GitHub MCP tools for inline comments and suggestions.
+
+<formatted_context>
+${formattedContext}
+</formatted_context>
+
+<repository>${context.repository}</repository>
+${eventData.isPR && eventData.prNumber ? `<pr_number>${eventData.prNumber}</pr_number>` : ""}
+
+<comments>
+${formattedComments || "No comments yet"}
+</comments>
+
+<review_comments>
+${formattedReviewComments || "No review comments"}
+</review_comments>
+
+<changed_files>
+${formattedChangedFiles}
+</changed_files>
+
+<formatted_body>
+${formattedBody}
+</formatted_body>
+
+${
+  (eventData.eventName === "issue_comment" ||
+    eventData.eventName === "pull_request_review_comment" ||
+    eventData.eventName === "pull_request_review") &&
+  eventData.commentBody
+    ? `<trigger_comment>
+User @${context.triggerUsername}: ${eventData.commentBody}
+</trigger_comment>`
+    : ""
+}
+
+${
+  context.directPrompt
+    ? `<direct_prompt>
+${context.directPrompt}
+</direct_prompt>`
+    : ""
+}
+
+REVIEW MODE WORKFLOW:
+
+1. First, understand the PR context:
+   - You are reviewing PR #${eventData.isPR && eventData.prNumber ? eventData.prNumber : "[PR number]"} in ${context.repository}
+   - Use mcp__github__get_pull_request to get PR metadata
+   - Use the Read, Grep, and Glob tools to examine the modified files directly from disk
+   - This provides the full context and latest state of the code
+   - Look at the changed_files section above to see which files were modified
+
+2. Create a pending review:
+   - Use mcp__github__create_pending_pull_request_review to start your review
+   - This allows you to batch comments before submitting
+
+3. Add inline comments:
+   - Use mcp__github__add_comment_to_pending_review for each issue or suggestion
+   - Parameters:
+     * path: The file path (e.g., "src/index.js")
+     * line: Line number for single-line comments
+     * startLine & line: For multi-line comments (startLine is the first line, line is the last)
+     * side: "LEFT" (old code) or "RIGHT" (new code)
+     * subjectType: "line" for line-level comments
+     * body: Your comment text
+   
+   - When to use multi-line comments:
+     * When replacing multiple consecutive lines
+     * When the fix requires changes across several lines
+     * Example: To replace lines 19-20, use startLine: 19, line: 20
+   
+   - For code suggestions, use this EXACT format in the body:
+     \`\`\`suggestion
+     corrected code here
+     \`\`\`
+   
+   CRITICAL: GitHub suggestion blocks must ONLY contain the replacement for the specific line(s) being commented on:
+   - For single-line comments: Replace ONLY that line
+   - For multi-line comments: Replace ONLY the lines in the range
+   - Do NOT include surrounding context or function signatures
+   - Do NOT suggest changes that span beyond the commented lines
+   
+   Example for line 19 \`var name = user.name;\`:
+   WRONG:
+   \\\`\\\`\\\`suggestion
+   function processUser(user) {
+       if (!user) throw new Error('Invalid user');
+       const name = user.name;
+   \\\`\\\`\\\`
+   
+   CORRECT:
+   \\\`\\\`\\\`suggestion
+   const name = user.name;
+   \\\`\\\`\\\`
+   
+   For validation suggestions, comment on the function declaration line or create separate comments for each concern.
+
+4. Submit your review:
+   - Use mcp__github__submit_pending_pull_request_review
+   - Parameters:
+     * event: "COMMENT" (general feedback), "REQUEST_CHANGES" (issues found), or "APPROVE" (if appropriate)
+     * body: Write a comprehensive review summary that includes:
+       - Overview of what was reviewed (files, scope, focus areas)
+       - Summary of all issues found (with counts by severity if applicable)
+       - Key recommendations and action items
+       - Highlights of good practices observed
+       - Overall assessment and recommendation
+   - The body should be detailed and informative since it's the main review content
+   - Structure the body with clear sections using markdown headers
+
+REVIEW GUIDELINES:
+
+- Focus on:
+  * Security vulnerabilities
+  * Bugs and logic errors
+  * Performance issues
+  * Code quality and maintainability
+  * Best practices and standards
+  * Edge cases and error handling
+
+- Provide:
+  * Specific, actionable feedback
+  * Code suggestions when possible (following GitHub's format exactly)
+  * Clear explanations of issues
+  * Constructive criticism
+  * Recognition of good practices
+  * For complex changes that require multiple modifications:
+    - Create separate comments for each logical change
+    - Or explain the full solution in text without a suggestion block
+
+- Communication:
+  * All feedback goes through GitHub's review system
+  * Be professional and respectful
+  * Your review body is the main communication channel
+
+Before starting, analyze the PR inside <analysis> tags:
+<analysis>
+- PR title and description
+- Number of files changed and scope
+- Type of changes (feature, bug fix, refactor, etc.)
+- Key areas to focus on
+- Review strategy
+</analysis>
+
+Then proceed with the review workflow described above.
+
+IMPORTANT: Your review body is the primary way users will understand your feedback. Make it comprehensive and well-structured with:
+- Executive summary at the top
+- Detailed findings organized by severity or category
+- Clear action items and recommendations
+- Recognition of good practices
+This ensures users get value from the review even before checking individual inline comments.`;
+  },
+
+  async prepare({
+    context,
+    octokit,
+    githubToken,
+  }: ModeOptions): Promise<ModeResult> {
+    if (!isEntityContext(context)) {
+      throw new Error("Review mode requires entity context");
+    }
+
+    // Review mode doesn't create a tracking comment
+    const githubData = await fetchGitHubData({
+      octokits: octokit,
+      repository: `${context.repository.owner}/${context.repository.repo}`,
+      prNumber: context.entityNumber.toString(),
+      isPR: context.isPR,
+      triggerUsername: context.actor,
+    });
+
+    // Review mode doesn't need branch setup or git auth since it only creates comments
+    // Using minimal branch info since review mode doesn't create or modify branches
+    const branchInfo = {
+      baseBranch: "main",
+      currentBranch: "",
+      claudeBranch: undefined, // Review mode doesn't create branches
+    };
+
+    const modeContext = this.prepareContext(context, {
+      baseBranch: branchInfo.baseBranch,
+      claudeBranch: branchInfo.claudeBranch,
+    });
+
+    await createPrompt(reviewMode, modeContext, githubData, context);
+
+    // Export tool environment variables for review mode
+    const baseTools = [
+      "Edit",
+      "MultiEdit",
+      "Glob",
+      "Grep",
+      "LS",
+      "Read",
+      "Write",
+    ];
+
+    // Add mode-specific and user-specified tools
+    const allowedTools = [
+      ...baseTools,
+      ...this.getAllowedTools(),
+      ...context.inputs.allowedTools,
+    ];
+    const disallowedTools = [
+      "WebSearch",
+      "WebFetch",
+      ...context.inputs.disallowedTools,
+    ];
+
+    // Export as INPUT_ prefixed variables for the base action
+    core.exportVariable("INPUT_ALLOWED_TOOLS", allowedTools.join(","));
+    core.exportVariable("INPUT_DISALLOWED_TOOLS", disallowedTools.join(","));
+
+    const additionalMcpConfig = process.env.MCP_CONFIG || "";
+    const mcpConfig = await prepareMcpConfig({
+      githubToken,
+      owner: context.repository.owner,
+      repo: context.repository.repo,
+      branch: branchInfo.claudeBranch || branchInfo.currentBranch,
+      baseBranch: branchInfo.baseBranch,
+      additionalMcpConfig,
+      allowedTools: [...this.getAllowedTools(), ...context.inputs.allowedTools],
+      context,
+    });
+
+    core.setOutput("mcp_config", mcpConfig);
+
+    return {
+      branchInfo,
+      mcpConfig,
+    };
+  },
+};
--- a/src/modes/tag/index.ts
+++ b/src/modes/tag/index.ts
@@ -0,0 +1,133 @@
+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 } from "../../github/operations/git-config";
+import { prepareMcpConfig } from "../../mcp/install-mcp-server";
+import { fetchGitHubData } from "../../github/data/fetcher";
+import { createPrompt, generateDefaultPrompt } from "../../create-prompt";
+import { isEntityContext } from "../../github/context";
+import type { PreparedContext } from "../../create-prompt/types";
+import type { FetchDataResult } from "../../github/data/fetcher";
+
+/**
+ * Tag mode implementation.
+ *
+ * The traditional implementation mode that responds to @claude mentions,
+ * issue assignments, or labels. Creates tracking comments showing progress
+ * and has full implementation capabilities.
+ */
+export const tagMode: Mode = {
+  name: "tag",
+  description: "Traditional implementation mode triggered by @claude mentions",
+
+  shouldTrigger(context) {
+    // Tag mode only handles entity events
+    if (!isEntityContext(context)) {
+      return false;
+    }
+    return checkContainsTrigger(context);
+  },
+
+  prepareContext(context, data) {
+    return {
+      mode: "tag",
+      githubContext: context,
+      commentId: data?.commentId,
+      baseBranch: data?.baseBranch,
+      claudeBranch: data?.claudeBranch,
+    };
+  },
+
+  getAllowedTools() {
+    return [];
+  },
+
+  getDisallowedTools() {
+    return [];
+  },
+
+  shouldCreateTrackingComment() {
+    return true;
+  },
+
+  async prepare({
+    context,
+    octokit,
+    githubToken,
+  }: ModeOptions): Promise<ModeResult> {
+    // Tag mode only handles entity-based events
+    if (!isEntityContext(context)) {
+      throw new Error("Tag mode requires entity context");
+    }
+
+    // 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 githubData = await fetchGitHubData({
+      octokits: octokit,
+      repository: `${context.repository.owner}/${context.repository.repo}`,
+      prNumber: context.entityNumber.toString(),
+      isPR: context.isPR,
+      triggerUsername: context.actor,
+    });
+
+    // Setup branch
+    const branchInfo = await setupBranch(octokit, githubData, context);
+
+    // Configure git authentication if not using commit signing
+    if (!context.inputs.useCommitSigning) {
+      try {
+        await configureGitAuth(githubToken, context, commentData.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);
+
+    // Get MCP configuration
+    const additionalMcpConfig = process.env.MCP_CONFIG || "";
+    const mcpConfig = await prepareMcpConfig({
+      githubToken,
+      owner: context.repository.owner,
+      repo: context.repository.repo,
+      branch: branchInfo.claudeBranch || branchInfo.currentBranch,
+      baseBranch: branchInfo.baseBranch,
+      additionalMcpConfig,
+      claudeCommentId: commentId.toString(),
+      allowedTools: context.inputs.allowedTools,
+      context,
+    });
+
+    core.setOutput("mcp_config", mcpConfig);
+
+    return {
+      commentId,
+      branchInfo,
+      mcpConfig,
+    };
+  },
+
+  generatePrompt(
+    context: PreparedContext,
+    githubData: FetchDataResult,
+    useCommitSigning: boolean,
+  ): string {
+    return generateDefaultPrompt(context, githubData, useCommitSigning);
+  },
+};
--- a/src/modes/types.ts
+++ b/src/modes/types.ts
@@ -0,0 +1,93 @@
+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" | "experimental-review";
+
+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': Traditional implementation triggered by mentions/assignments
+ * - 'agent': For automation with no trigger checking
+ */
+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>;
+};
+
+// 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/test/create-prompt.test.ts
+++ b/test/create-prompt.test.ts
@@ -3,13 +3,37 @@
 import { describe, test, expect } from "bun:test";
 import {
  generatePrompt,
+  generateDefaultPrompt,
  getEventTypeAndContext,
  buildAllowedToolsString,
  buildDisallowedToolsString,
 } from "../src/create-prompt";
 import type { PreparedContext } from "../src/create-prompt";
+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: "{}",
+    }),
+  };
+
  const mockGitHubData = {
    contextData: {
      title: "Test PR",
@@ -133,7 +157,7 @@ describe("generatePrompt", () => {
      },
    };

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

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

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

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

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

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

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

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

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

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

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

    expect(prompt).toContain("<direct_prompt>");
    expect(prompt).toContain("Fix the bug in the login form");
@@ -292,7 +316,7 @@ describe("generatePrompt", () => {
      },
    };

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

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

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

    expect(prompt).toContain("CUSTOM INSTRUCTIONS:\nAlways use TypeScript");
  });
@@ -336,7 +360,7 @@ describe("generatePrompt", () => {
      },
    };

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

    expect(prompt).toBe("Simple prompt for owner/repo PR #123");
    expect(prompt).not.toContain("You are Claude, an AI assistant");
@@ -371,7 +395,7 @@ describe("generatePrompt", () => {
      },
    };

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

    expect(prompt).toContain("Repository: test/repo");
    expect(prompt).toContain("PR: 456");
@@ -418,7 +442,7 @@ describe("generatePrompt", () => {
      },
    };

-    const prompt = generatePrompt(envVars, issueGitHubData, false);
+    const prompt = generatePrompt(envVars, issueGitHubData, false, mockTagMode);

    expect(prompt).toBe("Issue #789: Bug: Login form broken in owner/repo");
  });
@@ -438,7 +462,7 @@ describe("generatePrompt", () => {
      },
    };

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

    expect(prompt).toBe("PR: 123, Issue: , Comment: ");
  });
@@ -458,7 +482,7 @@ describe("generatePrompt", () => {
      },
    };

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

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

-    const prompt = generatePrompt(envVars, mockGitHubData, false);
+    const prompt = 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
@@ -503,7 +527,7 @@ describe("generatePrompt", () => {
      },
    };

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

    // Should contain PR-specific instructions (git commands when not using signing)
    expect(prompt).toContain("git push");
@@ -534,7 +558,7 @@ describe("generatePrompt", () => {
      },
    };

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

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

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

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

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

    // Should contain branch-specific instructions like issues
    expect(prompt).toContain(
@@ -641,7 +665,7 @@ describe("generatePrompt", () => {
      },
    };

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

    // Should contain open PR instructions (git commands when not using signing)
    expect(prompt).toContain("git push");
@@ -672,7 +696,7 @@ describe("generatePrompt", () => {
      },
    };

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

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

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

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

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

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

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

    // Should have git command instructions
    expect(prompt).toContain("Use git commands via the Bash tool");
@@ -781,7 +805,7 @@ describe("generatePrompt", () => {
      },
    };

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

    // Should have commit signing tool instructions
    expect(prompt).toContain("mcp__github_file_ops__commit_files");
--- a/test/data-formatter.test.ts
+++ b/test/data-formatter.test.ts
@@ -252,6 +252,63 @@ describe("formatComments", () => {
      `[user1 at 2023-01-01T00:00:00Z]: Image: ![](https://github.com/user-attachments/assets/test.png)`,
    );
  });
+
+  test("filters out minimized comments", () => {
+    const comments: GitHubComment[] = [
+      {
+        id: "1",
+        databaseId: "100001",
+        body: "Normal comment",
+        author: { login: "user1" },
+        createdAt: "2023-01-01T00:00:00Z",
+        isMinimized: false,
+      },
+      {
+        id: "2",
+        databaseId: "100002",
+        body: "Minimized comment",
+        author: { login: "user2" },
+        createdAt: "2023-01-02T00:00:00Z",
+        isMinimized: true,
+      },
+      {
+        id: "3",
+        databaseId: "100003",
+        body: "Another normal comment",
+        author: { login: "user3" },
+        createdAt: "2023-01-03T00:00:00Z",
+      },
+    ];
+
+    const result = formatComments(comments);
+    expect(result).toBe(
+      `[user1 at 2023-01-01T00:00:00Z]: Normal comment\n\n[user3 at 2023-01-03T00:00:00Z]: Another normal comment`,
+    );
+  });
+
+  test("returns empty string when all comments are minimized", () => {
+    const comments: GitHubComment[] = [
+      {
+        id: "1",
+        databaseId: "100001",
+        body: "Minimized comment 1",
+        author: { login: "user1" },
+        createdAt: "2023-01-01T00:00:00Z",
+        isMinimized: true,
+      },
+      {
+        id: "2",
+        databaseId: "100002",
+        body: "Minimized comment 2",
+        author: { login: "user2" },
+        createdAt: "2023-01-02T00:00:00Z",
+        isMinimized: true,
+      },
+    ];
+
+    const result = formatComments(comments);
+    expect(result).toBe("");
+  });
 });

 describe("formatReviewComments", () => {
@@ -517,6 +574,159 @@ describe("formatReviewComments", () => {
      `[Review by reviewer1 at 2023-01-01T00:00:00Z]: APPROVED\nReview body\n  [Comment on src/index.ts:42]: Image: ![](https://github.com/user-attachments/assets/test.png)`,
    );
  });
+
+  test("filters out minimized review comments", () => {
+    const reviewData = {
+      nodes: [
+        {
+          id: "review1",
+          databaseId: "300001",
+          author: { login: "reviewer1" },
+          body: "Review with mixed comments",
+          state: "APPROVED",
+          submittedAt: "2023-01-01T00:00:00Z",
+          comments: {
+            nodes: [
+              {
+                id: "comment1",
+                databaseId: "200001",
+                body: "Normal review comment",
+                author: { login: "reviewer1" },
+                createdAt: "2023-01-01T00:00:00Z",
+                path: "src/index.ts",
+                line: 42,
+                isMinimized: false,
+              },
+              {
+                id: "comment2",
+                databaseId: "200002",
+                body: "Minimized review comment",
+                author: { login: "reviewer1" },
+                createdAt: "2023-01-01T00:00:00Z",
+                path: "src/utils.ts",
+                line: 15,
+                isMinimized: true,
+              },
+              {
+                id: "comment3",
+                databaseId: "200003",
+                body: "Another normal comment",
+                author: { login: "reviewer1" },
+                createdAt: "2023-01-01T00:00:00Z",
+                path: "src/main.ts",
+                line: 10,
+              },
+            ],
+          },
+        },
+      ],
+    };
+
+    const result = formatReviewComments(reviewData);
+    expect(result).toBe(
+      `[Review by reviewer1 at 2023-01-01T00:00:00Z]: APPROVED\nReview with mixed comments\n  [Comment on src/index.ts:42]: Normal review comment\n  [Comment on src/main.ts:10]: Another normal comment`,
+    );
+  });
+
+  test("returns review with only body when all review comments are minimized", () => {
+    const reviewData = {
+      nodes: [
+        {
+          id: "review1",
+          databaseId: "300001",
+          author: { login: "reviewer1" },
+          body: "Review body only",
+          state: "APPROVED",
+          submittedAt: "2023-01-01T00:00:00Z",
+          comments: {
+            nodes: [
+              {
+                id: "comment1",
+                databaseId: "200001",
+                body: "Minimized comment 1",
+                author: { login: "reviewer1" },
+                createdAt: "2023-01-01T00:00:00Z",
+                path: "src/index.ts",
+                line: 42,
+                isMinimized: true,
+              },
+              {
+                id: "comment2",
+                databaseId: "200002",
+                body: "Minimized comment 2",
+                author: { login: "reviewer1" },
+                createdAt: "2023-01-01T00:00:00Z",
+                path: "src/utils.ts",
+                line: 15,
+                isMinimized: true,
+              },
+            ],
+          },
+        },
+      ],
+    };
+
+    const result = formatReviewComments(reviewData);
+    expect(result).toBe(
+      `[Review by reviewer1 at 2023-01-01T00:00:00Z]: APPROVED\nReview body only`,
+    );
+  });
+
+  test("handles multiple reviews with mixed minimized comments", () => {
+    const reviewData = {
+      nodes: [
+        {
+          id: "review1",
+          databaseId: "300001",
+          author: { login: "reviewer1" },
+          body: "First review",
+          state: "APPROVED",
+          submittedAt: "2023-01-01T00:00:00Z",
+          comments: {
+            nodes: [
+              {
+                id: "comment1",
+                databaseId: "200001",
+                body: "Good comment",
+                author: { login: "reviewer1" },
+                createdAt: "2023-01-01T00:00:00Z",
+                path: "src/index.ts",
+                line: 42,
+                isMinimized: false,
+              },
+            ],
+          },
+        },
+        {
+          id: "review2",
+          databaseId: "300002",
+          author: { login: "reviewer2" },
+          body: "Second review",
+          state: "COMMENTED",
+          submittedAt: "2023-01-02T00:00:00Z",
+          comments: {
+            nodes: [
+              {
+                id: "comment2",
+                databaseId: "200002",
+                body: "Spam comment",
+                author: { login: "reviewer2" },
+                createdAt: "2023-01-02T00:00:00Z",
+                path: "src/utils.ts",
+                line: 15,
+                isMinimized: true,
+              },
+            ],
+          },
+        },
+      ],
+    };
+
+    const result = formatReviewComments(reviewData);
+    expect(result).toBe(
+      `[Review by reviewer1 at 2023-01-01T00:00:00Z]: APPROVED\nFirst review\n  [Comment on src/index.ts:42]: Good comment\n\n[Review by reviewer2 at 2023-01-02T00:00:00Z]: COMMENTED\nSecond review`,
+    );
+  });
 });

 describe("formatChangedFiles", () => {
--- a/test/fixtures/sample-turns-expected-output.md
+++ b/test/fixtures/sample-turns-expected-output.md
@@ -28,7 +28,7 @@ if __name__ == "__main__":
    print(result)
 ```

-*Token usage: 100 input, 75 output*
+*Token usage: 150 input, 75 output*

 ---

@@ -47,7 +47,7 @@ I can see the debug print statement that needs to be removed. Let me fix this by

 **→** File successfully edited. The debug print statement has been removed.

-*Token usage: 200 input, 50 output*
+*Token usage: 300 input, 50 output*

 ---

@@ -70,7 +70,7 @@ Perfect! I've successfully removed the debug print statement from the function.

 **→** Successfully posted review comment to PR #123

-*Token usage: 150 input, 80 output*
+*Token usage: 225 input, 80 output*

 ---

@@ -82,7 +82,7 @@ Great! I've successfully completed the requested task:

 The debug print statement has been removed as requested by the reviewers.

-*Token usage: 180 input, 60 output*
+*Token usage: 270 input, 60 output*

 ---

@@ -91,5 +91,3 @@ The debug print statement has been removed as requested by the reviewers.
 Successfully removed debug print statement from file and added review comment to document the change.

 **Cost:** $0.0347 | **Duration:** 18.8s
-
-
--- a/test/install-mcp-server.test.ts
+++ b/test/install-mcp-server.test.ts
@@ -24,6 +24,7 @@ describe("prepareMcpConfig", () => {
    entityNumber: 123,
    isPR: false,
    inputs: {
+      mode: "tag",
      triggerPhrase: "@claude",
      assigneeTrigger: "",
      labelTrigger: "",
--- a/test/mockContext.ts
+++ b/test/mockContext.ts
@@ -1,4 +1,7 @@
-import type { ParsedGitHubContext } from "../src/github/context";
+import type {
+  ParsedGitHubContext,
+  AutomationContext,
+} from "../src/github/context";
 import type {
  IssuesEvent,
  IssueCommentEvent,
@@ -8,6 +11,7 @@ import type {
 } from "@octokit/webhooks-types";

 const defaultInputs = {
+  mode: "tag" as const,
  triggerPhrase: "/claude",
  assigneeTrigger: "",
  labelTrigger: "",
@@ -37,7 +41,7 @@ export const createMockContext = (
 ): ParsedGitHubContext => {
  const baseContext: ParsedGitHubContext = {
    runId: "1234567890",
-    eventName: "",
+    eventName: "issue_comment", // Default to a valid entity event
    eventAction: "",
    repository: defaultRepository,
    actor: "test-actor",
@@ -54,6 +58,22 @@ export const createMockContext = (
  return { ...baseContext, ...overrides };
 };

+export const createMockAutomationContext = (
+  overrides: Partial<AutomationContext> = {},
+): AutomationContext => {
+  const baseContext: AutomationContext = {
+    runId: "1234567890",
+    eventName: "workflow_dispatch",
+    eventAction: undefined,
+    repository: defaultRepository,
+    actor: "test-actor",
+    payload: {} as any,
+    inputs: defaultInputs,
+  };
+
+  return { ...baseContext, ...overrides };
+};
+
 export const mockIssueOpenedContext: ParsedGitHubContext = {
  runId: "1234567890",
  eventName: "issues",
--- a/test/modes/agent.test.ts
+++ b/test/modes/agent.test.ts
@@ -0,0 +1,59 @@
+import { describe, test, expect, beforeEach } from "bun:test";
+import { agentMode } from "../../src/modes/agent";
+import type { GitHubContext } from "../../src/github/context";
+import { createMockContext, createMockAutomationContext } from "../mockContext";
+
+describe("Agent Mode", () => {
+  let mockContext: GitHubContext;
+
+  beforeEach(() => {
+    mockContext = createMockAutomationContext({
+      eventName: "workflow_dispatch",
+    });
+  });
+
+  test("agent mode has correct properties", () => {
+    expect(agentMode.name).toBe("agent");
+    expect(agentMode.description).toBe(
+      "Automation mode for workflow_dispatch and schedule events",
+    );
+    expect(agentMode.shouldCreateTrackingComment()).toBe(false);
+    expect(agentMode.getAllowedTools()).toEqual([]);
+    expect(agentMode.getDisallowedTools()).toEqual([]);
+  });
+
+  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 for workflow_dispatch and schedule events", () => {
+    // Should trigger for automation events
+    const workflowDispatchContext = createMockAutomationContext({
+      eventName: "workflow_dispatch",
+    });
+    expect(agentMode.shouldTrigger(workflowDispatchContext)).toBe(true);
+
+    const scheduleContext = createMockAutomationContext({
+      eventName: "schedule",
+    });
+    expect(agentMode.shouldTrigger(scheduleContext)).toBe(true);
+
+    // Should NOT trigger for entity events
+    const entityEvents = [
+      "issue_comment",
+      "pull_request",
+      "pull_request_review",
+      "issues",
+    ] as const;
+
+    entityEvents.forEach((eventName) => {
+      const context = createMockContext({ eventName });
+      expect(agentMode.shouldTrigger(context)).toBe(false);
+    });
+  });
+});
--- a/test/modes/registry.test.ts
+++ b/test/modes/registry.test.ts
@@ -0,0 +1,80 @@
+import { describe, test, expect } from "bun:test";
+import { getMode, isValidMode } from "../../src/modes/registry";
+import type { ModeName } from "../../src/modes/types";
+import { tagMode } from "../../src/modes/tag";
+import { agentMode } from "../../src/modes/agent";
+import { reviewMode } from "../../src/modes/review";
+import { createMockContext, createMockAutomationContext } from "../mockContext";
+
+describe("Mode Registry", () => {
+  const mockContext = createMockContext({
+    eventName: "issue_comment",
+  });
+
+  const mockWorkflowDispatchContext = createMockAutomationContext({
+    eventName: "workflow_dispatch",
+  });
+
+  const mockScheduleContext = createMockAutomationContext({
+    eventName: "schedule",
+  });
+
+  test("getMode returns tag mode for standard events", () => {
+    const mode = getMode("tag", mockContext);
+    expect(mode).toBe(tagMode);
+    expect(mode.name).toBe("tag");
+  });
+
+  test("getMode returns agent mode", () => {
+    const mode = getMode("agent", mockContext);
+    expect(mode).toBe(agentMode);
+    expect(mode.name).toBe("agent");
+  });
+
+  test("getMode returns experimental-review mode", () => {
+    const mode = getMode("experimental-review", mockContext);
+    expect(mode).toBe(reviewMode);
+    expect(mode.name).toBe("experimental-review");
+  });
+
+  test("getMode throws error for tag mode with workflow_dispatch event", () => {
+    expect(() => getMode("tag", mockWorkflowDispatchContext)).toThrow(
+      "Tag mode cannot handle workflow_dispatch events. Use 'agent' mode for automation events.",
+    );
+  });
+
+  test("getMode throws error for tag mode with schedule event", () => {
+    expect(() => getMode("tag", mockScheduleContext)).toThrow(
+      "Tag mode cannot handle schedule events. Use 'agent' mode for automation events.",
+    );
+  });
+
+  test("getMode allows agent mode for workflow_dispatch event", () => {
+    const mode = getMode("agent", mockWorkflowDispatchContext);
+    expect(mode).toBe(agentMode);
+    expect(mode.name).toBe("agent");
+  });
+
+  test("getMode allows agent mode for schedule event", () => {
+    const mode = getMode("agent", mockScheduleContext);
+    expect(mode).toBe(agentMode);
+    expect(mode.name).toBe("agent");
+  });
+
+  test("getMode throws error for invalid mode", () => {
+    const invalidMode = "invalid" as unknown as ModeName;
+    expect(() => getMode(invalidMode, mockContext)).toThrow(
+      "Invalid mode 'invalid'. Valid modes are: 'tag', 'agent', 'experimental-review'. Please check your workflow configuration.",
+    );
+  });
+
+  test("isValidMode returns true for all valid modes", () => {
+    expect(isValidMode("tag")).toBe(true);
+    expect(isValidMode("agent")).toBe(true);
+    expect(isValidMode("experimental-review")).toBe(true);
+  });
+
+  test("isValidMode returns false for invalid mode", () => {
+    expect(isValidMode("invalid")).toBe(false);
+  });
+});
--- a/test/modes/tag.test.ts
+++ b/test/modes/tag.test.ts
@@ -0,0 +1,92 @@
+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", () => {
+  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/permissions.test.ts
+++ b/test/permissions.test.ts
@@ -60,6 +60,7 @@ describe("checkWritePermissions", () => {
    entityNumber: 1,
    isPR: false,
    inputs: {
+      mode: "tag",
      triggerPhrase: "@claude",
      assigneeTrigger: "",
      labelTrigger: "",
--- a/test/prepare-context.test.ts
+++ b/test/prepare-context.test.ts
@@ -299,15 +299,4 @@ describe("parseEnvVarsWithContext", () => {
      expect(result.allowedTools).toBe("Tool1,Tool2");
    });
  });
-
-  test("should throw error for unsupported event type", () => {
-    process.env = BASE_ENV;
-    const unsupportedContext = createMockContext({
-      eventName: "unsupported_event",
-      eventAction: "whatever",
-    });
-    expect(() => prepareContext(unsupportedContext, "12345")).toThrow(
-      "Unsupported event type: unsupported_event",
-    );
-  });
 });
--- a/test/trigger-validation.test.ts
+++ b/test/trigger-validation.test.ts
@@ -28,6 +28,7 @@ describe("checkContainsTrigger", () => {
        eventName: "issues",
        eventAction: "opened",
        inputs: {
+          mode: "tag",
          triggerPhrase: "/claude",
          assigneeTrigger: "",
          labelTrigger: "",
@@ -60,6 +61,7 @@ describe("checkContainsTrigger", () => {
          },
        } as IssuesEvent,
        inputs: {
+          mode: "tag",
          triggerPhrase: "/claude",
          assigneeTrigger: "",
          labelTrigger: "",
@@ -276,6 +278,7 @@ describe("checkContainsTrigger", () => {
          },
        } as PullRequestEvent,
        inputs: {
+          mode: "tag",
          triggerPhrase: "@claude",
          assigneeTrigger: "",
          labelTrigger: "",
@@ -309,6 +312,7 @@ describe("checkContainsTrigger", () => {
          },
        } as PullRequestEvent,
        inputs: {
+          mode: "tag",
          triggerPhrase: "@claude",
          assigneeTrigger: "",
          labelTrigger: "",
@@ -342,6 +346,7 @@ describe("checkContainsTrigger", () => {
          },
        } as PullRequestEvent,
        inputs: {
+          mode: "tag",
          triggerPhrase: "@claude",
          assigneeTrigger: "",
          labelTrigger: "",
@@ -469,17 +474,6 @@ describe("checkContainsTrigger", () => {
      });
    });
  });
-
-  describe("non-matching events", () => {
-    it("should return false for non-matching event type", () => {
-      const context = createMockContext({
-        eventName: "push",
-        eventAction: "created",
-        payload: {} as any,
-      });
-      expect(checkContainsTrigger(context)).toBe(false);
-    });
-  });
 });

 describe("escapeRegExp", () => {