aidp 0.30.0 → 0.31.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: dcf4f30f93195b349c527dd5531e056ad566a34be1ed079ced4b5002f07a93f5
-  data.tar.gz: 22a7ef871ab691e0072a1bc8f1254784e1605f46d3edfc9585e91c3a21c5180f
+  metadata.gz: de5176199a74d1e4992451708e3830fff889cffd526c8bc0887a0aa73a4946a9
+  data.tar.gz: 399593a4d2b8d6991d37d22f383c3cd816b5b276b42e1aa45b0a2df064a470da
 SHA512:
-  metadata.gz: c5630eb8255464816006bb091b02666b29ac58b4a1e3e9136c17f79dff54762d6ebe16a4ec45df3f26c22047959121db04ef4e94904be5a4fb2e03320c6a6113
-  data.tar.gz: 5bdae7edfb7aad8ef03dd2274c4a8095bd927097cbd882a28856f0f753b46c4f1f0d8f756801c6df239bd13540355cbf9e53805b3bc815e5ac1cfc407d61c1c9
+  metadata.gz: 1d290891c58232da0b32ca1a8560ba211f5a5805c8aa7b24d78f1536cd4e32750ca9ee11dbb8c1b25f018ed50082c5fd52e9412f7b871981f0ff8eacef6f5e15
+  data.tar.gz: c10ee2a196880353991978cdf7a92775e13828b82452ba323c152853740a402a07bad29dad8984da1f9f0e2f650e5075bde9308ac8cc326b89de72af66652b2a

data/lib/aidp/config.rb

@@ -111,11 +111,10 @@ module Aidp
           model_family: "claude",
           max_tokens: 100_000,
           default_flags: ["--dangerously-skip-permissions"],
