aidp 0.25.0 → 0.27.0

data/lib/aidp/watch/plan_generator.rb

@@ -29,32 +29,103 @@ module Aidp
       def initialize(provider_name: nil, verbose: false)
         @provider_name = provider_name
         @verbose = verbose
+        @providers_attempted = []
       end
 
       def generate(issue)
-        provider = resolve_provider
-        if provider
-          generate_with_provider(provider, issue)
-        else
-          display_message("⚠️  No active provider available. Falling back to heuristic plan.", type: :warn)
-          heuristic_plan(issue)
+        Aidp.log_debug("plan_generator", "generate.start", provider: @provider_name, issue: issue[:number])
+
+        # Try providers in fallback chain order
+        providers_to_try = build_provider_fallback_chain
+        Aidp.log_debug("plan_generator", "fallback_chain", providers: providers_to_try, count: providers_to_try.size)
+
+        providers_to_try.each do |provider_name|
+          next if @providers_attempted.include?(provider_name)
+
+          Aidp.log_debug("plan_generator", "trying_provider", provider: provider_name, attempted: @providers_attempted)
+
+          provider = resolve_provider(provider_name)
+          unless provider
+            Aidp.log_debug("plan_generator", "provider_unavailable", provider: provider_name, reason: "not resolved")
+            @providers_attempted << provider_name
+            next
+          end
+
+          begin
+            Aidp.log_info("plan_generator", "generate_with_provider", provider: provider_name, issue: issue[:number])
+            result = generate_with_provider(provider, issue, provider_name)
+            if result
+              Aidp.log_info("plan_generator", "generation_success", provider: provider_name, issue: issue[:number])
+              return result
+            end
+
+            # Provider returned nil - try next provider
+            Aidp.log_warn("plan_generator", "provider_returned_nil", provider: provider_name)
+            @providers_attempted << provider_name
+          rescue => e
+            # Log error and try next provider in chain
+            Aidp.log_warn("plan_generator", "provider_failed", provider: provider_name, error: e.message, error_class: e.class.name)
+            @providers_attempted << provider_name
+          end
         end
+
+        # All providers exhausted, fall back to heuristic
+        Aidp.log_warn("plan_generator", "all_providers_exhausted", attempted: @providers_attempted, falling_back: "heuristic")
+        display_message("⚠️  All providers unavailable or failed. Falling back to heuristic plan.", type: :warn)
+        heuristic_plan(issue)
       rescue => e
-        display_message("⚠️  Plan generation failed (#{e.message}). Using heuristic.", type: :warn)
+        Aidp.log_error("plan_generator", "generation_failed_unexpectedly", error: e.message, backtrace: e.backtrace&.first(3))
+        display_message("⚠️  Plan generation failed unexpectedly (#{e.message}). Using heuristic.", type: :warn)
         heuristic_plan(issue)
       end
 
       private
 
-      def resolve_provider
-        provider_name = @provider_name || detect_default_provider
+      def build_provider_fallback_chain
+        # Start with specified provider or default
+        primary_provider = @provider_name || detect_default_provider
+        providers = []
+
+        # Add primary provider first
+        providers << primary_provider if primary_provider
+
+        # Try to get fallback chain from config
+        begin
+          config_manager = Aidp::Harness::ConfigManager.new(Dir.pwd)
+          fallback_providers = config_manager.fallback_providers || []
+
+          # Add fallback providers that aren't already in the list
+          fallback_providers.each do |fallback|
+            providers << fallback unless providers.include?(fallback)
+          end
+        rescue => e
+          Aidp.log_debug("plan_generator", "config_fallback_unavailable", error: e.message)
+        end
+
+        # If we still have no providers, add cursor as last resort
+        providers << "cursor" if providers.empty?
+
+        # Remove duplicates while preserving order
+        providers.uniq
+      end
+
+      def resolve_provider(provider_name = nil)
+        provider_name ||= @provider_name || detect_default_provider
         return nil unless provider_name
 
+        Aidp.log_debug("plan_generator", "resolve_provider", provider: provider_name)
+
         provider = Aidp::ProviderManager.get_provider(provider_name, use_harness: false)
-        return provider if provider&.available?
 
+        if provider&.available?
+          Aidp.log_debug("plan_generator", "provider_resolved", provider: provider_name, available: true)
+          return provider
+        end
+
+        Aidp.log_debug("plan_generator", "provider_not_available", provider: provider_name, available: provider&.available?)
         nil
       rescue => e
