aidp 0.34.1 → 0.39.3

data/lib/aidp/setup/wizard.rb

@@ -7,6 +7,8 @@ require "time"
 require "fileutils"
 require "json"
 require "ostruct"
+require_relative "in_memory_config_adapter"
+require_relative "in_memory_config_manager"
 
 module Aidp
   module Setup
@@ -104,35 +106,23 @@ module Aidp
       # Provider configuration
       # -------------------------------------------
       def discover_available_providers
-        providers_dir = File.join(__dir__, "../providers")
-        provider_files = Dir.glob("*.rb", base: providers_dir)
-
-        # Exclude base classes and non-provider utility files
-        excluded_files = ["base.rb", "adapter.rb", "capability_registry.rb", "error_taxonomy.rb"]
-        provider_files -= excluded_files
+        require "agent_harness"
 
         providers = {}
+        registry = AgentHarness::Providers::Registry.instance
 
-        provider_files.each do |file|
-          provider_name = File.basename(file, ".rb")
-          begin
-            # Require the provider file if not already loaded
-            require_relative "../providers/#{provider_name}"
-
-            # Convert to class name (e.g., "anthropic" -> "Anthropic")
-            class_name = provider_name.split("_").map(&:capitalize).join
-            provider_class = Aidp::Providers.const_get(class_name)
-
-            # Create a temporary instance to get the display name
-            if provider_class.respond_to?(:new)
-              instance = provider_class.new
-              display_name = instance.respond_to?(:display_name) ? instance.display_name : provider_name.capitalize
-              providers[display_name] = provider_name
-            end
-          rescue => e
-            # Skip providers that can't be loaded, but don't fail the entire discovery
-            warn "Warning: Could not load provider #{provider_name}: #{e.message}" if ENV["DEBUG"]
+        registry.all.each do |provider_name|
+          provider_class = registry.get(provider_name)
+
+          # Create a temporary instance to get the display name
+          if provider_class.respond_to?(:new)
+            instance = provider_class.new
+            display_name = instance.respond_to?(:display_name) ? instance.display_name : provider_name.to_s.capitalize
+            providers[display_name] = provider_name.to_s
           end
+        rescue => e
+          # Skip providers that can't be loaded, but don't fail the entire discovery
+          warn "Warning: Could not load provider #{provider_name}: #{e.message}" if Aidp.debug_env_enabled?
         end
 
         providers
@@ -156,17 +146,20 @@ module Aidp
         end
 
         # Save primary provider
-        set([:harness, :default_provider], provider_choice) unless provider_choice == "custom"
+        set(%i[harness default_provider], provider_choice) unless provider_choice == "custom"
 
-        ensure_provider_billing_config(provider_choice) unless provider_choice == "custom"
+        # Always ask for billing config when running interactive wizard (force: true)
+        # This ensures users can update billing type when reconfiguring
+        ensure_provider_billing_config(provider_choice, force: true) unless provider_choice == "custom"
 
         # Prompt for fallback providers (excluding the primary), pre-select existing
-        existing_fallbacks = Array(get([:harness, :fallback_providers])).map(&:to_s) - [provider_choice]
+        existing_fallbacks = Array(get(%i[harness fallback_providers])).map(&:to_s) - [provider_choice]
         fallback_choices = available_providers.reject { |_, name| name == provider_choice }
         fallback_default_names = existing_fallbacks.filter_map { |provider_name| fallback_choices.key(provider_name) }
 
         prompt.say("\n💡 Use ↑/↓ arrows to navigate, SPACE to select/deselect, ENTER to confirm")
-        fallback_selected = prompt.multi_select("Select fallback providers (used if primary fails):", default: fallback_default_names) do |menu|
+        fallback_selected = prompt.multi_select("Select fallback providers (used if primary fails):",
+          default: fallback_default_names) do |menu|
           fallback_choices.each do |display_name, provider_name|
             menu.choice display_name, provider_name
           end
@@ -176,9 +169,7 @@ module Aidp
         end
         # Recovery: if multi_select unexpectedly returns empty and there were no existing fallbacks, offer a single-select
         if fallback_selected.empty? && existing_fallbacks.empty? && !fallback_choices.empty?
-          if ENV["AIDP_FALLBACK_DEBUG"] == "1"
-            prompt.say("[debug] invoking recovery single-select for first fallback")
-          end
+          prompt.say("[debug] invoking recovery single-select for first fallback") if ENV["AIDP_FALLBACK_DEBUG"] == "1"
           if prompt.yes?("No fallback selected. Add one?", default: true)
             recovery_choice = prompt.select("Select a fallback provider:") do |menu|
               fallback_choices.each do |display_name, provider_name|
@@ -192,13 +183,14 @@ module Aidp
 
         # If user selected none but we had existing fallbacks, confirm removal
         if fallback_selected.empty? && existing_fallbacks.any?
-          keep = prompt.no?("No fallbacks selected. Remove existing fallbacks (#{existing_fallbacks.join(", ")})?", default: false)
+          keep = prompt.no?("No fallbacks selected. Remove existing fallbacks (#{existing_fallbacks.join(", ")})?",
+            default: false)
           fallback_selected = existing_fallbacks if keep
         end
 
         # Remove any accidental duplication of primary provider & save (preserve order)
         cleaned_fallbacks = fallback_selected.reject { |name| name == provider_choice }
-        set([:harness, :fallback_providers], cleaned_fallbacks)
+        set(%i[harness fallback_providers], cleaned_fallbacks)
 
         # Auto-create minimal provider configs for fallbacks if missing
         cleaned_fallbacks.each do |fp|
@@ -215,16 +207,18 @@ module Aidp
           loop do
             remaining = available_providers.reject { |_, name| ([provider_choice] + cleaned_fallbacks).include?(name) }
             break if remaining.empty?
+
             add_choice = prompt.select("Select additional fallback provider:") do |menu|
               remaining.each { |display, name| menu.choice display, name }
               menu.choice "Done", :done
             end
             break if add_choice == :done
-            unless cleaned_fallbacks.include?(add_choice)
-              cleaned_fallbacks << add_choice
-              set([:harness, :fallback_providers], cleaned_fallbacks)
-              ensure_provider_billing_config(add_choice, force: true)
-            end
+
+            next if cleaned_fallbacks.include?(add_choice)
+
+            cleaned_fallbacks << add_choice
+            set(%i[harness fallback_providers], cleaned_fallbacks)
+            ensure_provider_billing_config(add_choice, force: true)
           end
         end
         # Recompute editable after additions
@@ -241,9 +235,7 @@ module Aidp
               end
               # Sentinel option: add a new fallback provider that isn't yet in editable list
               remaining = available_map.values - editable
-              if remaining.any?
-                menu.choice "➕ Add fallback provider…", :add_fallback
-              end
+              menu.choice "➕ Add fallback provider…", :add_fallback if remaining.any?
               menu.choice "Done", :done
             end
 
@@ -252,16 +244,21 @@ module Aidp
               break
             when :add_fallback
               # Allow user to pick from remaining providers by display name
-              remaining_map = available_map.select { |disp, internal| !editable.include?(internal) && internal != provider_choice }
+              remaining_map = available_map.select do |disp, internal|
+                !editable.include?(internal) && internal != provider_choice
+              end
               add_choice = prompt.select("Select provider to add as fallback:") do |menu|
                 remaining_map.each { |disp, internal| menu.choice disp, internal }
                 menu.choice "Cancel", :cancel
               end
               next if add_choice == :cancel