-          models: ["claude-3-5-sonnet-20241022", "claude-3-5-haiku-20241022", "claude-3-opus-20240229"],
+          models: ["claude-3-5-sonnet-20241022", "claude-3-5-haiku-20241022"],
           model_weights: {
             "claude-3-5-sonnet-20241022" => 3,
-            "claude-3-5-haiku-20241022" => 2,
-            "claude-3-opus-20240229" => 1
+            "claude-3-5-haiku-20241022" => 2
           },
           models_config: {
             "claude-3-5-sonnet-20241022" => {
@@ -127,11 +126,6 @@ module Aidp
               flags: ["--dangerously-skip-permissions"],
               max_tokens: 200_000,
               timeout: 180
-            },
-            "claude-3-opus-20240229" => {
-              flags: ["--dangerously-skip-permissions"],
-              max_tokens: 200_000,
-              timeout: 600
             }
           },
           auth: {

data/lib/aidp/harness/configuration.rb

@@ -1057,7 +1057,7 @@ module Aidp
       def default_thinking_config
         {
           default_tier: "mini",  # Use mini tier by default for cost optimization
-          max_tier: "max",
+          max_tier: "pro",       # Max tier rarely needed; pro is sufficient for most tasks
           allow_provider_switch: true,
           auto_escalate: true,
           escalation_threshold: 2,

data/lib/aidp/harness/provider_manager.rb

@@ -1394,9 +1394,9 @@ module Aidp
 
       # Execute a prompt with a specific provider
       def execute_with_provider(provider_type, prompt, options = {})
-        # Extract model and tier from options if provided
+        # Extract model from options if provided
         model_name = options.delete(:model)
-        tier = options[:tier] # Keep tier in options for provider
+        retry_on_rate_limit = options.delete(:retry_on_rate_limit) != false # Default true
 
         # Create provider factory instance
         provider_factory = ProviderFactory.new
@@ -1415,11 +1415,10 @@ module Aidp
         Aidp.logger.debug("provider_manager", "Executing with provider",
           provider: provider_type,
           model: model_name,
-          tier: tier,
           prompt_length: prompt.length)
 
-        # Execute the prompt with the provider (pass options including tier)
-        result = provider.send_message(prompt: prompt, session: nil, options: options)
+        # Execute the prompt with the provider
+        result = provider.send_message(prompt: prompt, session: nil)
 
         # Return structured result
         {
@@ -1436,6 +1435,38 @@ module Aidp
         }
       rescue => e
         log_rescue(e, component: "provider_manager", action: "execute_with_provider", fallback: "error_result", provider: provider_type, model: model_name, prompt_length: prompt.length)
+
+        # Detect rate limit / quota errors and attempt fallback
+        error_message = e.message.to_s.downcase
+        is_rate_limit = error_message.include?("rate limit") ||
+          error_message.include?("quota") ||
+          error_message.include?("limit reached") ||
+          error_message.include?("resource exhausted") ||
+          error_message.include?("too many requests")
+
+        if is_rate_limit && retry_on_rate_limit
+          Aidp.logger.warn("provider_manager", "Rate limit detected, attempting fallback",
+            provider: provider_type,
+            model: model_name,
+            error: e.message)
+
+          # Attempt to switch to fallback provider
+          fallback_provider = switch_provider_for_error("rate_limit", {
+            original_provider: provider_type,
+            model: model_name,
+            error_message: e.message
+          })
+
+          if fallback_provider && fallback_provider != provider_type
+            Aidp.logger.info("provider_manager", "Retrying with fallback provider",
+              original: provider_type,
+              fallback: fallback_provider)
+
+            # Retry with fallback provider (disable retry to prevent infinite loop)
+            return execute_with_provider(fallback_provider, prompt, options.merge(retry_on_rate_limit: false))
+          end
+        end
+
         # Return error result
         {
           status: "error",

data/lib/aidp/providers/anthropic.rb

@@ -408,20 +408,10 @@ module Aidp
             Aidp.log_debug("anthropic_provider", "error_classified",
               exit_code: result.exit_status,
               type: error_classification[:type],
-              confidence: error_classification[:confidence])            # Check for rate limit
-            if error_classification[:is_rate_limit]
-              Aidp.log_debug("anthropic_provider", "rate_limit_detected",
-                exit_code: result.exit_status,
-                confidence: error_classification[:confidence],
-                message: combined)
-              notify_rate_limit(combined)
-              error_message = "Rate limit reached for Claude CLI.\n#{combined}"
-              error = RuntimeError.new(error_message)
-              debug_error(error, {exit_code: result.exit_status, stdout: result.out, stderr: result.err})
-              raise error
-            end
+              confidence: error_classification[:confidence])
 
-            # Check for model deprecation
+            # Check for model deprecation FIRST (before rate limiting)
+            # Even if rate limited, we need to cache the deprecation for next run
             if error_classification[:is_deprecation]
               deprecated_model = @model
               Aidp.log_error("anthropic", "Model deprecation detected",
@@ -448,7 +438,7 @@ module Aidp
                 # Update model and retry
                 @model = replacement
 
-                # Retry with new model
+                # Retry with new model (even if rate limited, we'll hit rate limit with new model)
                 debug_log("🔄 Retrying with upgraded model: #{replacement}", level: :info)
                 return send_message(prompt: prompt, session: session, options: options)
               else
@@ -469,6 +459,19 @@ module Aidp
               end
             end
 
+            # Check for rate limit (after handling deprecation)
+            if error_classification[:is_rate_limit]
+              Aidp.log_debug("anthropic_provider", "rate_limit_detected",
+                exit_code: result.exit_status,
+                confidence: error_classification[:confidence],
+                message: combined)
+              notify_rate_limit(combined)
+              error_message = "Rate limit reached for Claude CLI.\n#{combined}"
+              error = RuntimeError.new(error_message)
+              debug_error(error, {exit_code: result.exit_status, stdout: result.out, stderr: result.err})
+              raise error
+            end
+
             # Check for auth issues
             if combined.downcase.include?("oauth token has expired") || combined.downcase.include?("authentication_error")
               error_message = "Authentication error from Claude CLI: token expired or invalid.\n" \

data/lib/aidp/providers/cursor.rb

@@ -56,7 +56,13 @@ module Aidp
             "api.cursor.sh",
             "cursor.sh",
             "app.cursor.sh",
-            "www.cursor.sh"
+            "www.cursor.sh",
+            # Authentication (Auth0)
+            "auth.cursor.sh",
+            "auth0.com",
+            "*.auth0.com",
+            "a0core.net",
+            "*.a0core.net"
           ],
           ip_ranges: []
         }

data/lib/aidp/setup/wizard.rb

@@ -50,6 +50,7 @@ module Aidp
         return @saved if skip_wizard?
 
         configure_providers
+        configure_harness_settings
         configure_thinking_tiers
         configure_work_loop
         configure_branching
@@ -285,6 +286,24 @@ module Aidp
         show_provider_summary(provider_choice, cleaned_fallbacks) unless provider_choice == "custom"
       end
 
+      # -------------------------------------------
+      # Harness settings (retries, limits, etc.)
+      # -------------------------------------------
+      def configure_harness_settings
+        prompt.say("\n⚙️  Harness Configuration")
+        prompt.say("  Advanced settings for provider behavior")
+        existing = get([:harness]) || {}
+
+        return unless prompt.yes?("Configure advanced harness settings?", default: false)
+
+        max_retries = ask_with_default(
+          "Maximum retry attempts for failed LLM calls",
+          (existing[:max_retries] || 2).to_s
+        ) { |value| value.to_i }
+
+        set([:harness, :max_retries], max_retries)
+      end
+
       # Removed MCP configuration step (MCP now expected to be provider-specific if used)
 
       # -------------------------------------------
@@ -473,6 +492,7 @@ module Aidp
         prompt.say("\n⚙️  Work loop configuration")
         prompt.say("-" * 40)
 
+        configure_work_loop_limits
         configure_test_commands
         configure_linting
         configure_watch_patterns
@@ -482,6 +502,19 @@ module Aidp
         configure_vcs_behavior
       end
 
+      def configure_work_loop_limits
+        existing = get([:work_loop]) || {}
+
+        return unless prompt.yes?("Configure work loop limits?", default: false)
+
+        max_iterations = ask_with_default(
+          "Maximum work loop iterations",
+          (existing[:max_iterations] || 50).to_s
+        ) { |value| value.to_i }
+
+        set([:work_loop, :max_iterations], max_iterations)
+      end
+
       def configure_test_commands
         existing = get([:work_loop, :test]) || {}
 
@@ -999,6 +1032,7 @@ module Aidp
 
         configure_watch_safety
         configure_watch_labels
+        configure_watch_change_requests
         configure_watch_label_creation
       end
 
@@ -1066,6 +1100,11 @@ module Aidp
           existing[:ci_fix_trigger] || "aidp-fix-ci"
         )
 
