minor linting update again

specify the type
bun format
2026-01-23 06:54:13 +08:00 · 2025-07-29 14:51:02 -07:00 · 2025-07-29 14:48:49 -07:00 · 2025-07-29 14:40:48 -07:00 · 2025-07-29 14:40:05 -07:00 · 2025-07-29 14:32:28 -07:00
34 changed files with 1737 additions and 628 deletions
--- 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/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,79 @@ 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 with no trigger checking) | 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 two 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.
+```
+
+See [`examples/claude-modes.yml`](./examples/claude-modes.yml) for complete examples of each mode.
+
 ### 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)"
+    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 }}
@@ -155,47 +162,34 @@ runs:
        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.62
+
    - 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.62
+
    - 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.59",
      },
      "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.59", "", { "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-/DkygJuGk9fVPkBwB2a8o9Vi2/3iDvzi5+FJ6w4sUFTR97VTR84/zCP20PyY24zVWm++X3yslyqjOzOaYmtLnw=="],
-
    "@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.59"
+    "@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.59",
        "@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.59", "", { "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-/DkygJuGk9fVPkBwB2a8o9Vi2/3iDvzi5+FJ6w4sUFTR97VTR84/zCP20PyY24zVWm++X3yslyqjOzOaYmtLnw=="],
-
    "@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-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.59",
    "@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)
      : "",
@@ -788,25 +795,33 @@ 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("Tag 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,
@@ -828,14 +843,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();
--- a/src/entrypoints/prepare.ts
+++ b/src/entrypoints/prepare.ts
@@ -7,17 +7,11 @@

 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 } from "../modes/registry";
+import { prepare } from "../prepare";

 async function run() {
  try {
@@ -28,77 +22,41 @@ async function run() {
    // 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(context.inputs.mode, 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/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/mcp/install-mcp-server.ts
+++ b/src/mcp/install-mcp-server.ts
@@ -141,7 +141,7 @@ export async function prepareMcpConfig(
          GITHUB_TOKEN: process.env.ACTIONS_TOKEN,
          REPO_OWNER: owner,
          REPO_NAME: repo,
-          PR_NUMBER: context.entityNumber.toString(),
+          PR_NUMBER: context.entityNumber?.toString() || "",
          RUNNER_TEMP: process.env.RUNNER_TEMP || "/tmp",
        },
      };
@@ -156,7 +156,7 @@ 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
+          "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,
--- a/src/modes/agent/index.ts
+++ b/src/modes/agent/index.ts
@@ -0,0 +1,117 @@
+import * as core from "@actions/core";
+import { mkdir, writeFile } from "fs/promises";
+import type { Mode, ModeOptions, ModeResult } from "../types";
+import { isAutomationContext } from "../../github/context";
+
+/**
+ * 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 }: ModeOptions): Promise<ModeResult> {
+    // Agent mode handles automation events (workflow_dispatch, schedule) only
+
+    // Create prompt directory
+    await mkdir(`${process.env.RUNNER_TEMP}/claude-prompts`, {
+      recursive: true,
+    });
+
+    // Write the prompt file - the base action requires a prompt_file parameter,
+    // so we must create this file even though agent mode typically uses
+    // override_prompt or direct_prompt. If neither is provided, we write
+    // a minimal prompt with just the repository information.
+    const promptContent =
+      context.inputs.overridePrompt ||
+      context.inputs.directPrompt ||
+      `Repository: ${context.repository.owner}/${context.repository.repo}`;
+
+    await writeFile(
+      `${process.env.RUNNER_TEMP}/claude-prompts/claude-prompt.txt`,
+      promptContent,
+    );
+
+    // 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,
+    ];
+
+    core.exportVariable("ALLOWED_TOOLS", allowedTools.join(","));
+    core.exportVariable("DISALLOWED_TOOLS", disallowedTools.join(","));
+
+    // Agent mode uses a minimal MCP configuration
+    // We don't need comment servers or PR-specific tools for automation
+    const mcpConfig: any = {
+      mcpServers: {},
+    };
+
+    // Add user-provided additional MCP config if any
+    const additionalMcpConfig = process.env.MCP_CONFIG || "";
+    if (additionalMcpConfig.trim()) {
+      try {
+        const additional = JSON.parse(additionalMcpConfig);
+        if (additional && typeof additional === "object") {
+          Object.assign(mcpConfig, additional);
+        }
+      } catch (error) {
+        core.warning(`Failed to parse additional MCP config: ${error}`);
+      }
+    }
+
+    core.setOutput("mcp_config", JSON.stringify(mcpConfig));
+
+    return {
+      commentId: undefined,
+      branchInfo: {
+        baseBranch: "",
+        currentBranch: "",
+        claudeBranch: undefined,
+      },
+      mcpConfig: JSON.stringify(mcpConfig),
+    };
+  },
+};
--- a/src/modes/registry.ts
+++ b/src/modes/registry.ts
@@ -0,0 +1,64 @@
+/**
+ * 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 type { GitHubContext } from "../github/context";
+import { isAutomationContext } from "../github/context";
+
+export const DEFAULT_MODE = "tag" as const;
+export const VALID_MODES = ["tag", "agent"] as const;
+
+/**
+ * All available modes.
+ * Add new modes here as they are created.
+ */
+const modes = {
+  tag: tagMode,
+  agent: agentMode,
+} 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/tag/index.ts
+++ b/src/modes/tag/index.ts
@@ -0,0 +1,123 @@
+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 } from "../../create-prompt";
+import { isEntityContext } from "../../github/context";
+
+/**
+ * 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,
+    };
+  },
+};
--- a/src/modes/types.ts
+++ b/src/modes/types.ts
@@ -0,0 +1,80 @@
+import type { GitHubContext } from "../github/context";
+
+export type ModeName = "tag" | "agent";
+
+export type ModeContext = {
+  mode: ModeName;
+  githubContext: GitHubContext;
+  commentId?: number;
+  baseBranch?: string;
+  claudeBranch?: string;
+};
+
+export type ModeData = {
+  commentId?: number;
+  baseBranch?: string;
+  claudeBranch?: string;
+};
+
+/**
+ * Mode interface for claude-code-action execution modes.
+ * Each mode defines its own behavior for trigger detection, prompt generation,
+ * and tracking comment creation.
+ *
+ * Current modes include:
+ * - 'tag': 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;
+
+  /**
+   * 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 to avoid circular dependencies
+export type ModeOptions = {
+  context: GitHubContext;
+  octokit: any; // We'll use any to avoid circular dependency with 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/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,73 @@
+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 { 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 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'. Please check your workflow configuration.",
+    );
+  });
+
+  test("isValidMode returns true for all valid modes", () => {
+    expect(isValidMode("tag")).toBe(true);
+    expect(isValidMode("agent")).toBe(true);
+  });
+
+  test("isValidMode returns false for invalid mode", () => {
+    expect(isValidMode("invalid")).toBe(false);
+    expect(isValidMode("review")).toBe(false);
+  });
+});
--- a/test/modes/tag.test.ts
+++ b/test/modes/tag.test.ts
@@ -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", () => {
Author	SHA1	Message	Date
km-anthropic	665606ccf4	minor linting update again	2025-07-29 14:51:02 -07:00
km-anthropic	624adc1976	specify the type	2025-07-29 14:48:49 -07:00
km-anthropic	8207a5f128	bun format	2025-07-29 14:40:48 -07:00
km-anthropic	aaae231799	refactor: further simplify discriminated union implementation - Add event name constants to reduce duplication - Derive EntityEventName and AutomationEventName types from constants - Use isAutomationContext consistently in agent mode and registry - Simplify parseGitHubContext by removing redundant type assertions - Extract payload casts to variables for cleaner code Co-Authored-By: Claude <noreply@anthropic.com>	2025-07-29 14:40:05 -07:00
km-anthropic	68e711968d	some structural simplification	2025-07-29 14:32:28 -07:00
km-anthropic	5bdfd090e0	refactor: improve discriminated union implementation based on review feedback - Use eventName checks instead of 'in' operator for more robust type guards - Remove unnecessary type assertions - TypeScript's control flow analysis works correctly - Remove redundant runtime checks for entityNumber and isPR - Simplify code by using context directly after type guard Co-Authored-By: Claude <noreply@anthropic.com>	2025-07-29 13:26:35 -07:00
km-anthropic	9c8ca262b6	More robust type checking	2025-07-29 13:21:58 -07:00
km-anthropic	21680fe730	update comment	2025-07-29 13:16:09 -07:00
km-anthropic	b1033b2ba1	refactor: implement discriminated unions for GitHub contexts Split ParsedGitHubContext into entity-specific and automation contexts: - ParsedGitHubContext: For entity events (issues/PRs) with required entityNumber and isPR - AutomationContext: For workflow_dispatch/schedule events without entity fields - GitHubContext: Union type for all contexts This eliminates ~20 null checks throughout the codebase and provides better type safety. Entity-specific code paths are now guaranteed to have the required fields. Co-Authored-By: Claude <noreply@anthropic.com>	2025-07-29 13:09:01 -07:00
km-anthropic	f1ce8b3d62	Merge branch 'main' of https://github.com/anthropics/claude-code-action into km/add-workflow-dispatch-schedule-support	2025-07-29 11:55:20 -07:00
km-anthropic	ec0e9b4f87	add schedule & workflow dispatch paths. Also make prepare logic conditional (#353 ) * feat: add agent mode for automation scenarios - Add agent mode that always triggers without checking for mentions - Implement Mode interface with support for mode-specific tool configuration - Add getAllowedTools() and getDisallowedTools() methods to Mode interface - Simplify tests by combining related test cases - Update documentation and examples to include agent mode - Fix TypeScript imports to prevent circular dependencies Agent mode is designed for automation and workflow_dispatch scenarios where Claude should always run without requiring trigger phrases. 🤖 Generated with [Claude Code](https://claude.ai/code) Co-Authored-By: Claude <noreply@anthropic.com> * Minor update to readme (from @main to @beta) * Since workflow_dispatch isn't in the base action, update the examples accordingly * minor formatting issue * Update to say beta instead of main * Fix missed tracking comment to be false * add schedule & workflow dispatch paths. Also make prepare logic conditional * tests * Add test workflow for workflow_dispatch functionality * Update workflow to use correct branch reference * remove test workflow dispatch file * minor lint update * update workflow dispatch agent example * minor lint update * refactor: simplify prepare logic with mode-specific implementations * ensure tag mode can't work with workflow dispatch and schedule tasks * simplify: remove workflow_dispatch/schedule from create-prompt - Remove workflow_dispatch and schedule event handling from create-prompt since agent mode doesn't use the standard prompt generation flow - Enforce mode compatibility at selection time in the registry instead of runtime validation in tag mode - Add explanatory comment in agent mode about why prompt file is needed - Update tests to reflect simplified event handling This reduces code duplication and makes the separation between tag mode (entity-based events) and agent mode (automation events) clearer. * simplify PR by making agent mode only work with workflow dispatch and schedule events * remove unnecessary changes * remove unnecessary changes from PR - Revert update-comment-link.ts changes (agent mode doesn't use this) - Revert create-initial.ts changes (agent mode doesn't create comments) - Remove unused default-branch.ts file - Revert install-mcp-server.ts changes (agent mode uses minimal MCP) These files are only used by tag mode for entity-based events, not needed for workflow_dispatch/schedule support via agent mode. * fix: handle optional entityNumber for TypeScript - Add runtime checks in files that require entityNumber - These files are only used by tag mode which always has entityNumber - Agent mode (workflow_dispatch/schedule) doesn't use these files * linting update --------- Co-authored-by: km-anthropic <km-anthropic@users.noreply.github.com> Co-authored-by: Claude <noreply@anthropic.com>	2025-07-29 11:52:45 -07:00
Ashwin Bhat	af32fd318a	Revert "feat: add GITHUB_HOST to github-mcp-server for GitHub Enterprise Serv…" (#359 ) This reverts commit `e07ea013bd`.	2025-07-29 11:51:20 -07:00
km-anthropic	5146c656e8	linting update	2025-07-29 11:16:51 -07:00
km-anthropic	5da8dc78e6	fix: handle optional entityNumber for TypeScript - Add runtime checks in files that require entityNumber - These files are only used by tag mode which always has entityNumber - Agent mode (workflow_dispatch/schedule) doesn't use these files	2025-07-29 11:16:09 -07:00
km-anthropic	1c2e7e788d	Merge branch 'main' of https://github.com/anthropics/claude-code-action into km/add-workflow-dispatch-schedule-support	2025-07-29 11:08:07 -07:00
km-anthropic	b85d457dc6	remove unnecessary changes from PR - Revert update-comment-link.ts changes (agent mode doesn't use this) - Revert create-initial.ts changes (agent mode doesn't create comments) - Remove unused default-branch.ts file - Revert install-mcp-server.ts changes (agent mode uses minimal MCP) These files are only used by tag mode for entity-based events, not needed for workflow_dispatch/schedule support via agent mode.	2025-07-29 11:06:24 -07:00
km-anthropic	3ebb5202a2	remove unnecessary changes	2025-07-29 11:01:38 -07:00
km-anthropic	3402c5355d	simplify PR by making agent mode only work with workflow dispatch and schedule events	2025-07-29 10:46:44 -07:00
km-anthropic	26d6ecc65d	simplify: remove workflow_dispatch/schedule from create-prompt - Remove workflow_dispatch and schedule event handling from create-prompt since agent mode doesn't use the standard prompt generation flow - Enforce mode compatibility at selection time in the registry instead of runtime validation in tag mode - Add explanatory comment in agent mode about why prompt file is needed - Update tests to reflect simplified event handling This reduces code duplication and makes the separation between tag mode (entity-based events) and agent mode (automation events) clearer.	2025-07-29 10:15:22 -07:00
km-anthropic	859e93f18e	ensure tag mode can't work with workflow dispatch and schedule tasks	2025-07-29 09:38:00 -07:00
km-anthropic	96970dfa2d	refactor: simplify prepare logic with mode-specific implementations	2025-07-29 08:56:26 -07:00
YutaSaito	e07ea013bd	feat: add GITHUB_HOST to github-mcp-server for GitHub Enterprise Server (#343 )	2025-07-28 17:39:52 -07:00
aki77	6037d754ac	chore: update MCP server image to version 0.9.0 (#344 )	2025-07-28 16:20:59 -07:00
GitHub Actions	04b2df22d4	chore: bump Claude Code version to 1.0.62	2025-07-28 22:36:23 +00:00
km-anthropic	11d4e4c175	minor lint update	2025-07-28 12:28:57 -07:00
km-anthropic	bde5e40caf	update workflow dispatch agent example	2025-07-28 12:27:05 -07:00
km-anthropic	6dbeb928d1	minor lint update	2025-07-28 12:21:12 -07:00
km-anthropic	cc8c99b7b4	Merge branch 'main' of https://github.com/anthropics/claude-code-action into km/add-workflow-dispatch-schedule-support	2025-07-28 12:19:37 -07:00
km-anthropic	aa2ef8067e	remove test workflow dispatch file	2025-07-28 12:03:45 -07:00
km-anthropic	a433016152	Update workflow to use correct branch reference	2025-07-28 11:53:48 -07:00
km-anthropic	7a53e0529b	Add test workflow for workflow_dispatch functionality	2025-07-28 11:52:52 -07:00
km-anthropic	dfe00d37c1	tests	2025-07-28 11:49:30 -07:00
km-anthropic	999dd8a3b6	add schedule & workflow dispatch paths. Also make prepare logic conditional	2025-07-28 11:28:06 -07:00
Ashwin Bhat	8fc9a366cb	chore: update Claude Code installation to use bun and version 1.0.61 (#352 ) - Switch from npm to bun for Claude Code installation in base-action - Update Claude Code version from 1.0.59 to 1.0.61 in main action - Ensures consistent package manager usage across both action files 🤖 Generated with [Claude Code](https://claude.ai/code) Co-authored-by: Claude <noreply@anthropic.com>	2025-07-28 09:44:51 -07:00
GitHub Actions	7c5a98d59d	chore: bump Claude Code version to 1.0.61	2025-07-25 21:06:57 +00:00
km-anthropic	c3e0ab4d6d	feat: add agent mode for automation scenarios (#337 ) * feat: add agent mode for automation scenarios - Add agent mode that always triggers without checking for mentions - Implement Mode interface with support for mode-specific tool configuration - Add getAllowedTools() and getDisallowedTools() methods to Mode interface - Simplify tests by combining related test cases - Update documentation and examples to include agent mode - Fix TypeScript imports to prevent circular dependencies Agent mode is designed for automation and workflow_dispatch scenarios where Claude should always run without requiring trigger phrases. 🤖 Generated with [Claude Code](https://claude.ai/code) Co-Authored-By: Claude <noreply@anthropic.com> * Minor update to readme (from @main to @beta) * Since workflow_dispatch isn't in the base action, update the examples accordingly * minor formatting issue * Update to say beta instead of main * Fix missed tracking comment to be false --------- Co-authored-by: km-anthropic <km-anthropic@users.noreply.github.com> Co-authored-by: Claude <noreply@anthropic.com>	2025-07-24 14:53:15 -07:00
GitHub Actions	94437192fa	chore: bump Claude Code version to 1.0.60	2025-07-24 21:02:45 +00:00
km-anthropic	a53ce607e4	Fix missed tracking comment to be false	2025-07-24 13:25:26 -07:00
km-anthropic	02c804a6be	Update to say beta instead of main	2025-07-24 13:23:55 -07:00
km-anthropic	cda7d07f95	minor formatting issue	2025-07-24 12:31:20 -07:00
km-anthropic	65bfefd6c4	Since workflow_dispatch isn't in the base action, update the examples accordingly	2025-07-24 10:11:40 -07:00
km-anthropic	4a6d3cf183	Minor update to readme (from @main to @beta)	2025-07-24 08:35:25 -07:00
km-anthropic	3fef2d3f20	feat: add agent mode for automation scenarios - Add agent mode that always triggers without checking for mentions - Implement Mode interface with support for mode-specific tool configuration - Add getAllowedTools() and getDisallowedTools() methods to Mode interface - Simplify tests by combining related test cases - Update documentation and examples to include agent mode - Fix TypeScript imports to prevent circular dependencies Agent mode is designed for automation and workflow_dispatch scenarios where Claude should always run without requiring trigger phrases. 🤖 Generated with [Claude Code](https://claude.ai/code) Co-Authored-By: Claude <noreply@anthropic.com>	2025-07-24 00:01:40 -07:00
Yuku Kotani	9cf75f75b9	feat: format PR and issue body text in prompt variables (#330 ) * feat: format PR and issue body text in prompt variables Apply formatBody function to PR_BODY and ISSUE_BODY variables to properly handle images and markdown formatting in prompt context. 🤖 Generated with [Claude Code](https://claude.ai/code) Co-Authored-By: Claude <noreply@anthropic.com> * style: format PR_BODY and ISSUE_BODY ternary expressions 🤖 Generated with [Claude Code](https://claude.ai/code) Co-Authored-By: Claude <noreply@anthropic.com> * feat: add claude_code_oauth_token to all GitHub workflow tests Add claude_code_oauth_token parameter to all test workflow files to support new authentication method. This ensures proper authentication for Claude Code API access in GitHub Actions. 🤖 Generated with [Claude Code](https://claude.ai/code) Co-Authored-By: Claude <noreply@anthropic.com> * Revert "feat: add claude_code_oauth_token to all GitHub workflow tests" This reverts commit `fccc1a0ebd`. --------- Co-authored-by: Claude <noreply@anthropic.com>	2025-07-23 22:16:10 -07:00
km-anthropic	a58dc37018	Add mode support (#333 ) * Add mode support * update "as any" with proper "as unknwon as ModeName" casting * Add documentation to README and registry.ts * Add tests for differen event types, integration flows, and error conditions * Clean up some tests * Minor test fix * Minor formatting test + switch from interface to type * correct the order of mkdir call * always configureGitAuth as there's already a fallback to handle null users by using the bot ID * simplify registry setup --------- Co-authored-by: km-anthropic <km-anthropic@users.noreply.github.com>	2025-07-23 20:35:11 -07:00
Ashwin Bhat	963754fa12	perf: optimize Squid proxy startup time (#334 ) * perf: optimize Squid proxy startup time - Replace fixed 7-second sleep with dynamic readiness check - Only shutdown existing Squid if actually running - Add detailed timing logs to track each step's duration - Expected reduction: ~7-8 seconds to ~1-2 seconds startup overhead 🤖 Generated with [Claude Code](https://claude.ai/code) Co-Authored-By: Claude <noreply@anthropic.com> * refactor: extract squid setup into standalone script Move squid proxy setup logic from action.yml inline bash script to scripts/setup-network-restrictions.sh for better maintainability and cleaner action configuration. 🤖 Generated with [Claude Code](https://claude.ai/code) Co-Authored-By: Claude <noreply@anthropic.com> * Revert "refactor: extract squid setup into standalone script" This reverts commit `b18aa2821d`. * tmp * Reapply "refactor: extract squid setup into standalone script" This reverts commit `07f6911549`. --------- Co-authored-by: Claude <noreply@anthropic.com>	2025-07-23 20:33:29 -07:00
Ashwin Bhat	3f4d843152	Revert "feat: integrate Claude Code SDK to replace process spawning (#327 )" (#335 ) * Revert "feat: integrate Claude Code SDK to replace process spawning (#327)" This reverts commit `204266ca45`. * 1.0.59	2025-07-23 18:42:43 -07:00