+
               unless cleaned_fallbacks.include?(add_choice)
                 cleaned_fallbacks << add_choice
-                set([:harness, :fallback_providers], cleaned_fallbacks)
-                prompt.say("[debug] ensuring billing config for newly added fallback '#{add_choice}'") if ENV["AIDP_FALLBACK_DEBUG"] == "1"
+                set(%i[harness fallback_providers], cleaned_fallbacks)
+                if ENV["AIDP_FALLBACK_DEBUG"] == "1"
+                  prompt.say("[debug] ensuring billing config for newly added fallback '#{add_choice}'")
+                end
                 ensure_provider_billing_config(add_choice, force: true)
                 editable = ([provider_choice] + cleaned_fallbacks).uniq.reject { |p| p == "custom" }
               end
@@ -296,7 +293,7 @@ module Aidp
           (existing[:max_retries] || 2).to_s
         ) { |value| value.to_i }
 
-        set([:harness, :max_retries], max_retries)
+        set(%i[harness max_retries], max_retries)
       end
 
       # Removed MCP configuration step (MCP now expected to be provider-specific if used)
@@ -309,8 +306,8 @@ module Aidp
         prompt.say("-" * 40)
 
         # Get configured providers
-        primary_provider = get([:harness, :default_provider])
-        fallback_providers = Array(get([:harness, :fallback_providers]))
+        primary_provider = get(%i[harness default_provider])
+        fallback_providers = Array(get(%i[harness fallback_providers]))
         all_providers = ([primary_provider] + fallback_providers).compact.uniq
 
         if all_providers.empty?
@@ -326,9 +323,7 @@ module Aidp
 
         if has_existing_tiers
           prompt.say("📝 Found existing tier configuration")
-          unless prompt.yes?("Would you like to update it with discovered models?", default: false)
-            return
-          end
+          return unless prompt.yes?("Would you like to update it with discovered models?", default: false)
         elsif !prompt.yes?("Auto-configure thinking tiers with discovered models?", default: true)
           prompt.say("💡 You can run 'aidp models discover' later to see available models")
           return
@@ -432,11 +427,11 @@ module Aidp
             tier_models = find_models_for_tier(models, tier)
 
             # Add to config if we found any models for this tier
-            if tier_models.any?
-              provider_tiers[tier.to_sym] = {
-                models: tier_models.map { |m| m[:name] }
-              }
-            end
+            next unless tier_models.any?
+
+            provider_tiers[tier.to_sym] = {
+              models: tier_models.map { |m| m[:name] }
+            }
           end
 
           # Only add provider if it has at least one tier configured
@@ -489,8 +484,7 @@ module Aidp
 
         configure_work_loop_limits
         configure_output_filtering
-        configure_test_commands
-        configure_linting
+        configure_commands
         configure_watch_patterns
         configure_guards
         configure_coverage
@@ -498,6 +492,208 @@ module Aidp
         configure_vcs_behavior
       end
 
+      # Configure generic deterministic commands for work loop
+      # Replaces the old category-specific configure_test_commands and configure_linting
+      def configure_commands
+        prompt.say("\n📋 Deterministic Commands Configuration")
+        prompt.say("  Commands run automatically during work loops to validate changes")
+        prompt.say("  Commands can run: after each unit, at full loop end, or on completion")
+
+        existing_commands = get(%i[work_loop commands]) || []
+
+        # If user has existing commands, offer to edit or start fresh
+        if existing_commands.any?
+          prompt.say("\n  Found #{existing_commands.size} existing command(s)")
+          action = prompt.select("What would you like to do?") do |menu|
+            menu.choice "Keep existing commands", :keep
+            menu.choice "Add more commands", :add
+            menu.choice "Replace all commands", :replace
+            menu.choice "Skip command configuration", :skip
+          end
+
+          case action
+          when :skip, :keep, nil
+            return
+          when :replace
+            existing_commands = []
+          when :add
+            # Continue to the loop below with existing commands
+          else
+            # Unexpected value - treat as skip for safety
+            return
+          end
+        else
+          return unless prompt.yes?("Configure deterministic commands?", default: true)
+        end
+
+        commands = existing_commands.dup
+        loop do
+          prompt.say("\n  Current commands: #{commands.size}")
+          commands.each_with_index do |cmd, i|
+            prompt.say("    #{i + 1}. [#{cmd[:category]}] #{cmd[:name]}: #{cmd[:command]}")
+          end
+
+          action = prompt.select("\nWhat would you like to do?") do |menu|
+            # Done is first so tests default to exiting the loop
+            menu.choice "Done configuring commands", :done
+            menu.choice "Add a command", :add
+            menu.choice "Add from auto-detected tooling", :detect
+            menu.choice "Remove a command", :remove if commands.any?
+          end
+
+          case action
+          when :add
+            cmd = collect_command_details
+            commands << cmd if cmd
+          when :detect
+            detected = add_detected_commands(commands)
+            commands = detected
+          when :remove
+            commands = remove_command_interactive(commands)
+          when :done, nil
+            # Exit on explicit done or unexpected nil (safety for tests)
+            break
+          end
+        end
+
+        set(%i[work_loop commands], commands)
+        prompt.say("✅ Configured #{commands.size} command(s)")
+      end
+
+      # Collect details for a single command
+      def collect_command_details
+        prompt.say("\n  Adding new command:")
+
+        name = prompt.ask("Command name (identifier):", required: true) do |q|
+          q.validate(/\A[a-z0-9_]+\z/i, "Name must be alphanumeric with underscores")
+        end
+
+        command = prompt.ask("Shell command to run:", required: true)
+
+        category_choices = [
+          ["Test (unit, integration, e2e)", :test],
+          ["Lint (code style)", :lint],
+          ["Formatter (auto-fix)", :formatter],
+          ["Build (compilation)", :build],
+          ["Documentation", :documentation],
+          ["Custom", :custom]
+        ]
+        category = prompt.select("Category:") do |menu|
+          category_choices.each { |label, value| menu.choice label, value }
+        end
+
+        run_after_choices = [
+          ["After each work unit iteration (recommended for tests/linters)", :each_unit],
+          ["Only at end of full work loop", :full_loop],
+          ["Only when agent marks work complete (recommended for formatters)", :on_completion]
+        ]
+        run_after = prompt.select("When should this command run?") do |menu|
+          run_after_choices.each { |label, value| menu.choice label, value }
+        end
+
+        required = prompt.yes?("Is this command required to pass? (failures block completion)", default: true)
+
+        {
+          name: name,
+          command: command,
+          category: category,
+          run_after: run_after,
+          required: required,
+          timeout_seconds: nil
+        }
+      end
+
+      # Add auto-detected commands
+      def add_detected_commands(existing_commands)
+        detected = detect_all_tooling
+        return existing_commands if detected.empty?
+
+        prompt.say("\n  Auto-detected tooling:")
+        detected.each_with_index do |cmd, i|
+          prompt.say("    #{i + 1}. [#{cmd[:category]}] #{cmd[:command]}")
+        end
+
+        selected = prompt.multi_select("Select commands to add:") do |menu|
+          detected.each_with_index do |cmd, i|
+            # Skip if already exists
+            existing = existing_commands.any? { |e| e[:command] == cmd[:command] }
+            label = "[#{cmd[:category]}] #{cmd[:command]}"
+            label += " (already added)" if existing
+            menu.choice label, i, disabled: existing ? "(already added)" : nil
+          end
+        end
+
+        new_commands = existing_commands.dup
+        selected.each do |idx|
+          new_commands << detected[idx]
+        end
+        new_commands
+      end
+
+      # Detect all tooling and return as generic command configs
+      def detect_all_tooling
+        commands = []
+
+        # Detect test command
+        test_cmd = detect_unit_test_command
+        if test_cmd && !test_cmd.empty?
+          commands << {
+            name: "unit_tests",
+            command: test_cmd,
+            category: :test,
+            run_after: :each_unit,
+            required: true,
+            timeout_seconds: 1800
+          }
+        end
+
+        # Detect lint command
+        lint_cmd = detect_lint_command
+        if lint_cmd && !lint_cmd.empty?
+          commands << {
+            name: "lint",
+            command: lint_cmd,
+            category: :lint,
+            run_after: :each_unit,
+            required: true,
+            timeout_seconds: 300
+          }
+        end
+
+        # Detect format command
+        format_cmd = detect_format_command
+        if format_cmd && !format_cmd.empty?
+          commands << {
+            name: "format",
+            command: format_cmd,
+            category: :formatter,
+            run_after: :on_completion,
+            required: false,
+            timeout_seconds: 120
+          }
+        end
+
+        commands
+      end
+
+      # Remove a command interactively
+      def remove_command_interactive(commands)
+        return commands if commands.empty?
+
+        choices = commands.each_with_index.map do |cmd, i|
+          ["#{cmd[:name]}: #{cmd[:command]}", i]
+        end
+
+        idx = prompt.select("Select command to remove:") do |menu|
+          choices.each { |label, value| menu.choice label, value }
+          menu.choice "Cancel", nil
+        end
+
+        return commands if idx.nil?
+
+        commands.dup.tap { |c| c.delete_at(idx) }
+      end
+
       def configure_work_loop_limits
         existing = get([:work_loop]) || {}
 