+        auto_trigger = ask_with_default(
+          "Label to trigger fully autonomous build+review+CI",
+          existing[:auto_trigger] || "aidp-auto"
+        )
+
         change_request_trigger = ask_with_default(
           "Label to trigger PR change implementation",
           existing[:change_request_trigger] || "aidp-request-changes"
@@ -1078,10 +1117,35 @@ module Aidp
           build_trigger: build_trigger,
           review_trigger: review_trigger,
           ci_fix_trigger: ci_fix_trigger,
+          auto_trigger: auto_trigger,
           change_request_trigger: change_request_trigger
         })
       end
 
+      def configure_watch_change_requests
+        prompt.say("\n📝 PR Change Request Configuration")
+        prompt.say("  Configure how AIDP handles automated PR change requests")
+        existing = get([:watch, :change_requests]) || {}
+
+        max_diff_size = ask_with_default(
+          "Maximum PR diff size (lines) for change requests",
+          (existing[:max_diff_size] || 5000).to_s
+        ) { |value| value.to_i }
+
+        post_comments = prompt.yes?(
+          "Post detection comments when work is detected?",
+          default: existing.fetch(:post_detection_comments, true)
+        )
+
+        set([:watch, :change_requests], {
+          max_diff_size: max_diff_size
+        })
+
+        set([:watch], {
+          post_detection_comments: post_comments
+        }.merge(get([:watch]) || {}))
+      end
+
       def configure_watch_label_creation
         prompt.say("\n🏷️  GitHub Label Auto-Creation")
         prompt.say("  Automatically create GitHub labels for watch mode if they don't exist")
@@ -1222,6 +1286,7 @@ module Aidp
           build_trigger: "5319E7",       # Purple
           review_trigger: "FBCA04",      # Yellow
           ci_fix_trigger: "D93F0B",      # Red
+          auto_trigger: "0C8BD6",        # Blue (distinct from build)
           change_request_trigger: "F9D0C4",  # Light pink
           in_progress: "1D76DB"          # Dark blue (internal coordination)
         }

data/lib/aidp/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Aidp
-  VERSION = "0.30.0"
+  VERSION = "0.31.0"
 end

data/lib/aidp/watch/auto_pr_processor.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+require_relative "../message_display"
+require_relative "github_state_extractor"
+
+module Aidp
+  module Watch
+    # Handles the aidp-auto label on PRs by chaining review and CI-fix flows
+    # until the PR is ready for human review.
+    class AutoPrProcessor
+      include Aidp::MessageDisplay
+
+      DEFAULT_AUTO_LABEL = "aidp-auto"
+
+      def initialize(repository_client:, state_store:, review_processor:, ci_fix_processor:, label_config: {}, verbose: false)
+        @repository_client = repository_client
+        @state_store = state_store
+        @review_processor = review_processor
+        @ci_fix_processor = ci_fix_processor
+        @state_extractor = GitHubStateExtractor.new(repository_client: repository_client)
+        @verbose = verbose
+        @auto_label = label_config[:auto_trigger] || label_config["auto_trigger"] || DEFAULT_AUTO_LABEL
+      end
+
+      def process(pr)
+        number = pr[:number]
+        Aidp.log_debug("auto_pr_processor", "process_started", pr: number, title: pr[:title])
+        display_message("🤖 Running autonomous review/CI loop for PR ##{number}", type: :info)
+
+        # Run review and CI fix flows. Each processor is responsible for its own guards.
+        @review_processor.process(pr)
+        @ci_fix_processor.process(pr)
+
+        finalize_if_ready(pr_number: number)
+      rescue => e
+        Aidp.log_error("auto_pr_processor", "process_failed", pr: pr[:number], error: e.message, error_class: e.class.name)
+        display_message("❌ aidp-auto failed on PR ##{pr[:number]}: #{e.message}", type: :error)
+      end
+
+      attr_reader :auto_label
+
+      private
+
+      def finalize_if_ready(pr_number:)
+        pr_data = @repository_client.fetch_pull_request(pr_number)
+        ci_status = @repository_client.fetch_ci_status(pr_number)
+
+        review_done = @state_extractor.review_completed?(pr_data) || @state_store.review_processed?(pr_number)
+        ci_passing = ci_status[:state] == "success"
+
+        Aidp.log_debug("auto_pr_processor", "completion_check",
+          pr: pr_number,
+          review_done: review_done,
+          ci_state: ci_status[:state])
+
+        return unless review_done && ci_passing
+
+        post_completion_comment(pr_number)
+        remove_auto_label(pr_number)
+      end
+
+      def post_completion_comment(pr_number)
+        comment = <<~COMMENT
+          ## 🤖 aidp-auto
+
+          - Automated review completed
+          - CI is passing
+
+          Marking this PR ready for human review and removing the `#{@auto_label}` label.
+        COMMENT
+
+        @repository_client.post_comment(pr_number, comment)
+        display_message("💬 Posted aidp-auto completion comment on PR ##{pr_number}", type: :success)
+      rescue => e
+        Aidp.log_warn("auto_pr_processor", "comment_failed", pr: pr_number, error: e.message)
+      end
+
+      def remove_auto_label(pr_number)
+        @repository_client.remove_labels(pr_number, @auto_label)
+        display_message("🏷️  Removed '#{@auto_label}' from PR ##{pr_number}", type: :info)
+      rescue => e
+        Aidp.log_warn("auto_pr_processor", "remove_label_failed", pr: pr_number, error: e.message)
+      end
+    end
+  end
+end