+        Aidp.log_warn("plan_generator", "resolve_provider_failed", provider: provider_name, error: e.message)
         display_message("⚠️  Failed to resolve provider #{provider_name}: #{e.message}", type: :warn)
         nil
       end
@@ -66,9 +137,11 @@ module Aidp
         "cursor"
       end
 
-      def generate_with_provider(provider, issue)
+      def generate_with_provider(provider, issue, provider_name = "unknown")
         payload = build_prompt(issue)
 
+        Aidp.log_debug("plan_generator", "sending_to_provider", provider: provider_name, prompt_length: payload.length)
+
         if @verbose
           display_message("\n--- Plan Generation Prompt ---", type: :muted)
           display_message(payload.strip, type: :muted)
@@ -77,6 +150,8 @@ module Aidp
 
         response = provider.send_message(prompt: payload)
 
+        Aidp.log_debug("plan_generator", "provider_response_received", provider: provider_name, response_length: response&.length || 0)
+
         if @verbose
           display_message("\n--- Provider Response ---", type: :muted)
           display_message(response.strip, type: :muted)
@@ -85,10 +160,14 @@ module Aidp
 
         parsed = parse_structured_response(response)
 
-        return parsed if parsed
+        if parsed
+          Aidp.log_debug("plan_generator", "response_parsed", provider: provider_name, has_summary: !parsed[:summary].to_s.empty?, tasks_count: parsed[:tasks]&.size || 0)
+          return parsed
+        end
 
-        display_message("⚠️  Unable to parse provider response. Using heuristic plan.", type: :warn)
-        heuristic_plan(issue)
+        Aidp.log_warn("plan_generator", "parse_failed", provider: provider_name)
+        display_message("⚠️  Unable to parse #{provider_name} response. Trying next provider.", type: :warn)
+        nil
       end
 
       def build_prompt(issue)

data/lib/aidp/watch/plan_processor.rb

@@ -41,21 +41,46 @@ module Aidp
 
       def process(issue)
         number = issue[:number]
-        if @state_store.plan_processed?(number)
-          display_message("ℹ️  Plan for issue ##{number} already posted. Skipping.", type: :muted)
-          return
+        existing_plan = @state_store.plan_data(number)
+
+        if existing_plan
+          display_message("🔄 Re-planning for issue ##{number} (iteration #{@state_store.plan_iteration_count(number) + 1})", type: :info)
+        else
+          display_message("🧠 Generating plan for issue ##{number} (#{issue[:title]})", type: :info)
         end
 
-        display_message("🧠 Generating plan for issue ##{number} (#{issue[:title]})", type: :info)
         plan_data = @plan_generator.generate(issue)
 
         # Fetch the user who added the most recent label
         label_actor = @repository_client.most_recent_label_actor(number)
 
-        comment_body = build_comment(issue: issue, plan: plan_data, label_actor: label_actor)
-        @repository_client.post_comment(number, comment_body)
+        # If updating existing plan, archive the previous content
+        archived_content = existing_plan ? archive_previous_plan(number, existing_plan) : nil
+
+        comment_body = build_comment(issue: issue, plan: plan_data, label_actor: label_actor, archived_content: archived_content)
+
+        if existing_plan && existing_plan["comment_id"]
+          # Update existing comment
+          @repository_client.update_comment(existing_plan["comment_id"], comment_body)
+          display_message("📝 Updated plan comment for issue ##{number}", type: :success)
+        elsif existing_plan
+          # Try to find existing comment by header
+          existing_comment = @repository_client.find_comment(number, COMMENT_HEADER)
+          if existing_comment
+            @repository_client.update_comment(existing_comment[:id], comment_body)
+            display_message("📝 Updated plan comment for issue ##{number}", type: :success)
+            plan_data = plan_data.merge(comment_id: existing_comment[:id])
+          else
+            # Fallback to posting new comment if we can't find the old one
+            @repository_client.post_comment(number, comment_body)
+            display_message("💬 Posted new plan comment for issue ##{number}", type: :success)
+          end
+        else
+          # First time planning - post new comment
+          @repository_client.post_comment(number, comment_body)
+          display_message("💬 Posted plan comment for issue ##{number}", type: :success)
+        end
 
-        display_message("💬 Posted plan comment for issue ##{number}", type: :success)
         @state_store.record_plan(number, plan_data.merge(comment_body: comment_body, comment_hint: COMMENT_HEADER))
 
         # Update labels: remove plan trigger, add appropriate status label
@@ -64,6 +89,31 @@ module Aidp
 
       private
 