@@ -508,13 +704,13 @@ module Aidp
           (existing[:max_iterations] || 50).to_s
         ) { |value| value.to_i }
 
-        set([:work_loop, :max_iterations], max_iterations)
+        set(%i[work_loop max_iterations], max_iterations)
       end
 
       def configure_output_filtering
         prompt.say("\n🔍 Output filtering configuration")
         prompt.say("  Reduces token consumption by filtering test/lint output")
-        existing = get([:work_loop, :output_filtering]) || {}
+        existing = get(%i[work_loop output_filtering]) || {}
 
         return unless prompt.yes?("Configure output filtering?", default: false)
 
@@ -524,7 +720,7 @@ module Aidp
         )
 
         unless enabled
-          set([:work_loop, :output_filtering], {enabled: false})
+          set(%i[work_loop output_filtering], {enabled: false})
           return
         end
 
@@ -576,7 +772,7 @@ module Aidp
           0
         end
 
-        set([:work_loop, :output_filtering], {
+        set(%i[work_loop output_filtering], {
           enabled: true,
           test_mode: test_mode,
           lint_mode: lint_mode,
@@ -611,7 +807,7 @@ module Aidp
         end
 
         # Check if AI provider is configured
-        primary_provider = get([:harness, :default_provider])
+        primary_provider = get(%i[harness default_provider])
         unless primary_provider
           prompt.warn("⚠️  No AI provider configured. Configure providers first.")
           return
@@ -655,18 +851,18 @@ module Aidp
           end
         end
 
-        if filter_definitions.any?
-          set([:work_loop, :output_filtering, :filter_definitions], filter_definitions)
-          prompt.ok("\n✅ Generated #{filter_definitions.size} filter definition(s)")
-          prompt.say("   These filters will be applied deterministically (no AI calls at runtime)")
-        end
+        return unless filter_definitions.any?
+
+        set(%i[work_loop output_filtering filter_definitions], filter_definitions)
+        prompt.ok("\n✅ Generated #{filter_definitions.size} filter definition(s)")
+        prompt.say("   These filters will be applied deterministically (no AI calls at runtime)")
       end
 
       def collect_commands_for_filtering
         commands = []
 
         # Test commands
-        test_config = get([:work_loop, :test]) || {}
+        test_config = get(%i[work_loop test]) || {}
         if test_config[:unit] && !test_config[:unit].start_with?("echo")
           commands << {
             key: "unit_test",
@@ -693,7 +889,7 @@ module Aidp
         end
 
         # Lint commands
-        lint_config = get([:work_loop, :lint]) || {}
+        lint_config = get(%i[work_loop lint]) || {}
         if lint_config[:command] && !lint_config[:command].start_with?("echo")
           commands << {
             key: "lint",
@@ -707,30 +903,43 @@ module Aidp
       end
 
       def create_filter_factory
-        # Build a minimal configuration for the factory
-        config = build_harness_config_for_factory
-        Aidp::Harness::AIFilterFactory.new(config)
+        # Build in-memory configuration adapters for the factory
+        # This enables AGD to work before the config file is written
+        config_adapter = build_in_memory_config_adapter
+        config_manager = build_in_memory_config_manager
+
+        # Create provider factory with in-memory config manager
+        provider_factory = Aidp::Harness::ProviderFactory.new(config_manager)
+
+        Aidp.log_debug("setup_wizard", "creating_filter_factory",
+          provider: config_adapter.default_provider,
+          configured_providers: config_adapter.configured_providers)
+
+        Aidp::Harness::AIFilterFactory.new(config_adapter, provider_factory: provider_factory)
       end
 
-      def build_harness_config_for_factory
-        # Create a minimal config object that the factory needs
-        OpenStruct.new(
-          default_provider: get([:harness, :default_provider]),
-          providers: get([:providers]) || {},
-          thinking_tiers: get([:thinking, :tiers])
-        )
+      def build_in_memory_config_adapter
+        # Create adapter that provides Configuration-like interface from in-memory config
+        InMemoryConfigAdapter.new(@config, project_dir)
+      end
+
+      def build_in_memory_config_manager
+        # Create ConfigManager-compatible wrapper for in-memory config
+        InMemoryConfigManager.new(@config, project_dir)
       end
 
       def configure_test_commands
-        existing = get([:work_loop, :test]) || {}
+        existing = get(%i[work_loop test]) || {}
 
         unit = ask_with_default("Unit test command", existing[:unit] || detect_unit_test_command)
         integration = ask_with_default("Integration test command", existing[:integration])
         e2e = ask_with_default("End-to-end test command", existing[:e2e])
 
-        timeout = ask_with_default("Test timeout (seconds)", (existing[:timeout_seconds] || 1800).to_s) { |value| value.to_i }
+        timeout = ask_with_default("Test timeout (seconds)", (existing[:timeout_seconds] || 1800).to_s) do |value|
+          value.to_i
+        end
 
-        set([:work_loop, :test], {
+        set(%i[work_loop test], {
           unit: unit,
           integration: integration,
           e2e: e2e,
@@ -740,16 +949,48 @@ module Aidp
         validate_command(unit)
         validate_command(integration)
         validate_command(e2e)
+
+        # Check RSpec persistence configuration for --only-failures optimization
+        check_rspec_persistence_configuration(unit, integration, e2e)
+      end
+
+      # Validates RSpec persistence configuration if RSpec is detected
+      # Warns user if example_status_persistence_file_path is not configured
+      def check_rspec_persistence_configuration(*commands)
+        rspec_commands = commands.compact.select { |cmd| cmd.to_s.downcase.include?("rspec") }
+        return if rspec_commands.empty?
+
+        # Check if spec_helper.rb has persistence configured
+        require_relative "../harness/rspec_command_optimizer"
+        optimizer = Aidp::Harness::RSpecCommandOptimizer.new(project_dir)
+        config_check = optimizer.check_persistence_configuration
+
+        if config_check[:configured]
+          prompt.ok("✅ RSpec persistence configured for --only-failures optimization")
+        else
+          prompt.warn("\n⚠️  RSpec --only-failures optimization not available")
+          prompt.say("   The work loop can run significantly faster with --only-failures on subsequent iterations.")
+          prompt.say("   To enable, add this to your spec/spec_helper.rb:")
+          prompt.say("")
+          prompt.say("   RSpec.configure do |config|")
+          prompt.say("     config.example_status_persistence_file_path = '.rspec_status'")
+          prompt.say("   end")
+          prompt.say("")
+          prompt.say("   Also add .rspec_status to your .gitignore")
+
+          Aidp.log_info("setup_wizard", "rspec_persistence_missing",
+            message: "RSpec --only-failures optimization not available")
+        end
       end
 
       def configure_linting
-        existing = get([:work_loop, :lint]) || {}
+        existing = get(%i[work_loop lint]) || {}
 
         lint_cmd = ask_with_default("Lint command", existing[:command] || detect_lint_command)
         format_cmd = ask_with_default("Format command", existing[:format] || detect_format_command)
         autofix = prompt.yes?("Run formatter automatically?", default: existing.fetch(:autofix, false))
 
-        set([:work_loop, :lint], {
+        set(%i[work_loop lint], {
           command: lint_cmd,
           format: format_cmd,
           autofix: autofix
@@ -760,23 +1001,29 @@ module Aidp
       end
 
       def configure_watch_patterns
-        existing = get([:work_loop, :test, :watch]) || {}
+        existing = get(%i[work_loop test watch]) || {}
         default_patterns = detect_watch_patterns
 
         watch_patterns = ask_list("Test watch patterns (comma-separated)", existing.fetch(:patterns, default_patterns))
-        set([:work_loop, :test, :watch], {patterns: watch_patterns}) if watch_patterns.any?
+        set(%i[work_loop test watch], {patterns: watch_patterns}) if watch_patterns.any?
       end
 
       def configure_guards
-        existing = get([:work_loop, :guards]) || {}
+        existing = get(%i[work_loop guards]) || {}
 
         include_patterns = ask_list("Guard include patterns", existing[:include] || detect_source_patterns)
-        exclude_patterns = ask_list("Guard exclude patterns", existing[:exclude] || ["node_modules/**", "dist/**", "build/**"])
-        max_lines = ask_with_default("Max lines changed per commit", (existing[:max_lines_changed_per_commit] || 300).to_s) { |value| value.to_i }
-        protected_paths = ask_list("Protected paths (require confirmation)", existing[:protected_paths] || [], allow_empty: true)
-        confirmation_required = prompt.yes?("Require confirmation before editing protected paths?", default: existing.fetch(:confirm_protected, true))
-
-        set([:work_loop, :guards], {
+        exclude_patterns = ask_list("Guard exclude patterns",
+          existing[:exclude] || ["node_modules/**", "dist/**", "build/**"])
+        max_lines = ask_with_default("Max lines changed per commit",
+          (existing[:max_lines_changed_per_commit] || 300).to_s) do |value|
+          value.to_i
+        end
+        protected_paths = ask_list("Protected paths (require confirmation)", existing[:protected_paths] || [],
+          allow_empty: true)
+        confirmation_required = prompt.yes?("Require confirmation before editing protected paths?",
+          default: existing.fetch(:confirm_protected, true))
+
+        set(%i[work_loop guards], {
           include: include_patterns,
           exclude: exclude_patterns,
           max_lines_changed_per_commit: max_lines,
@@ -787,10 +1034,10 @@ module Aidp
 
       def configure_coverage
         prompt.say("\n📊 Coverage configuration")
-        existing = get([:work_loop, :coverage]) || {}
+        existing = get(%i[work_loop coverage]) || {}
 
         enabled = prompt.yes?("Enable coverage tracking?", default: existing.fetch(:enabled, false))
-        return set([:work_loop, :coverage], {enabled: false}) unless enabled
+        return set(%i[work_loop coverage], {enabled: false}) unless enabled
 
         coverage_tool_choices = [
           ["SimpleCov (Ruby)", "simplecov"],
@@ -801,7 +1048,9 @@ module Aidp
           ["Other", "other"]
         ]
         coverage_tool_default = existing[:tool]
-        coverage_tool_default_label = coverage_tool_choices.find { |label, value| value == coverage_tool_default }&.first
+        coverage_tool_default_label = coverage_tool_choices.find do |label, value|
+          value == coverage_tool_default
+        end&.first
 
         tool = prompt.select("Which coverage tool do you use?", default: coverage_tool_default_label) do |menu|
           coverage_tool_choices.each { |label, value| menu.choice label, value }
@@ -812,12 +1061,13 @@ module Aidp
         fail_on_drop = prompt.yes?("Fail on coverage drop?", default: existing.fetch(:fail_on_drop, false))
 
         minimum_coverage_default = existing[:minimum_coverage]&.to_s
-        minimum_coverage_answer = ask_with_default("Minimum coverage % (optional - press enter to skip)", minimum_coverage_default)
+        minimum_coverage_answer = ask_with_default("Minimum coverage % (optional - press enter to skip)",
+          minimum_coverage_default)
         minimum_coverage = if minimum_coverage_answer && !minimum_coverage_answer.to_s.strip.empty?
           minimum_coverage_answer.to_f
         end
 
-        set([:work_loop, :coverage], {
+        set(%i[work_loop coverage], {
           enabled: true,
           tool: tool,
           run_command: run_command,
@@ -831,10 +1081,10 @@ module Aidp
 
       def configure_interactive_testing
         prompt.say("\n🎯 Interactive testing configuration")
-        existing = get([:work_loop, :interactive_testing]) || {}
+        existing = get(%i[work_loop interactive_testing]) || {}
 
         enabled = prompt.yes?("Enable interactive testing tools?", default: existing.fetch(:enabled, false))
-        return set([:work_loop, :interactive_testing], {enabled: false}) unless enabled
+        return set(%i[work_loop interactive_testing], {enabled: false}) unless enabled
 
         app_type_choices = [
           ["Web application", "web"],
@@ -859,7 +1109,7 @@ module Aidp
           tools[:desktop] = configure_desktop_testing_tools(existing.dig(:tools, :desktop) || {})
         end
 
-        set([:work_loop, :interactive_testing], {
+        set(%i[work_loop interactive_testing], {
           enabled: true,
           app_type: app_type,
           tools: tools
@@ -869,17 +1119,22 @@ module Aidp
       def configure_web_testing_tools(existing)
         tools = {}
 
-        playwright_enabled = prompt.yes?("Enable Playwright MCP?", default: existing.dig(:playwright_mcp, :enabled) || false)
+        playwright_enabled = prompt.yes?("Enable Playwright MCP?",
+          default: existing.dig(:playwright_mcp, :enabled) || false)
         if playwright_enabled
-          playwright_run = ask_with_default("Playwright run command", existing.dig(:playwright_mcp, :run) || "npx playwright test")
-          playwright_specs = ask_with_default("Playwright specs directory", existing.dig(:playwright_mcp, :specs_dir) || ".aidp/tests/web")
+          playwright_run = ask_with_default("Playwright run command",
+            existing.dig(:playwright_mcp, :run) || "npx playwright test")
+          playwright_specs = ask_with_default("Playwright specs directory",
+            existing.dig(:playwright_mcp, :specs_dir) || ".aidp/tests/web")
           tools[:playwright_mcp] = {enabled: true, run: playwright_run, specs_dir: playwright_specs}
         end
 
-        chrome_enabled = prompt.yes?("Enable Chrome DevTools MCP?", default: existing.dig(:chrome_devtools_mcp, :enabled) || false)
+        chrome_enabled = prompt.yes?("Enable Chrome DevTools MCP?",
+          default: existing.dig(:chrome_devtools_mcp, :enabled) || false)
         if chrome_enabled
           chrome_run = ask_with_default("Chrome DevTools run command", existing.dig(:chrome_devtools_mcp, :run) || "")
-          chrome_specs = ask_with_default("Chrome DevTools specs directory", existing.dig(:chrome_devtools_mcp, :specs_dir) || ".aidp/tests/web")
+          chrome_specs = ask_with_default("Chrome DevTools specs directory",
+            existing.dig(:chrome_devtools_mcp, :specs_dir) || ".aidp/tests/web")
           tools[:chrome_devtools_mcp] = {enabled: true, run: chrome_run, specs_dir: chrome_specs}
         end
 
@@ -891,8 +1146,10 @@ module Aidp
 
         expect_enabled = prompt.yes?("Enable expect scripts?", default: existing.dig(:expect, :enabled) || false)
         if expect_enabled
-          expect_run = ask_with_default("Expect run command", existing.dig(:expect, :run) || "expect .aidp/tests/cli/smoke.exp")
-          expect_specs = ask_with_default("Expect specs directory", existing.dig(:expect, :specs_dir) || ".aidp/tests/cli")
+          expect_run = ask_with_default("Expect run command",
+            existing.dig(:expect, :run) || "expect .aidp/tests/cli/smoke.exp")
+          expect_specs = ask_with_default("Expect specs directory",
+            existing.dig(:expect, :specs_dir) || ".aidp/tests/cli")
           tools[:expect] = {enabled: true, run: expect_run, specs_dir: expect_specs}
         end
 
@@ -902,16 +1159,22 @@ module Aidp
       def configure_desktop_testing_tools(existing)
         tools = {}
 
-        applescript_enabled = prompt.yes?("Enable AppleScript testing?", default: existing.dig(:applescript, :enabled) || false)
+        applescript_enabled = prompt.yes?("Enable AppleScript testing?",
+          default: existing.dig(:applescript, :enabled) || false)
         if applescript_enabled
-          applescript_run = ask_with_default("AppleScript run command", existing.dig(:applescript, :run) || "osascript .aidp/tests/desktop/smoke.scpt")
-          applescript_specs = ask_with_default("AppleScript specs directory", existing.dig(:applescript, :specs_dir) || ".aidp/tests/desktop")
+          applescript_run = ask_with_default("AppleScript run command",
+            existing.dig(:applescript,
+              :run) || "osascript .aidp/tests/desktop/smoke.scpt")
+          applescript_specs = ask_with_default("AppleScript specs directory",
+            existing.dig(:applescript, :specs_dir) || ".aidp/tests/desktop")
           tools[:applescript] = {enabled: true, run: applescript_run, specs_dir: applescript_specs}
         end
 
-        screen_reader_enabled = prompt.yes?("Enable screen reader testing?", default: existing.dig(:screen_reader, :enabled) || false)
+        screen_reader_enabled = prompt.yes?("Enable screen reader testing?",
+          default: existing.dig(:screen_reader, :enabled) || false)
         if screen_reader_enabled
-          screen_reader_notes = ask_with_default("Screen reader testing notes (optional)", existing.dig(:screen_reader, :notes) || "VoiceOver scripted checks")
+          screen_reader_notes = ask_with_default("Screen reader testing notes (optional)",
+            existing.dig(:screen_reader, :notes) || "VoiceOver scripted checks")
           tools[:screen_reader] = {enabled: true, notes: screen_reader_notes}
         end
 
@@ -920,7 +1183,7 @@ module Aidp
 
       def configure_vcs_behavior
         prompt.say("\n🗂️  Version control configuration")
-        existing = get([:work_loop, :version_control]) || {}
+        existing = get(%i[work_loop version_control]) || {}
 
         # Detect VCS
         detected_vcs = detect_vcs_tool
@@ -933,7 +1196,8 @@ module Aidp
         vcs_default_label = vcs_choices.find { |label, value| value == vcs_default }&.first
 
         vcs_tool = if detected_vcs
-          prompt.select("Detected #{detected_vcs}. Use this version control system?", default: vcs_default_label) do |menu|
+          prompt.select("Detected #{detected_vcs}. Use this version control system?",
+            default: vcs_default_label) do |menu|
             vcs_choices.each { |label, value| menu.choice label, value }
           end
         else
@@ -942,7 +1206,7 @@ module Aidp
           end
         end
 
-        return set([:work_loop, :version_control], {tool: "none", behavior: "nothing"}) if vcs_tool == "none"
+        return set(%i[work_loop version_control], {tool: "none", behavior: "nothing"}) if vcs_tool == "none"
 
         prompt.say("\n📋 Commit Behavior (applies to copilot/interactive mode only)")
         prompt.say("Note: Watch mode and fully automatic daemon mode will always commit changes.")
@@ -970,7 +1234,7 @@ module Aidp
           {auto_create_pr: false}
         end
 
-        set([:work_loop, :version_control], {
+        set(%i[work_loop version_control], {
           tool: vcs_tool,
           behavior: behavior,
           **commit_config,
@@ -997,7 +1261,9 @@ module Aidp
             ["Emoji (e.g., '✨ feat: add user authentication')", "emoji"]
           ]
           commit_style_default = existing[:commit_style] || "default"
-          commit_style_default_label = commit_style_choices.find { |label, value| value == commit_style_default }&.first
+          commit_style_default_label = commit_style_choices.find do |label, value|
+            value == commit_style_default
+          end&.first
 
           prompt.select("Conventional commit style:", default: commit_style_default_label) do |menu|
             commit_style_choices.each { |label, value| menu.choice label, value }
@@ -1060,13 +1326,14 @@ module Aidp
       def configure_branching
         prompt.say("\n🌿 Branching strategy")
         prompt.say("-" * 40)
-        existing = get([:work_loop, :branching]) || {}
+        existing = get(%i[work_loop branching]) || {}
 
         prefix = ask_with_default("Branch prefix for work loops", existing[:prefix] || "aidp")
-        slug_format = ask_with_default("Slug format (use %{id} and %{title})", existing[:slug_format] || "issue-%{id}-%{title}")
-        checkpoint_tag = ask_with_default("Checkpoint tag template", existing[:checkpoint_tag] || "aidp-start/%{id}")
+        slug_format = ask_with_default("Slug format (use %<id>s and %<title>s)",
+          existing[:slug_format] || "issue-%<id>s-%<title>s")
+        checkpoint_tag = ask_with_default("Checkpoint tag template", existing[:checkpoint_tag] || "aidp-start/%<id>s")
 
-        set([:work_loop, :branching], {
+        set(%i[work_loop branching], {
           prefix: prefix,
           slug_format: slug_format,
           checkpoint_tag: checkpoint_tag
@@ -1076,13 +1343,13 @@ module Aidp
       def configure_artifacts
         prompt.say("\n📁 Artifact storage")
         prompt.say("-" * 40)
-        existing = get([:work_loop, :artifacts]) || {}
+        existing = get(%i[work_loop artifacts]) || {}
 
         evidence_dir = ask_with_default("Evidence pack directory", existing[:evidence_dir] || ".aidp/evidence")
         logs_dir = ask_with_default("Logs directory", existing[:logs_dir] || ".aidp/logs")
         screenshots_dir = ask_with_default("Screenshots directory", existing[:screenshots_dir] || ".aidp/screenshots")
 
-        set([:work_loop, :artifacts], {
+        set(%i[work_loop artifacts], {
           evidence_dir: evidence_dir,
           logs_dir: logs_dir,
           screenshots_dir: screenshots_dir
@@ -1104,10 +1371,10 @@ module Aidp
 
         unless configure
           Aidp.log_debug("setup_wizard.nfrs", "opt_out")
-          return set([:nfrs, :configure], false)
+          return set(%i[nfrs configure], false)
         end
 
-        set([:nfrs, :configure], true)
+        set(%i[nfrs configure], true)
         categories = %i[performance security reliability accessibility internationalization]
         categories.each do |category|
           existing = get([:nfrs, category])
@@ -1126,11 +1393,11 @@ module Aidp
         prompt.say("\n📚 Detected stack: #{(stack == :other) ? "Custom" : stack.to_s.capitalize}")
         case stack
         when :rails
-          set([:nfrs, :preferred_libraries, :rails], configure_rails_libraries)
+          set(%i[nfrs preferred_libraries rails], configure_rails_libraries)
         when :node
-          set([:nfrs, :preferred_libraries, :node], configure_node_libraries)
+          set(%i[nfrs preferred_libraries node], configure_node_libraries)
         when :python
-          set([:nfrs, :preferred_libraries, :python], configure_python_libraries)
+          set(%i[nfrs preferred_libraries python], configure_python_libraries)
         else
           custom_stack = ask_with_default("Name this stack (e.g. go, php)", "custom")
           libs = ask_list("Preferred libraries (comma-separated)", [])
@@ -1154,7 +1421,7 @@ module Aidp
       end
 
       def configure_rails_libraries
-        existing = get([:nfrs, :preferred_libraries, :rails]) || {}
+        existing = get(%i[nfrs preferred_libraries rails]) || {}
         {
           auth: ask_with_default("Authentication gem", existing[:auth] || "devise"),
           authz: ask_with_default("Authorization gem", existing[:authz] || "pundit"),
@@ -1164,7 +1431,7 @@ module Aidp
       end
 
       def configure_node_libraries
-        existing = get([:nfrs, :preferred_libraries, :node]) || {}
+        existing = get(%i[nfrs preferred_libraries node]) || {}
         {
           validation: ask_with_default("Validation library", existing[:validation] || "zod"),
           orm: ask_with_default("ORM/Database", existing[:orm] || "prisma"),
@@ -1173,7 +1440,7 @@ module Aidp
       end
 
       def configure_python_libraries
-        existing = get([:nfrs, :preferred_libraries, :python]) || {}
+        existing = get(%i[nfrs preferred_libraries python]) || {}
         linting = ask_list("Linting tools", existing[:linting] || %w[ruff mypy])
         {
           validation: ask_with_default("Validation library", existing[:validation] || "pydantic"),
@@ -1191,9 +1458,9 @@ module Aidp
         existing = get([:logging]) || {}
 
         log_level_choices = [
-          ["Debug", "debug"],
-          ["Info", "info"],
-          ["Error", "error"]
+          %w[Debug debug],
+          %w[Info info],
+          %w[Error error]
         ]
         log_level_default = existing[:level] || "info"
         log_level_default_label = log_level_choices.find { |label, value| value == log_level_default }&.first
@@ -1284,9 +1551,11 @@ module Aidp
         prompt.say("-" * 40)
         existing = get([:modes]) || {}
 
-        background = prompt.yes?("Run in background mode by default?", default: existing.fetch(:background_default, false))
+        background = prompt.yes?("Run in background mode by default?",
+          default: existing.fetch(:background_default, false))
         watch = prompt.yes?("Enable watch mode integrations?", default: existing.fetch(:watch_enabled, false))
-        quick_mode = prompt.yes?("Enable quick mode (short timeouts) by default?", default: existing.fetch(:quick_mode_default, false))
+        quick_mode = prompt.yes?("Enable quick mode (short timeouts) by default?",
+          default: existing.fetch(:quick_mode_default, false))
 
         set([:modes], {
           background_default: background,
@@ -1310,7 +1579,7 @@ module Aidp
 
       def configure_watch_safety
         prompt.say("\n🔒 Watch mode safety settings")
-        existing = get([:watch, :safety]) || {}
+        existing = get(%i[watch safety]) || {}
 
         allow_public_repos = prompt.yes?(
           "Allow watch mode on public repositories?",
@@ -1330,7 +1599,7 @@ module Aidp
           default: existing.fetch(:require_container, true)
         )
 
-        set([:watch, :safety], {
+        set(%i[watch safety], {
           allow_public_repos: allow_public_repos,
           author_allowlist: author_allowlist,
           require_container: require_container
@@ -1340,7 +1609,7 @@ module Aidp
       def configure_watch_labels
         prompt.say("\n🏷️  Watch mode label configuration")
         prompt.say("  Configure GitHub issue and PR labels that trigger watch mode actions")
-        existing = get([:watch, :labels]) || {}
+        existing = get(%i[watch labels]) || {}
 
         plan_trigger = ask_with_default(
           "Label to trigger plan generation",
@@ -1382,7 +1651,7 @@ module Aidp
           existing[:change_request_trigger] || "aidp-request-changes"
         )
 
-        set([:watch, :labels], {
+        set(%i[watch labels], {
           plan_trigger: plan_trigger,
           needs_input: needs_input,
           ready_to_build: ready_to_build,
@@ -1397,7 +1666,7 @@ module Aidp
       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]) || {}
+        existing = get(%i[watch change_requests]) || {}
 
         max_diff_size = ask_with_default(
           "Maximum PR diff size (lines) for change requests",
@@ -1409,7 +1678,7 @@ module Aidp
           default: existing.fetch(:post_detection_comments, true)
         )
 
-        set([:watch, :change_requests], {
+        set(%i[watch change_requests], {
           max_diff_size: max_diff_size
         })
 
@@ -1462,7 +1731,7 @@ module Aidp
         Aidp.log_debug("setup_wizard.label_creation", "existing_labels_fetched", count: existing_labels.size)
 
         # Get configured label names
-        labels_config = get([:watch, :labels]) || {}
+        labels_config = get(%i[watch labels]) || {}
         required_labels = collect_required_labels(labels_config)
 
         # Determine which labels need to be created
@@ -1534,7 +1803,8 @@ module Aidp
       # Fetch existing labels from GitHub
       def fetch_existing_labels(owner, repo)
         require "open3"
-        stdout, stderr, status = Open3.capture3("gh", "label", "list", "-R", "#{owner}/#{repo}", "--json", "name", "--jq", ".[].name")
+        stdout, stderr, status = Open3.capture3("gh", "label", "list", "-R", "#{owner}/#{repo}", "--json", "name",
+          "--jq", ".[].name")
 
         unless status.success?
           Aidp.log_error("setup_wizard.fetch_labels", "gh_failed", error: stderr)
@@ -1559,26 +1829,18 @@ module Aidp
           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)
+          change_request_trigger: "F9D0C4", # Light pink
+          in_progress: "1D76DB" # Dark blue (internal coordination)
         }
 
         required = []
         labels_config.each do |key, name|
           next if name.nil? || name.to_s.strip.empty?
 
-          color = default_colors[key] || "EDEDED"  # Gray fallback
+          color = default_colors[key] || "EDEDED" # Gray fallback
           required << {name: name, color: color, key: key}
         end
 
-        # Always include the internal in-progress label for coordination
-        required << {
-          name: "aidp-in-progress",
-          color: default_colors[:in_progress],
-          key: :in_progress,
-          internal: true
-        }
-
         Aidp.log_debug("setup_wizard.collect_labels", "collected", count: required.size)
         required
       end
@@ -1728,6 +1990,7 @@ module Aidp
 
         if answer.nil? || answer.strip.empty?
           return default if default.nil? || !block_given?
+
           return yield(default)
         end
 
@@ -1744,6 +2007,7 @@ module Aidp
           line = prompt.ask("", default: nil)
           break if line.nil? || line.empty?
           return nil if line.strip.casecmp("clear").zero?
+
           lines << line
         end
         return default if lines.empty?
@@ -1786,6 +2050,7 @@ module Aidp
         return "bundle exec rspec" if project_file?("Gemfile") && Dir.exist?(File.join(project_dir, "spec"))
         return "npm test" if project_file?("package.json")
         return "pytest" if project_file?("pytest.ini") || Dir.exist?(File.join(project_dir, "tests"))
+
         "echo 'No tests configured'"
       end
 
@@ -1793,6 +2058,7 @@ module Aidp
         return "bundle exec rubocop" if project_file?(".rubocop.yml")
         return "npm run lint" if project_file?("package.json")
         return "ruff check ." if project_file?("pyproject.toml")
+
         "echo 'No linter configured'"
       end
 
@@ -1800,6 +2066,7 @@ module Aidp
         return "bundle exec rubocop -A" if project_file?(".rubocop.yml")
         return "npm run format" if project_file?("package.json")
         return "ruff format ." if project_file?("pyproject.toml")
+
         "echo 'No formatter configured'"
       end
 
@@ -1862,6 +2129,7 @@ module Aidp
       def detect_vcs_tool
         return "git" if Dir.exist?(File.join(project_dir, ".git"))
         return "svn" if Dir.exist?(File.join(project_dir, ".svn"))
+
         nil
       end
 
@@ -1880,7 +2148,8 @@ module Aidp
       end
 
       def show_provider_summary(primary, fallbacks)
-        Aidp.log_debug("wizard.provider_summary", "displaying provider configuration table", primary: primary, fallback_count: fallbacks&.size || 0)
+        Aidp.log_debug("wizard.provider_summary", "displaying provider configuration table", primary: primary,
+          fallback_count: fallbacks&.size || 0)
         prompt.say("\n📋 Provider Configuration Summary:")
         providers_config = get([:providers]) || {}
 
@@ -1960,6 +2229,7 @@ module Aidp
       # Ensure a minimal billing configuration exists for a selected provider (no secrets)
       def ensure_provider_billing_config(provider_name, force: false)
         return if provider_name.nil? || provider_name == "custom"
+
         providers_section = get([:providers]) || {}
         existing = providers_section[provider_name.to_sym]
 
@@ -1977,6 +2247,10 @@ module Aidp
         merged = (existing || {}).merge(type: provider_type, model_family: model_family)
         set([:providers, provider_name.to_sym], merged)
         normalize_existing_model_families!
+
+        # Offer to configure usage limits for usage-based providers
+        configure_usage_limits(provider_name) if provider_type == "usage_based"
+
         action_word = if existing
           force ? "reconfigured" : "updated"
         else
@@ -1993,9 +2267,7 @@ module Aidp
 
         action = prompt.select("What would you like to do with '#{display_name}'?") do |menu|
           menu.choice "Edit configuration", :edit
-          unless is_primary
-            menu.choice "Remove from configuration", :remove
-          end
+          menu.choice "Remove from configuration", :remove unless is_primary
           menu.choice "Cancel", :cancel
         end
 
@@ -2015,12 +2287,12 @@ module Aidp
 
       def remove_fallback_provider(provider_name, fallbacks)
         display_name = discover_available_providers.invert.fetch(provider_name, provider_name)
-        if prompt.yes?("Remove '#{display_name}' from fallback providers?", default: false)
-          fallbacks.delete(provider_name)
-          set([:harness, :fallback_providers], fallbacks)
-          Aidp.log_info("wizard.remove_provider", "removed fallback provider", provider: provider_name)
-          prompt.ok("Removed '#{display_name}' from fallback providers")
-        end
+        return unless prompt.yes?("Remove '#{display_name}' from fallback providers?", default: false)
+
+        fallbacks.delete(provider_name)
+        set(%i[harness fallback_providers], fallbacks)
+        Aidp.log_info("wizard.remove_provider", "removed fallback provider", provider: provider_name)
+        prompt.ok("Removed '#{display_name}' from fallback providers")
       end
 
       def edit_provider_configuration(provider_name)
@@ -2028,12 +2300,177 @@ module Aidp
         prompt.say("\n🔧 Editing provider '#{provider_name}' (current: type=#{existing[:type] || "unset"}, model_family=#{existing[:model_family] || "unset"})")
         new_type = ask_provider_billing_type_with_default(provider_name, existing[:type])
         new_family = ask_model_family(provider_name, existing[:model_family] || "auto")
-        set([:providers, provider_name.to_sym], {type: new_type, model_family: new_family})
+
+        # Merge with existing config to preserve other keys (e.g., usage_limits, custom settings)
+        updated_config = existing.merge(type: new_type, model_family: new_family)
+
+        set([:providers, provider_name.to_sym], updated_config)
         # Normalize immediately so tests relying on canonical value see 'claude' rather than label
         normalize_existing_model_families!
+
+        # Offer to configure/edit usage limits for usage-based providers
+        configure_usage_limits(provider_name) if new_type == "usage_based"
+
         prompt.ok("Updated '#{provider_name}' → type=#{new_type}, model_family=#{new_family}")
       end
 
+      # Configure usage limits for a usage-based provider
+      # @param provider_name [String] Name of the provider
+      def configure_usage_limits(provider_name)
+        existing = get([:providers, provider_name.to_sym, :usage_limits]) || {}
+        existing_enabled = existing[:enabled] == true
+
+        display_name = discover_available_providers.invert.fetch(provider_name, provider_name)
+
+        if existing_enabled
+          prompt.say("\n💰 Usage limits currently enabled for '#{display_name}'")
+          action = prompt.select("Configure usage limits?") do |menu|
+            menu.choice "Keep current settings", :keep
+            menu.choice "Edit usage limits", :edit
+            menu.choice "Disable usage limits", :disable
+          end
+
+          case action
+          when :keep
+            return
+          when :disable
+            set([:providers, provider_name.to_sym, :usage_limits], {enabled: false})
+            prompt.ok("Disabled usage limits for '#{display_name}'")
+            return
+          end
+        else
+          return unless prompt.yes?("\n💰 Configure usage limits for '#{display_name}'? (prevents runaway costs)",
+            default: false)
+        end
+
+        # Configure usage limits
+        limits_config = ask_usage_limits_config(provider_name, existing)
+        set([:providers, provider_name.to_sym, :usage_limits], limits_config)
+
+        return unless limits_config[:enabled]
+
+        prompt.ok("Configured usage limits for '#{display_name}'")
+      end
+
+      # Ask for usage limits configuration
+      # @param provider_name [String] Provider name
+      # @param existing [Hash] Existing configuration
+      # @return [Hash] Usage limits configuration
+      def ask_usage_limits_config(provider_name, existing = {})
+        display_name = discover_available_providers.invert.fetch(provider_name, provider_name)
+
+        # Period selection
+        period_choices = [
+          %w[Monthly monthly],
+          %w[Weekly weekly],
+          %w[Daily daily]
+        ]
+        period_default = existing[:period] || "monthly"
+        period_default_label = period_choices.find { |label, value| value == period_default }&.first
+
+        period = prompt.select("Billing period for '#{display_name}':", default: period_default_label) do |menu|
+          period_choices.each { |label, value| menu.choice label, value }
+        end
+
+        # Reset day (only for monthly)
+        reset_day = 1
+        if period == "monthly"
+          reset_day = prompt.ask("Day of month for period reset (1-28):",
+            default: (existing[:reset_day] || 1).to_s,
+            convert: :int) do |q|
+            q.validate(->(v) { v.to_i.between?(1, 28) }, "Please enter a day between 1 and 28")
+          end
+        end
+
+        # Limit type selection
+        limit_type = prompt.select("How would you like to set limits?") do |menu|
+          menu.choice "By tier (different limits for mini vs advanced)", :tier
+          menu.choice "Global (single limit for all usage)", :global
+          menu.choice "Skip (no limits)", :skip
+        end
+
+        return {enabled: false} if limit_type == :skip
+
+        if limit_type == :tier
+          ask_tier_limits_config(period, reset_day, existing)
+        else
+          ask_global_limits_config(period, reset_day, existing)
+        end
+      end
+
+      # Ask for global limits configuration
+      def ask_global_limits_config(period, reset_day, existing = {})
+        max_cost = prompt.ask("Maximum cost per #{period} in USD (e.g., 50.00, or blank for no limit):",
+          default: existing[:max_cost]&.to_s) do |q|
+          q.validate(/\A(\d+\.?\d*|)$/, "Please enter a valid number or leave blank")
+        end
+
+        max_tokens = prompt.ask("Maximum tokens per #{period} (e.g., 1000000, or blank for no limit):",
+          default: existing[:max_tokens]&.to_s) do |q|
+          q.validate(/\A(\d+|)$/, "Please enter a valid integer or leave blank")
+        end
+
+        config = {
+          enabled: true,
+          period: period,
+          reset_day: reset_day
+        }
+
+        config[:max_cost] = max_cost.to_f if max_cost && !max_cost.strip.empty?
+        config[:max_tokens] = max_tokens.to_i if max_tokens && !max_tokens.strip.empty?
+
+        config
+      end
+
+      # Ask for tier-based limits configuration
+      def ask_tier_limits_config(period, reset_day, existing = {})
+        existing_tier_limits = existing[:tier_limits] || {}
+
+        prompt.say("\n📊 Configure limits by tier (mini models typically have higher limits)")
+
+        tier_limits = {}
+
+        # Mini tier
+        prompt.say("\n🔹 Mini tier (fast, cheap models):")
+        mini_limits = ask_single_tier_limits("mini", period,
+          existing_tier_limits[:mini] || existing_tier_limits["mini"])
+        tier_limits[:mini] = mini_limits if mini_limits
+
+        # Advanced tier
+        prompt.say("\n🔸 Advanced tier (powerful, expensive models):")
+        advanced_limits = ask_single_tier_limits("advanced", period,
+          existing_tier_limits[:advanced] || existing_tier_limits["advanced"])
+        tier_limits[:advanced] = advanced_limits if advanced_limits
+
+        {
+          enabled: true,
+          period: period,
+          reset_day: reset_day,
+          tier_limits: tier_limits
+        }
+      end
+
+      # Ask for limits for a single tier
+      def ask_single_tier_limits(tier, period, existing = {})
+        existing ||= {}
+
+        max_cost = prompt.ask("  Max cost per #{period} for #{tier} tier (USD, blank for no limit):",
+          default: existing[:max_cost]&.to_s) do |q|
+          q.validate(/\A(\d+\.?\d*|)$/, "Please enter a valid number or leave blank")
+        end
+
+        max_tokens = prompt.ask("  Max tokens per #{period} for #{tier} tier (blank for no limit):",
+          default: existing[:max_tokens]&.to_s) do |q|
+          q.validate(/\A(\d+|)$/, "Please enter a valid integer or leave blank")
+        end
+
+        limits = {}
+        limits[:max_cost] = max_cost.to_f if max_cost && !max_cost.strip.empty?
+        limits[:max_tokens] = max_tokens.to_i if max_tokens && !max_tokens.strip.empty?
+
+        limits.empty? ? nil : limits
+      end
+
       def ask_provider_billing_type(provider_name)
         ask_provider_billing_type_with_default(provider_name, nil)
       end
@@ -2076,7 +2513,7 @@ module Aidp
 
         # Try label -> value mapping (case-insensitive)
         choices = ProviderRegistry.model_family_choices
-        mapped = choices.find { |label, _| label.downcase == value.to_s.downcase }&.last
+        mapped = choices.find { |label, _| label.casecmp(value.to_s).zero? }&.last
         return mapped if mapped
 
         # Unknown legacy entry -> fallback to auto
@@ -2086,8 +2523,10 @@ module Aidp
       def normalize_existing_model_families!
         providers_cfg = @config[:providers]
         return unless providers_cfg.is_a?(Hash)
+
         providers_cfg.each do |prov_name, prov_cfg|
           next unless prov_cfg.is_a?(Hash)
+
           mf = prov_cfg[:model_family]
           # Normalize and write back only if different to avoid unnecessary YAML churn
           normalized = normalize_model_family(mf)
@@ -2122,19 +2561,19 @@ module Aidp
         combined = []
         (Array(existing_models) + Array(new_models)).each do |entry|
           next unless entry.is_a?(Hash)
+
           provider = entry[:provider]
           model = entry[:model]
           next unless provider && model
 
-          unless combined.any? { |m| m[:provider] == provider && m[:model] == model }
-            combined << entry
-          end
+          combined << entry unless combined.any? { |m| m[:provider] == provider && m[:model] == model }
         end
         combined
       end
 
       def load_existing_config
         return {} unless File.exist?(config_path)
+
         YAML.safe_load_file(config_path, permitted_classes: [Time]) || {}
       rescue => e
         @warnings << "Failed to parse existing configuration: #{e.message}"
@@ -2302,7 +2741,7 @@ module Aidp
 
         unless manage
           Aidp.log_debug(DEVCONTAINER_COMPONENT, "configure.opt_out")
-          return set([:devcontainer, :manage], false)
+          return set(%i[devcontainer manage], false)
         end
 
         # Build wizard config and detect ports
@@ -2340,9 +2779,9 @@ module Aidp
         end
 
         # Save configuration
-        set([:devcontainer, :manage], true)
-        set([:devcontainer, :custom_ports], custom_ports) if custom_ports.any?
-        set([:devcontainer, :last_generated], Time.now.utc.iso8601)
+        set(%i[devcontainer manage], true)
+        set(%i[devcontainer custom_ports], custom_ports) if custom_ports.any?
+        set(%i[devcontainer last_generated], Time.now.utc.iso8601)
         Aidp.log_debug(DEVCONTAINER_COMPONENT, "configure.enabled",
           custom_port_count: custom_ports.count,
           detected_port_count: detected_ports.count)
@@ -2364,6 +2803,7 @@ module Aidp
         return "rails_web" if project_file?("config/routes.rb")
         return "sinatra" if project_file?("config.ru")
         return "express" if project_file?("app.js") && project_file?("package.json")
+
         "cli"
       end