data/lib/aidp/watch/auto_processor.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require_relative "../message_display"
+
+module Aidp
+  module Watch
+    # Handles the aidp-auto label on issues by delegating to the BuildProcessor
+    # and transferring the label to the created PR once work completes.
+    class AutoProcessor
+      include Aidp::MessageDisplay
+
+      DEFAULT_AUTO_LABEL = "aidp-auto"
+
+      attr_reader :auto_label
+
+      def initialize(repository_client:, state_store:, build_processor:, label_config: {}, verbose: false)
+        @repository_client = repository_client
+        @state_store = state_store
+        @build_processor = build_processor
+        @verbose = verbose
+
+        # Allow overrides from watch config
+        @auto_label = label_config[:auto_trigger] || label_config["auto_trigger"] || DEFAULT_AUTO_LABEL
+      end
+
+      def process(issue)
+        number = issue[:number]
+        Aidp.log_debug("auto_processor", "process_started", issue: number, title: issue[:title])
+        display_message("🤖 Starting autonomous build for issue ##{number}", type: :info)
+
+        @build_processor.process(issue)
+
+        status = @state_store.build_status(number)
+        pr_url = status["pr_url"]
+        pr_number = extract_pr_number(pr_url)
+
+        unless status["status"] == "completed" && pr_number
+          Aidp.log_debug("auto_processor", "no_pr_to_transfer", issue: number, status: status["status"], pr_url: pr_url)
+          return
+        end
+
+        transfer_label_to_pr(issue_number: number, pr_number: pr_number)
+      rescue => e
+        Aidp.log_error("auto_processor", "process_failed", issue: issue[:number], error: e.message, error_class: e.class.name)
+        display_message("❌ aidp-auto failed for issue ##{issue[:number]}: #{e.message}", type: :error)
+      end
+
+      private
+
+      def extract_pr_number(pr_url)
+        return nil unless pr_url
+
+        match = pr_url.match(%r{/pull/(\d+)}i)
+        match && match[1].to_i
+      end
+
+      def transfer_label_to_pr(issue_number:, pr_number:)
+        Aidp.log_debug("auto_processor", "transferring_label", issue: issue_number, pr: pr_number, label: @auto_label)
+
+        begin
+          @repository_client.add_labels(pr_number, @auto_label)
+          display_message("🏷️  Added '#{@auto_label}' to PR ##{pr_number}", type: :info)
+        rescue => e
+          Aidp.log_warn("auto_processor", "add_label_failed", pr: pr_number, label: @auto_label, error: e.message)
+          display_message("⚠️  Failed to add '#{@auto_label}' to PR ##{pr_number}: #{e.message}", type: :warn)
+        end
+
+        begin
+          @repository_client.remove_labels(issue_number, @auto_label)
+          display_message("🏷️  Removed '#{@auto_label}' from issue ##{issue_number}", type: :muted)
+        rescue => e
+          Aidp.log_warn("auto_processor", "remove_label_failed", issue: issue_number, label: @auto_label, error: e.message)
+          display_message("⚠️  Failed to remove '#{@auto_label}' from issue ##{issue_number}: #{e.message}", type: :warn)
+        end
+      end
+    end
+  end
+end

data/lib/aidp/watch/change_request_processor.rb

@@ -57,7 +57,8 @@ module Aidp
           run_tests_before_push: true,
           commit_message_prefix: "aidp: pr-change",
           require_comment_reference: true,
-          max_diff_size: 2000
+          max_diff_size: 2000,
+          allow_large_pr_worktree_bypass: true # Default to always using worktree for large PRs
         }.merge(symbolize_keys(change_request_config))
 
         # Load safety configuration
@@ -95,16 +96,23 @@ module Aidp
           return
         end
 
-        # Fetch diff to check size
+        # If max_diff_size is set, attempt to fetch and check diff
+        # But bypass restriction for worktree-based workflows
         diff = @repository_client.fetch_pull_request_diff(number)
         diff_size = diff.lines.count
 