+      def archive_previous_plan(number, existing_plan)
+        iteration = @state_store.plan_iteration_count(number)
+        timestamp = existing_plan["posted_at"] || "unknown"
+
+        archived_parts = []
+        archived_parts << "<!-- ARCHIVED_PLAN_START iteration=#{iteration} timestamp=#{timestamp} -->"
+        archived_parts << "<details>"
+        archived_parts << "<summary>📋 Previous Plan (Iteration #{iteration}) - #{timestamp}</summary>"
+        archived_parts << ""
+        archived_parts << "<!-- ARCHIVED_PLAN_SUMMARY_START -->"
+        archived_parts << "### Plan Summary"
+        archived_parts << existing_plan["summary"].to_s
+        archived_parts << "<!-- ARCHIVED_PLAN_SUMMARY_END -->"
+        archived_parts << ""
+        archived_parts << "<!-- ARCHIVED_PLAN_TASKS_START -->"
+        archived_parts << "### Proposed Tasks"
+        archived_parts << format_bullets(Array(existing_plan["tasks"]), placeholder: "_No tasks_")
+        archived_parts << "<!-- ARCHIVED_PLAN_TASKS_END -->"
+        archived_parts << ""
+        archived_parts << "</details>"
+        archived_parts << "<!-- ARCHIVED_PLAN_END -->"
+
+        archived_parts.join("\n")
+      end
+
       def update_labels_after_plan(number, plan_data)
         questions = Array(plan_data[:questions])
         has_questions = questions.any? && !questions.all? { |q| q.to_s.strip.empty? }
@@ -85,7 +135,7 @@ module Aidp
         end
       end
 
-      def build_comment(issue:, plan:, label_actor: nil)
+      def build_comment(issue:, plan:, label_actor: nil, archived_content: nil)
         summary = plan[:summary].to_s.strip
         tasks = Array(plan[:tasks])
         questions = Array(plan[:questions])
@@ -104,14 +154,27 @@ module Aidp
         parts << "**Issue**: [##{issue[:number]}](#{issue[:url]})"
         parts << "**Title**: #{issue[:title]}"
         parts << ""
+
+        # Add archived content if this is a plan update
+        if archived_content
+          parts << archived_content
+          parts << ""
+        end
+
+        parts << "<!-- PLAN_SUMMARY_START -->"
         parts << "### Plan Summary"
         parts << (summary.empty? ? "_No summary generated_" : summary)
+        parts << "<!-- PLAN_SUMMARY_END -->"
         parts << ""
+        parts << "<!-- PLAN_TASKS_START -->"
         parts << "### Proposed Tasks"
         parts << format_bullets(tasks, placeholder: "_Pending task breakdown_")
+        parts << "<!-- PLAN_TASKS_END -->"
         parts << ""
+        parts << "<!-- CLARIFYING_QUESTIONS_START -->"
         parts << "### Clarifying Questions"
         parts << format_numbered(questions, placeholder: "_No questions identified_")
+        parts << "<!-- CLARIFYING_QUESTIONS_END -->"
         parts << ""
 
         # Add instructions based on whether there are questions

data/lib/aidp/watch/repository_client.rb

@@ -61,6 +61,14 @@ module Aidp
         gh_available? ? post_comment_via_gh(number, body) : post_comment_via_api(number, body)
       end
 
+      def find_comment(number, header_text)
+        gh_available? ? find_comment_via_gh(number, header_text) : find_comment_via_api(number, header_text)
+      end
+
+      def update_comment(comment_id, body)
+        gh_available? ? update_comment_via_gh(comment_id, body) : update_comment_via_api(comment_id, body)
+      end
+
       def create_pull_request(title:, body:, head:, base:, issue_number:, draft: false, assignee: nil)
         gh_available? ? create_pull_request_via_gh(title: title, body: body, head: head, base: base, issue_number: issue_number, draft: draft, assignee: assignee) : raise("GitHub CLI not available - cannot create PR")
       end
@@ -108,6 +116,10 @@ module Aidp
         gh_available? ? list_pull_requests_via_gh(labels: labels, state: state) : list_pull_requests_via_api(labels: labels, state: state)
       end
 
+      def fetch_pr_comments(number)
+        gh_available? ? fetch_pr_comments_via_gh(number) : fetch_pr_comments_via_api(number)
+      end
+
       private
 
       def list_issues_via_gh(labels:, state:)
@@ -162,27 +174,11 @@ module Aidp
         raise "GitHub API error (#{response.code})" unless response.code == "200"
 
         data = JSON.parse(response.body)