-        if diff_size > @config[:max_diff_size]
+        # Check if we want to use the worktree bypass
+        use_worktree_bypass = @config[:allow_large_pr_worktree_bypass] || @config[:allow_large_pr_worktree_bypass].nil?
+
+        if diff_size > @config[:max_diff_size] && !use_worktree_bypass
           display_message("⚠️  PR ##{number} diff too large (#{diff_size} lines > #{@config[:max_diff_size]}). Skipping.", type: :warn)
           post_diff_too_large_comment(pr, diff_size)
           return
         end
 
+        # Log the diff size for observability
+        Aidp.log_debug("change_request_processor", "PR diff size", number: number, size: diff_size, max_allowed: @config[:max_diff_size], worktree_bypass: use_worktree_bypass)
+
         # Analyze change requests
         analysis_result = analyze_change_requests(pr_data: pr_data, comments: authorized_comments, diff: diff)
 
@@ -308,40 +316,105 @@ module Aidp
         head_ref = pr_data[:head_ref]
         pr_number = pr_data[:number]
 
-        # Check if a worktree already exists for this branch
+        worktree_path = resolve_worktree_for_pr(pr_data)
+
+        Dir.chdir(worktree_path) do
+          run_git(%w[fetch origin], allow_failure: true)
+          run_git(["checkout", head_ref])
+          run_git(%w[pull --ff-only], allow_failure: true)
+        end
+
+        @project_dir = worktree_path
+
+        Aidp.log_debug("change_request_processor", "Checked out PR branch", branch: head_ref, worktree: worktree_path)
+        display_message("🌿 Using worktree for PR ##{pr_number}: #{head_ref}", type: :info)
+      end
+
+      def resolve_worktree_for_pr(pr_data)
+        head_ref = pr_data[:head_ref]
+        pr_number = pr_data[:number]
+
         existing = Aidp::Worktree.find_by_branch(branch: head_ref, project_dir: @project_dir)
 
         if existing && existing[:active]
           display_message("🔄 Using existing worktree for branch: #{head_ref}", type: :info)
           Aidp.log_debug("change_request_processor", "worktree_reused", pr_number: pr_number, branch: head_ref, path: existing[:path])
+          return existing[:path]
+        end
+
+        issue_worktree = find_issue_worktree_for_pr(pr_data)
+        return issue_worktree if issue_worktree
+
+        create_worktree_for_pr(pr_data)
+      end
+
+      def find_issue_worktree_for_pr(pr_data)
+        pr_number = pr_data[:number]
+        linked_issue_numbers = extract_issue_numbers_from_pr(pr_data)
+
+        build_match = @state_store.find_build_by_pr(pr_number)
+        linked_issue_numbers << build_match[:issue_number] if build_match
+        linked_issue_numbers = linked_issue_numbers.compact.uniq
 
-          # Update @project_dir to point to the worktree
-          @project_dir = existing[:path]
+        linked_issue_numbers.each do |issue_number|
+          workstream = @state_store.workstream_for_issue(issue_number)
+          next unless workstream
 
-          # Pull latest changes in the worktree
-          Dir.chdir(@project_dir) do
-            run_git(%w[fetch origin], allow_failure: true)
-            run_git(["checkout", head_ref])
-            run_git(%w[pull --ff-only], allow_failure: true)
+          slug = workstream[:workstream]
+          branch = workstream[:branch]
+
+          if slug
+            info = Aidp::Worktree.info(slug: slug, project_dir: @project_dir)
+            if info && info[:active]
+              Aidp.log_debug("change_request_processor", "issue_worktree_reused", pr_number: pr_number, issue_number: issue_number, branch: branch, path: info[:path])
+              display_message("🔄 Reusing worktree #{slug} for issue ##{issue_number} (PR ##{pr_number})", type: :info)
+              return info[:path]
+            end
           end
 
-          return
+          if branch
+            existing = Aidp::Worktree.find_by_branch(branch: branch, project_dir: @project_dir)
+            if existing && existing[:active]
+              Aidp.log_debug("change_request_processor", "issue_branch_worktree_reused", pr_number: pr_number, issue_number: issue_number, branch: branch, path: existing[:path])
+              display_message("🔄 Reusing branch worktree for issue ##{issue_number}: #{branch}", type: :info)
+              return existing[:path]
+            end
+          end
         end
 
-        # Otherwise, use the main worktree
-        Dir.chdir(@project_dir) do
-          # Fetch latest
-          run_git(%w[fetch origin])
+        nil
+      end
 
-          # Checkout the PR branch
-          run_git(["checkout", head_ref])
+      def extract_issue_numbers_from_pr(pr_data)
+        body = pr_data[:body].to_s
+        issue_matches = body.scan(/(?:Fixes|Resolves|Closes)\s+#(\d+)/i).flatten
 
-          # Pull latest changes
-          run_git(%w[pull --ff-only], allow_failure: true)
+        issue_matches.map { |num| num.to_i }.uniq
+      end
+
+      def create_worktree_for_pr(pr_data)
+        head_ref = pr_data[:head_ref]
+        pr_number = pr_data[:number]
+        slug = "pr-#{pr_number}-change-requests"
+
+        display_message("🌿 Creating worktree for PR ##{pr_number}: #{head_ref}", type: :info)
+
+        Dir.chdir(@project_dir) do
+          run_git(%w[fetch origin], allow_failure: true)
         end
 
-        Aidp.log_debug("change_request_processor", "Checked out PR branch", branch: head_ref)
-        display_message("🌿 Checked out branch: #{head_ref}", type: :info)
+        result = Aidp::Worktree.create(
+          slug: slug,
+          project_dir: @project_dir,
+          branch: head_ref,
+          base_branch: pr_data[:base_ref]
+        )
+
+        worktree_path = result[:path]
+        Aidp.log_debug("change_request_processor", "worktree_created", pr_number: pr_number, branch: head_ref, path: worktree_path)
+        display_message("✅ Worktree created at #{worktree_path}", type: :success)
+
+        worktree_path
       end
 
       def apply_changes(changes)
@@ -704,15 +777,20 @@ module Aidp
         comment = <<~COMMENT
           #{COMMENT_HEADER}
 
-          ⚠️  PR diff is too large for automated change requests.
+          ⚠️  PR diff is too large for default change requests.
 
           **Current size:** #{diff_size} lines
           **Maximum allowed:** #{@config[:max_diff_size]} lines
 
-          For large PRs, please consider:
-          1. Breaking the PR into smaller chunks
-          2. Implementing changes manually
-          3. Increasing `max_diff_size` in your `aidp.yml` configuration if appropriate
+          For large PRs, you have several options:
+          1. Enable worktree-based large PR handling:
+             Set `allow_large_pr_worktree_bypass: true` in your `aidp.yml`
+          2. Break the PR into smaller chunks
+          3. Implement changes manually
+          4. Increase `max_diff_size` in your configuration
+
+          The worktree bypass allows processing large PRs by working directly in the branch
+          instead of using diff-based changes.
         COMMENT
 
         begin

data/lib/aidp/watch/runner.rb

@@ -14,6 +14,8 @@ require_relative "../auto_update"
 require_relative "review_processor"
 require_relative "ci_fix_processor"
 require_relative "change_request_processor"
+require_relative "auto_processor"
+require_relative "auto_pr_processor"
 
 module Aidp
   module Watch
@@ -70,6 +72,13 @@ module Aidp
           verbose: verbose,
           label_config: label_config
         )
+        @auto_processor = AutoProcessor.new(
+          repository_client: @repository_client,
+          state_store: @state_store,
+          build_processor: @build_processor,
+          label_config: label_config,
+          verbose: verbose
+        )
 
         # Initialize auto-update coordinator
         @auto_update_coordinator = Aidp::AutoUpdate.coordinator(project_dir: project_dir)
@@ -90,6 +99,14 @@ module Aidp
           label_config: label_config,
           verbose: verbose
         )