-        comments = fetch_comments_via_api(number)
+        comments = fetch_pr_comments_via_api(number)
         data["comments"] = comments
         normalize_issue_detail_api(data)
       end
 
-      def fetch_comments_via_api(number)
-        uri = URI("https://api.github.com/repos/#{full_repo}/issues/#{number}/comments")
-        response = Net::HTTP.get_response(uri)
-        return [] unless response.code == "200"
-
-        JSON.parse(response.body).map do |raw|
-          {
-            "body" => raw["body"],
-            "author" => raw.dig("user", "login"),
-            "createdAt" => raw["created_at"]
-          }
-        end
-      rescue
-        []
-      end
-
       def post_comment_via_gh(number, body)
         cmd = ["gh", "issue", "comment", number.to_s, "--repo", full_repo, "--body", body]
         stdout, stderr, status = Open3.capture3(*cmd)
@@ -205,6 +201,44 @@ module Aidp
         response.body
       end
 
+      def find_comment_via_gh(number, header_text)
+        comments = fetch_pr_comments_via_gh(number)
+        comments.find { |comment| comment[:body]&.include?(header_text) }
+      rescue => e
+        Aidp.log_warn("repository_client", "Failed to find comment", error: e.message)
+        nil
+      end
+
+      def find_comment_via_api(number, header_text)
+        comments = fetch_pr_comments_via_api(number)
+        comments.find { |comment| comment[:body]&.include?(header_text) }
+      rescue => e
+        Aidp.log_warn("repository_client", "Failed to find comment", error: e.message)
+        nil
+      end
+
+      def update_comment_via_gh(comment_id, body)
+        cmd = ["gh", "api", "repos/#{full_repo}/issues/comments/#{comment_id}", "-X", "PATCH", "-f", "body=#{body}"]
+        stdout, stderr, status = Open3.capture3(*cmd)
+        raise "Failed to update comment via gh: #{stderr.strip}" unless status.success?
+
+        stdout.strip
+      end
+
+      def update_comment_via_api(comment_id, body)
+        uri = URI("https://api.github.com/repos/#{full_repo}/issues/comments/#{comment_id}")
+        request = Net::HTTP::Patch.new(uri)
+        request["Content-Type"] = "application/json"
+        request.body = JSON.dump({body: body})
+
+        response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
+          http.request(request)
+        end
+
+        raise "GitHub API update comment failed (#{response.code})" unless response.code.start_with?("2")
+        response.body
+      end
+
       def create_pull_request_via_gh(title:, body:, head:, base:, issue_number:, draft: false, assignee: nil)
         cmd = [
           "gh", "pr", "create",
@@ -535,6 +569,27 @@ module Aidp
         response.body
       end
 
+      def fetch_pr_comments_via_gh(number)
+        cmd = ["gh", "api", "repos/#{full_repo}/issues/#{number}/comments", "--jq", "."]
+        stdout, stderr, status = Open3.capture3(*cmd)
+        raise "Failed to fetch PR comments via gh: #{stderr.strip}" unless status.success?
+
+        JSON.parse(stdout).map { |raw| normalize_pr_comment(raw) }
+      rescue JSON::ParserError => e
+        raise "Failed to parse PR comments response: #{e.message}"
+      end
+
+      def fetch_pr_comments_via_api(number)
+        uri = URI("https://api.github.com/repos/#{full_repo}/issues/#{number}/comments")
+        response = Net::HTTP.get_response(uri)
+        return [] unless response.code == "200"
+
+        JSON.parse(response.body).map { |raw| normalize_pr_comment(raw) }
+      rescue => e
+        Aidp.log_warn("repository_client", "Failed to fetch PR comments", error: e.message)
+        []
+      end
+
       # Normalization methods for PRs
       def normalize_pull_request(raw)
         {
@@ -691,14 +746,24 @@ module Aidp
       def normalize_comment(comment)
         if comment.is_a?(Hash)
           {
-            "body" => comment["body"],
-            "author" => comment["author"] || comment.dig("user", "login"),
-            "createdAt" => comment["createdAt"] || comment["created_at"]
+            "body" => comment["body"] || comment[:body],
+            "author" => comment["author"] || comment[:author] || comment.dig("user", "login"),
+            "createdAt" => comment["createdAt"] || comment[:created_at] || comment["created_at"]
           }
         else
           {"body" => comment.to_s}
         end
       end
+
+      def normalize_pr_comment(raw)
+        {
+          id: raw["id"],
+          body: raw["body"],
+          author: raw.dig("user", "login"),
+          created_at: raw["created_at"],
+          updated_at: raw["updated_at"]
+        }
+      end
     end
   end
 end

data/lib/aidp/watch/review_processor.rb

@@ -23,7 +23,7 @@ module Aidp
 
       attr_reader :review_label
 
-      def initialize(repository_client:, state_store:, provider_name: nil, project_dir: Dir.pwd, label_config: {}, verbose: false)
+      def initialize(repository_client:, state_store:, provider_name: nil, project_dir: Dir.pwd, label_config: {}, verbose: false, reviewers: nil)
         @repository_client = repository_client
         @state_store = state_store
         @provider_name = provider_name
@@ -33,8 +33,8 @@ module Aidp
         # Load label configuration
         @review_label = label_config[:review_trigger] || label_config["review_trigger"] || DEFAULT_REVIEW_LABEL
 
-        # Initialize reviewers
-        @reviewers = [
+        # Initialize reviewers (allow dependency injection for testing)
+        @reviewers = reviewers || [
           Reviewers::SeniorDevReviewer.new(provider_name: provider_name),
           Reviewers::SecurityReviewer.new(provider_name: provider_name),
           Reviewers::PerformanceReviewer.new(provider_name: provider_name)

data/lib/aidp/watch/runner.rb

@@ -12,6 +12,7 @@ require_relative "build_processor"
 require_relative "../auto_update"
 require_relative "review_processor"
 require_relative "ci_fix_processor"
+require_relative "change_request_processor"
 
 module Aidp
   module Watch
@@ -77,6 +78,16 @@ module Aidp
           label_config: label_config,
           verbose: verbose
         )
+        @change_request_processor = ChangeRequestProcessor.new(
+          repository_client: @repository_client,
+          state_store: @state_store,
+          provider_name: provider_name,
+          project_dir: project_dir,
+          label_config: label_config,
+          change_request_config: safety_config[:pr_change_requests] || safety_config["pr_change_requests"] || {},
+          safety_config: safety_config[:safety] || safety_config["safety"] || {},
+          verbose: verbose
+        )
       end
 
       def start
@@ -122,6 +133,7 @@ module Aidp
         check_for_updates_if_due
         process_review_triggers
         process_ci_fix_triggers
+        process_change_request_triggers
       end
 
       def process_plan_triggers
@@ -230,6 +242,31 @@ module Aidp
         end
       end
 
+      def process_change_request_triggers
+        change_request_label = @change_request_processor.change_request_label
+        prs = @repository_client.list_pull_requests(labels: [change_request_label], state: "open")
+        Aidp.log_debug("watch_runner", "change_request_poll", label: change_request_label, total: prs.size)
+        prs.each do |pr|
+          unless pr_has_label?(pr, change_request_label)
+            Aidp.log_debug("watch_runner", "change_request_skip_label_mismatch", pr: pr[:number], labels: pr[:labels])
+            next
+          end
+
+          detailed = @repository_client.fetch_pull_request(pr[:number])
+
+          # Check author authorization before processing
+          unless @safety_checker.should_process_issue?(detailed, enforce: false)
+            Aidp.log_debug("watch_runner", "change_request_skip_unauthorized_author", pr: detailed[:number], author: detailed[:author])
+            next
+          end
+
+          Aidp.log_debug("watch_runner", "change_request_process", pr: detailed[:number])
+          @change_request_processor.process(detailed)
+        rescue RepositorySafetyChecker::UnauthorizedAuthorError => e
+          Aidp.log_warn("watch_runner", "unauthorized PR author", pr: pr[:number], error: e.message)
+        end
+      end
+
       def issue_has_label?(issue, label)
         Array(issue[:labels]).any? do |issue_label|
           name = issue_label.is_a?(Hash) ? issue_label["name"] : issue_label.to_s

data/lib/aidp/watch/state_store.rb

@@ -27,14 +27,26 @@ module Aidp
         plans[issue_number.to_s]
       end
 
+      def plan_iteration_count(issue_number)
+        plan = plans[issue_number.to_s]
+        return 0 unless plan
+        plan["iteration"] || 1
+      end
+
       def record_plan(issue_number, data)
+        existing_plan = plans[issue_number.to_s]
+        iteration = existing_plan ? (existing_plan["iteration"] || 1) + 1 : 1
+
         payload = {
           "summary" => data[:summary],
           "tasks" => data[:tasks],
           "questions" => data[:questions],
           "comment_body" => data[:comment_body],
           "comment_hint" => data[:comment_hint],
-          "posted_at" => data[:posted_at] || Time.now.utc.iso8601
+          "comment_id" => data[:comment_id],
+          "posted_at" => data[:posted_at] || Time.now.utc.iso8601,
+          "iteration" => iteration,
+          "previous_iteration_at" => existing_plan ? existing_plan["posted_at"] : nil
         }.compact
 
         plans[issue_number.to_s] = payload
@@ -96,6 +108,34 @@ module Aidp
         save!
       end
 
+      # Change request tracking methods
+      def change_request_processed?(pr_number)
+        change_requests.key?(pr_number.to_s)
+      end
+
+      def change_request_data(pr_number)
+        change_requests[pr_number.to_s]
+      end
+
+      def record_change_request(pr_number, data)
+        payload = {
+          "status" => data[:status],
+          "timestamp" => data[:timestamp] || Time.now.utc.iso8601,
+          "changes_applied" => data[:changes_applied],
+          "commits" => data[:commits],
+          "reason" => data[:reason],
+          "clarification_count" => data[:clarification_count]
+        }.compact
+
+        change_requests[pr_number.to_s] = payload
+        save!
+      end
+
+      def reset_change_request_state(pr_number)
+        change_requests.delete(pr_number.to_s)
+        save!
+      end
+
       private
 
       def ensure_directory
@@ -126,6 +166,7 @@ module Aidp
           base["builds"] ||= {}
           base["reviews"] ||= {}
           base["ci_fixes"] ||= {}
+          base["change_requests"] ||= {}
           base
         end
       end
@@ -146,6 +187,10 @@ module Aidp
         state["ci_fixes"]
       end
 
+      def change_requests
+        state["change_requests"]
+      end
+
       def stringify_keys(hash)
         return {} unless hash
 

data/lib/aidp/workflows/guided_agent.rb

@@ -19,7 +19,7 @@ module Aidp
 
       class ConversationError < StandardError; end
 
-      def initialize(project_dir, prompt: nil, use_enhanced_input: true, verbose: false)
+      def initialize(project_dir, prompt: nil, use_enhanced_input: true, verbose: false, config_manager: nil, provider_manager: nil)
         @project_dir = project_dir
 
         # Use EnhancedInput with Reline for full readline-style key bindings
@@ -29,8 +29,8 @@ module Aidp
           prompt || TTY::Prompt.new
         end
 
-        @config_manager = Aidp::Harness::ConfigManager.new(project_dir)
-        @provider_manager = Aidp::Harness::ProviderManager.new(@config_manager, prompt: @prompt)
+        @config_manager = config_manager || Aidp::Harness::ConfigManager.new(project_dir)
+        @provider_manager = provider_manager || Aidp::Harness::ProviderManager.new(@config_manager, prompt: @prompt)
         @conversation_history = []
         @user_input = {}
         @verbose = verbose

data/lib/aidp/workstream_executor.rb

@@ -156,8 +156,11 @@ module Aidp
         )
 
         # Log error and exit
-        warn("Error in workstream #{slug}: #{e.message}")
-        warn(e.backtrace.first(5).join("\n"))
+        # Suppress backtrace noise during tests while keeping it for production debugging
+        unless ENV["RSPEC_RUNNING"] == "true"
+          warn("Error in workstream #{slug}: #{e.message}")
+          warn(e.backtrace.first(5).join("\n"))
+        end
         exit(1)
       end
 

data/lib/aidp.rb

@@ -93,6 +93,10 @@ require_relative "aidp/harness/state_manager"
 require_relative "aidp/harness/error_handler"
 require_relative "aidp/harness/status_display"
 require_relative "aidp/harness/runner"
+require_relative "aidp/harness/filter_strategy"
+require_relative "aidp/harness/generic_filter_strategy"
+require_relative "aidp/harness/rspec_filter_strategy"
+require_relative "aidp/harness/output_filter"
 
 # UI components
 require_relative "aidp/harness/ui/spinner_helper"

data/templates/aidp-development.yml.example

@@ -137,7 +137,7 @@ providers:
       file_upload: true
       code_generation: true
       analysis: true
-      streaming: true
+      supports_json_mode: true
 
     # Monitoring configuration (enhanced for development)
     monitoring:
@@ -243,7 +243,7 @@ providers:
       code_generation: true
       analysis: true
       vision: true
-      streaming: true
+      supports_json_mode: true
       function_calling: true
       tool_use: true