+        @auto_pr_processor = AutoPrProcessor.new(
+          repository_client: @repository_client,
+          state_store: @state_store,
+          review_processor: @review_processor,
+          ci_fix_processor: @ci_fix_processor,
+          label_config: label_config,
+          verbose: verbose
+        )
         @change_request_processor = ChangeRequestProcessor.new(
           repository_client: @repository_client,
           state_store: @state_store,
@@ -142,9 +159,11 @@ module Aidp
       def process_cycle
         process_plan_triggers
         process_build_triggers
+        process_auto_issue_triggers
         check_for_updates_if_due
         process_review_triggers
         process_ci_fix_triggers
+        process_auto_pr_triggers
         process_change_request_triggers
       end
 
@@ -264,6 +283,54 @@ module Aidp
         end
       end
 
+      def process_auto_issue_triggers
+        auto_label = @auto_processor.auto_label
+        begin
+          issues = @repository_client.list_issues(labels: [auto_label], state: "open")
+        rescue => e
+          Aidp.log_error("watch_runner", "auto_issue_poll_failed", label: auto_label, error: e.message)
+          return
+        end
+
+        Aidp.log_debug("watch_runner", "auto_issue_poll", label: auto_label, total: issues.size)
+
+        issues.each do |issue|
+          unless issue_has_label?(issue, auto_label)
+            Aidp.log_debug("watch_runner", "auto_issue_skip_label_mismatch", issue: issue[:number], labels: issue[:labels])
+            next
+          end
+
+          begin
+            detailed = @repository_client.fetch_issue(issue[:number])
+          rescue => e
+            Aidp.log_error("watch_runner", "auto_issue_fetch_failed", issue: issue[:number], error: e.message)
+            next
+          end
+
+          # Check if already in progress by another instance
+          if @state_extractor.in_progress?(detailed)
+            Aidp.log_debug("watch_runner", "auto_issue_skip_in_progress", issue: detailed[:number])
+            next
+          end
+
+          # Check author authorization before processing
+          unless @safety_checker.should_process_issue?(detailed, enforce: false)
+            Aidp.log_debug("watch_runner", "auto_issue_skip_unauthorized_author", issue: detailed[:number], author: detailed[:author])
+            next
+          end
+
+          # Check if detection comment already posted (deduplication)
+          unless @state_extractor.detection_comment_posted?(detailed, auto_label)
+            post_detection_comment(item_type: :issue, number: detailed[:number], label: auto_label)
+          end
+
+          Aidp.log_debug("watch_runner", "auto_issue_process", issue: detailed[:number])
+          @auto_processor.process(detailed)
+        rescue RepositorySafetyChecker::UnauthorizedAuthorError => e
+          Aidp.log_warn("watch_runner", "unauthorized_issue_author_auto", issue: issue[:number], error: e.message)
+        end
+      end
+
       def process_review_triggers
         review_label = @review_processor.review_label
         begin
@@ -310,6 +377,43 @@ module Aidp
         end
       end
 
+      def process_auto_pr_triggers
+        auto_label = @auto_pr_processor.auto_label
+        prs = @repository_client.list_pull_requests(labels: [auto_label], state: "open")
+        Aidp.log_debug("watch_runner", "auto_pr_poll", label: auto_label, total: prs.size)
+
+        prs.each do |pr|
+          unless pr_has_label?(pr, auto_label)
+            Aidp.log_debug("watch_runner", "auto_pr_skip_label_mismatch", pr: pr[:number], labels: pr[:labels])
+            next
+          end
+
+          detailed = @repository_client.fetch_pull_request(pr[:number])
+
+          # Check if already in progress by another instance
+          if @state_extractor.in_progress?(detailed)
+            Aidp.log_debug("watch_runner", "auto_pr_skip_in_progress", pr: detailed[:number])
+            next
+          end
+
+          # Check author authorization before processing
+          unless @safety_checker.should_process_issue?(detailed, enforce: false)
+            Aidp.log_debug("watch_runner", "auto_pr_skip_unauthorized_author", pr: detailed[:number], author: detailed[:author])
+            next
+          end
+
+          # Check if detection comment already posted (deduplication)
+          unless @state_extractor.detection_comment_posted?(detailed, auto_label)
+            post_detection_comment(item_type: :pr, number: detailed[:number], label: auto_label)
+          end
+
+          Aidp.log_debug("watch_runner", "auto_pr_process", pr: detailed[:number])
+          @auto_pr_processor.process(detailed)
+        rescue RepositorySafetyChecker::UnauthorizedAuthorError => e
+          Aidp.log_warn("watch_runner", "unauthorized_pr_author_auto", pr: pr[:number], error: e.message)
+        end
+      end
+
       def process_ci_fix_triggers
         ci_fix_label = @ci_fix_processor.ci_fix_label
         prs = @repository_client.list_pull_requests(labels: [ci_fix_label], state: "open")

data/lib/aidp/watch/state_store.rb

@@ -65,6 +65,43 @@ module Aidp
         save!
       end
 
+      # Retrieve workstream metadata for a given issue
+      # @return [Hash, nil] {issue_number:, branch:, workstream:, pr_url:, status:}
+      def workstream_for_issue(issue_number)
+        data = build_status(issue_number)
+        return nil if data.nil? || data.empty?
+
+        {
+          issue_number: issue_number.to_i,
+          branch: data["branch"],
+          workstream: data["workstream"],
+          pr_url: data["pr_url"],
+          status: data["status"]
+        }
+      end
+
+      # Find the build/workstream metadata associated with a PR URL
+      # This is used to map change-request PRs back to their originating issues/worktrees.
+      # @return [Hash, nil] {issue_number:, branch:, workstream:, pr_url:, status:}
+      def find_build_by_pr(pr_number)
+        builds.each do |issue_number, data|
+          pr_url = data["pr_url"]
+          next unless pr_url
+
+          if pr_url.match?(%r{/pull/#{pr_number}\b})
+            return {
+              issue_number: issue_number.to_i,
+              branch: data["branch"],
+              workstream: data["workstream"],
+              pr_url: pr_url,
+              status: data["status"]
+            }
+          end
+        end
+
+        nil
+      end
+
       # Review tracking methods
       def review_processed?(pr_number)
         reviews.key?(pr_number.to_s)

data/lib/aidp/worktree_branch_manager.rb

@@ -0,0 +1,147 @@
+require "json"
+require "fileutils"
+
+module Aidp
+  # Manages git worktrees for pull request branches
+  class WorktreeBranchManager
+    class WorktreeCreationError < StandardError; end
+    class WorktreeLookupError < StandardError; end
+
+    # Initialize with a project directory and optional logger
+    def initialize(project_dir:, logger: Aidp.logger)
+      @project_dir = project_dir
+      @logger = logger
+      @worktree_registry_path = File.join(project_dir, ".aidp", "worktrees.json")
+    end
+
+    # Find an existing worktree for a given branch or PR
+    def find_worktree(branch:)
+      Aidp.log_debug("worktree_branch_manager", "finding_worktree", branch: branch)
+
+      raise WorktreeLookupError, "Invalid git repository: #{@project_dir}" unless git_repository?
+
+      # Check registry first
+      worktree_info = read_registry.find { |w| w["branch"] == branch }
+
+      if worktree_info
+        worktree_path = worktree_info["path"]
+        return worktree_path if File.directory?(worktree_path)
+      end
+
+      # Fallback: Use git worktree list to find the worktree
+      worktree_list_output = run_git_command("git worktree list")
+      worktree_list_output.split("\n").each do |line|
+        path, branch_info = line.split(" ", 2)
+        return path if branch_info&.include?(branch)
+      end
+
+      nil
+    rescue => e
+      Aidp.log_error("worktree_branch_manager", "worktree_lookup_failed",
+        error: e.message, branch: branch)
+      raise
+    end
+
+    # Create a new worktree for a branch
+    def create_worktree(branch:, base_branch: "main")
+      Aidp.log_debug("worktree_branch_manager", "creating_worktree",
+        branch: branch, base_branch: base_branch)
+
+      # Validate branch name to prevent path traversal
+      validate_branch_name!(branch)
+
+      # Check if worktree already exists
+      existing_worktree = find_worktree(branch: branch)
+      return existing_worktree if existing_worktree
+
+      # Ensure base branch exists
+      base_ref = (branch == "main") ? "main" : "refs/heads/#{base_branch}"
+      base_exists_cmd = "git show-ref --verify --quiet #{base_ref}"
+
+      system({"GIT_DIR" => File.join(@project_dir, ".git")}, "cd #{@project_dir} && #{base_exists_cmd}")
+
+      # If base branch doesn't exist locally, create it
+      unless $?.success?
+        system({"GIT_DIR" => File.join(@project_dir, ".git")}, "cd #{@project_dir} && git checkout -b #{base_branch}")
+      end
+
+      # Create worktree directory
+      worktree_name = branch.tr("/", "_")
+      worktree_path = File.join(@project_dir, ".worktrees", worktree_name)
+
+      # Ensure .worktrees directory exists
+      FileUtils.mkdir_p(File.join(@project_dir, ".worktrees"))
+
+      # Create the worktree
+      cmd = "git worktree add -b #{branch} #{worktree_path} #{base_branch}"
+      result = system({"GIT_DIR" => File.join(@project_dir, ".git")}, "cd #{@project_dir} && #{cmd}")
+
+      unless result
+        Aidp.log_error("worktree_branch_manager", "worktree_creation_failed",
+          branch: branch, base_branch: base_branch)
+        raise WorktreeCreationError, "Failed to create worktree for branch #{branch}"
+      end
+
+      # Update registry
+      update_registry(branch, worktree_path)
+
+      worktree_path
+    end
+
+    private
+
+    def git_repository?
+      File.directory?(File.join(@project_dir, ".git"))
+    rescue
+      false
+    end
+
+    def validate_branch_name!(branch)
+      if branch.include?("..") || branch.start_with?("/")
+        raise WorktreeCreationError, "Invalid branch name: #{branch}"
+      end
+    end
+
+    def run_git_command(cmd)
+      Dir.chdir(@project_dir) do
+        output = `#{cmd} 2>&1`
+        raise StandardError, output unless $?.success?
+        output
+      end
+    end
+
+    # Read the worktree registry
+    def read_registry
+      return [] unless File.exist?(@worktree_registry_path)
+
+      begin
+        JSON.parse(File.read(@worktree_registry_path))
+      rescue JSON::ParserError
+        Aidp.log_warn("worktree_branch_manager", "invalid_registry",
+          path: @worktree_registry_path)
+        []
+      end
+    end
+
+    # Update the worktree registry
+    def update_registry(branch, path)
+      # Ensure .aidp directory exists
+      FileUtils.mkdir_p(File.dirname(@worktree_registry_path))
+
+      registry = read_registry
+
+      # Remove existing entries for the same branch
+      registry.reject! { |w| w["branch"] == branch }
+
+      # Add new entry
+      registry << {
+        "branch" => branch,
+        "path" => path,
+        "created_at" => Time.now.to_i
+      }
+
+      # Write updated registry
+      File.write(@worktree_registry_path, JSON.pretty_generate(registry))
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: aidp
 version: !ruby/object:Gem::Version
-  version: 0.30.0
+  version: 0.31.0
 platform: ruby
 authors:
 - Bart Agapinan
@@ -449,6 +449,8 @@ files:
 - lib/aidp/utils/devcontainer_detector.rb
 - lib/aidp/version.rb
 - lib/aidp/watch.rb
+- lib/aidp/watch/auto_pr_processor.rb
+- lib/aidp/watch/auto_processor.rb
 - lib/aidp/watch/build_processor.rb
 - lib/aidp/watch/change_request_processor.rb
 - lib/aidp/watch/ci_fix_processor.rb
@@ -473,6 +475,7 @@ files:
 - lib/aidp/workstream_executor.rb
 - lib/aidp/workstream_state.rb
 - lib/aidp/worktree.rb
+- lib/aidp/worktree_branch_manager.rb
 - templates/COMMON/AGENT_BASE.md
 - templates/COMMON/CONVENTIONS.md
 - templates/COMMON/TEMPLATES/ADR_TEMPLATE.md