aidp 0.19.1 → 0.20.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 25ff9a05d33bc6dc88dfac85b9fc37ff5023af5f756c1d7b2533b1d2f473b103
-  data.tar.gz: 11f7a0c6ca6d1c8b2f9f13475fe7d8a2ba9851f2ba09037264e6808171291d62
+  metadata.gz: 724d07296380ad69a72b1f9d6bf4dd44d77cf35f994eb35e1e0d224ed32e93a0
+  data.tar.gz: f54213c88e3e532205852f8dfbedcc0c264a446a65a1110ddf7de524f10e64d5
 SHA512:
-  metadata.gz: e05fe743a66e0370dff5a60194c824a71e1d99e8ffcbea03786ab9f8b98e7983ff9a01ce48bf6d2ac8f294781d9808715181f9d92f292dc6bfa4ca568a3a4175
-  data.tar.gz: 59774b09928fbc2e1b6e1023247aa5b2b1208531a965c2fe8c05f9012b2cb03a94a9ccf7dc6029a77086ed6f425a9570c3860b241a50094a6dd71c4053f782b6
+  metadata.gz: f8788f4f8af45642b276e350f7d64e2413ae1532cbe02fe29c95c06c8fcbf84ecd66c35cb73e5b16637b6780f52ba77991b255d78f5f2464200a5db6acce262b
+  data.tar.gz: 2cd95f1e5369205332ad1f87d313b6dc99801d7bdb6f13d0b661cfbba4a771a9e8277e6e8f43e8234a2bea1a6ba23cc73ef54e480f2cf73788bc6dd17aa8de74

data/lib/aidp/cli.rb

@@ -146,6 +146,16 @@ module Aidp
 
     class << self
       extend Aidp::MessageDisplay::ClassMethods
+      extend Aidp::RescueLogging
+
+      # Explicit singleton delegator (defensive: ensure availability even if extend fails to attach)
+      def log_rescue(error, component:, action:, fallback: nil, level: :warn, **context)
+        Aidp::RescueLogging.log_rescue(error, component: component, action: action, fallback: fallback, level: level, **context)
+      end
+
+      # Store last parsed options for access by UI components (e.g., verbose flag)
+      @last_options = nil
+      attr_accessor :last_options
 
       def create_prompt
         ::TTY::Prompt.new
@@ -156,6 +166,7 @@ module Aidp
         return run_subcommand(args) if subcommand?(args)
 
         options = parse_options(args)
+        self.last_options = options
 
         if options[:help]
           display_message(options[:parser].to_s, type: :info)
@@ -324,6 +335,7 @@ module Aidp
           opts.on("-h", "--help", "Show this help message") { options[:help] = true }
           opts.on("-v", "--version", "Show version information") { options[:version] = true }
           opts.on("--setup-config", "Setup or reconfigure config file") { options[:setup_config] = true }
+          opts.on("--verbose", "Show detailed prompts and raw provider responses during guided workflow") { options[:verbose] = true }
 
           opts.separator ""
           opts.separator "Examples:"

data/lib/aidp/harness/state/persistence.rb

@@ -18,21 +18,27 @@ module Aidp
           # Callers should set skip_persistence: true for test/dry-run scenarios
           @skip_persistence = skip_persistence
           ensure_state_directory
+          Aidp.log_debug("state_persistence", "initialized", mode: @mode, skip: @skip_persistence, dir: @state_dir)
         end
 
         def has_state?
           return false if @skip_persistence
-          File.exist?(@state_file)
+          exists = File.exist?(@state_file)
+          Aidp.log_debug("state_persistence", "has_state?", exists: exists, file: @state_file) if exists
+          exists
         end
 
         def load_state
           return {} if @skip_persistence || !has_state?
 
           with_lock do
+            Aidp.log_debug("state_persistence", "load_state.start", file: @state_file)
             content = File.read(@state_file)
-            JSON.parse(content, symbolize_names: true)
+            parsed = JSON.parse(content, symbolize_names: true)
+            Aidp.log_debug("state_persistence", "load_state.success", keys: parsed.keys.size, file: @state_file)
+            parsed
           rescue JSON::ParserError => e
-            warn "Failed to parse state file: #{e.message}"
+            Aidp.log_warn("state_persistence", "parse_error", error: e.message, file: @state_file)
             {}
           end
         end
@@ -41,8 +47,10 @@ module Aidp
           return if @skip_persistence
 
           with_lock do
+            Aidp.log_debug("state_persistence", "save_state.start", keys: state_data.keys.size)
             state_with_metadata = add_metadata(state_data)
             write_atomically(state_with_metadata)
+            Aidp.log_debug("state_persistence", "save_state.written", file: @state_file, size: state_with_metadata.keys.size)
           end
         end
 
@@ -50,7 +58,9 @@ module Aidp
           return if @skip_persistence
 
           with_lock do
+            Aidp.log_debug("state_persistence", "clear_state.start", file: @state_file)
             File.delete(@state_file) if File.exist?(@state_file)
+            Aidp.log_debug("state_persistence", "clear_state.done", file: @state_file)
           end
         end
 
@@ -66,8 +76,10 @@ module Aidp
 
         def write_atomically(state_with_metadata)
           temp_file = "#{@state_file}.tmp"
+          Aidp.log_debug("state_persistence", "write_atomically.start", temp: temp_file)
           File.write(temp_file, JSON.pretty_generate(state_with_metadata))
           File.rename(temp_file, @state_file)
+          Aidp.log_debug("state_persistence", "write_atomically.rename", file: @state_file)
         end
 
         def ensure_state_directory
@@ -76,45 +88,50 @@ module Aidp
 
         def with_lock(&block)
           return yield if @skip_persistence
-
-          acquire_lock_with_timeout(&block)
+          result = acquire_lock_with_timeout(&block)
+          result
         ensure
           cleanup_lock_file
         end
 
         def acquire_lock_with_timeout(&block)
-          lock_acquired = false
-          timeout = 30
+          timeout = ENV["AIDP_STATE_LOCK_TIMEOUT"]&.to_f || ((ENV["RSPEC_RUNNING"] == "true") ? 1.0 : 30.0)
           start_time = Time.now
-
+          attempt_result = nil
           while (Time.now - start_time) < timeout
-            lock_acquired = try_acquire_lock(&block)
-            break if lock_acquired
+            acquired, attempt_result = try_acquire_lock(&block)
+            return attempt_result if acquired
             sleep_briefly
           end
-
-          raise_lock_timeout_error unless lock_acquired
+          raise_lock_timeout_error(timeout)
         end
 
         def try_acquire_lock(&block)
           File.open(@lock_file, File::CREAT | File::EXCL | File::WRONLY) do |_lock|
-            yield
-            true
+            Aidp.log_debug("state_persistence", "lock.acquired", file: @lock_file)
+            [true, yield]
           end
         rescue Errno::EEXIST
-          false
+          Aidp.log_debug("state_persistence", "lock.busy", file: @lock_file)
+          [false, nil]
         end
 
         def sleep_briefly
-          sleep(0.1)
+          sleep(ENV["AIDP_STATE_LOCK_SLEEP"]&.to_f || 0.05)
         end
 
-        def raise_lock_timeout_error
-          raise "Could not acquire state lock within 30 seconds"
+        def raise_lock_timeout_error(timeout)
+          # Prefer explicit error class; fall back if not defined yet
+          error_class = defined?(Aidp::Errors::StateError) ? Aidp::Errors::StateError : RuntimeError
+          Aidp.log_error("state_persistence", "lock.timeout", file: @lock_file, waited: timeout)
+          raise error_class, "Could not acquire state lock within #{timeout} seconds"
         end
 
         def cleanup_lock_file
-          File.delete(@lock_file) if File.exist?(@lock_file)
+          if File.exist?(@lock_file)
+            File.delete(@lock_file)
+            Aidp.log_debug("state_persistence", "lock.cleaned", file: @lock_file)
+          end
         end
       end
     end

data/lib/aidp/harness/ui/enhanced_workflow_selector.rb

@@ -251,7 +251,10 @@ module Aidp
         def select_guided_workflow
           # Use the guided agent to help user select workflow
           # Don't pass prompt so it uses EnhancedInput with full readline support
-          guided_agent = Aidp::Workflows::GuidedAgent.new(@project_dir)
+          verbose_flag = (defined?(Aidp::CLI) && Aidp::CLI.respond_to?(:last_options) && Aidp::CLI.last_options) ? Aidp::CLI.last_options[:verbose] : false
+          # Fallback: store verbose in an env for easier access if options not available
+          verbose = verbose_flag || ENV["AIDP_VERBOSE"] == "1"
+          guided_agent = Aidp::Workflows::GuidedAgent.new(@project_dir, verbose: verbose)
           result = guided_agent.select_workflow
 
           # Store user input for later use

data/lib/aidp/logger.rb

@@ -33,7 +33,7 @@ module Aidp
     attr_reader :level, :json_format
 
     def initialize(project_dir = Dir.pwd, config = {})
-      @project_dir = project_dir
+      @project_dir = sanitize_project_dir(project_dir)
       @config = config
       @level = determine_log_level
       @json_format = config[:json] || false
@@ -195,6 +195,18 @@ module Aidp
     def redact_hash(hash)
       hash.transform_values { |v| v.is_a?(String) ? redact(v) : v }
     end
+
+    # Guard against accidentally passing stream sentinel strings or invalid characters
+    # that would create odd top-level directories like "<STDERR>".
+    def sanitize_project_dir(dir)
+      return Dir.pwd if dir.nil?
+      str = dir.to_s
+      if str.empty? || str.match?(/[<>|]/) || str.match?(/[\x00-\x1F]/)
+        Kernel.warn "[AIDP Logger] Invalid project_dir '#{str}' - falling back to #{Dir.pwd}"
+        return Dir.pwd
+      end
+      str
+    end
   end
 
   # Module-level logger accessor

data/lib/aidp/rescue_logging.rb

@@ -13,24 +13,35 @@ module Aidp
   #   - includes error class, message
   #   - optional fallback and extra context hash merged in
   module RescueLogging
+    # Instance-level helper (made public so extend works for singleton contexts)
     def log_rescue(error, component:, action:, fallback: nil, level: :warn, **context)
+      Aidp::RescueLogging.__log_rescue_impl(self, error, component: component, action: action, fallback: fallback, level: level, **context)
+    end
+
+    # Module-level access (Aidp::RescueLogging.log_rescue) for direct calls if desired
+    def self.log_rescue(error, component:, action:, fallback: nil, level: :warn, **context)
+      Aidp::RescueLogging.__log_rescue_impl(self, error, component: component, action: action, fallback: fallback, level: level, **context)
+    end
+
+    # Internal implementation shared by instance & module forms
+    def self.__log_rescue_impl(context_object, error, component:, action:, fallback:, level:, **extra)
       data = {
         error_class: error.class.name,
         error_message: error.message,
         action: action
       }
       data[:fallback] = fallback if fallback
-      data.merge!(context) unless context.empty?
+      data.merge!(extra) unless extra.empty?
 
-      # Prefer debug_mixin if present; otherwise use Aidp.logger directly
-      if respond_to?(:debug_log)
-        debug_log("⚠️ Rescue in #{component}: #{action}", level: level, data: data)
-      else
-        Aidp.logger.send(level, component, "Rescued exception during #{action}", **data)
+      begin
+        if context_object.respond_to?(:debug_log)
+          context_object.debug_log("⚠️ Rescue in #{component}: #{action}", level: level, data: data)
+        else
+          Aidp.logger.send(level, component, "Rescued exception during #{action}", **data)
+        end
+      rescue => logging_error
+        warn "[AIDP Rescue Logging Error] Failed to log rescue for #{component}:#{action} - #{error.class}: #{error.message} (logging error: #{logging_error.message})"
       end
-    rescue => logging_error
-      # Last resort: avoid raising from logging path - fall back to STDERR
-      warn "[AIDP Rescue Logging Error] Failed to log rescue for #{component}:#{action} - #{error.class}: #{error.message} (logging error: #{logging_error.message})"
     end
   end
 end

data/lib/aidp/setup/wizard.rb

@@ -30,6 +30,8 @@ module Aidp
 
       def run
         display_welcome
+        # Normalize any legacy or label-based model_family entries before prompting
+        normalize_existing_model_families!
         return @saved if skip_wizard?
 
         configure_providers
@@ -150,11 +152,30 @@ module Aidp
         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_choices.each do |display_name, provider_name|
             menu.choice display_name, provider_name
           end
         end
+        if ENV["AIDP_FALLBACK_DEBUG"] == "1"
+          prompt.say("[debug] raw multi_select fallback_selected=#{fallback_selected.inspect}")
+        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
+          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|
+                menu.choice display_name, provider_name
+              end
+              menu.choice "Skip", :skip
+            end
+            fallback_selected = [recovery_choice] unless recovery_choice == :skip
+          end
+        end
 
         # If user selected none but we had existing fallbacks, confirm removal
         if fallback_selected.empty? && existing_fallbacks.any?
@@ -167,10 +188,81 @@ module Aidp
         set([:harness, :fallback_providers], cleaned_fallbacks)
 
         # Auto-create minimal provider configs for fallbacks if missing
-        cleaned_fallbacks.each { |fp| ensure_provider_billing_config(fp) }
+        cleaned_fallbacks.each do |fp|
+          prompt.say("[debug] ensuring billing config for fallback '#{fp}'") if ENV["AIDP_FALLBACK_DEBUG"] == "1"
+          ensure_provider_billing_config(fp, force: true)
+        end
+
+        # Offer editing of existing provider configurations (primary + fallbacks)
+        # (editable will be recomputed after any additional fallback additions)
+        ([provider_choice] + cleaned_fallbacks).uniq.reject { |p| p == "custom" }
+
+        # Optional: allow adding more fallbacks iteratively
+        if prompt.yes?("Add another fallback provider?", default: false)
+          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
+          end
+        end
+        # Recompute editable after additions
+        editable = ([provider_choice] + cleaned_fallbacks).uniq.reject { |p| p == "custom" }
+        if editable.any? && prompt.yes?("Edit provider configuration details (billing/model family)?", default: false)
+          loop do
+            # Build dynamic mapping of display names -> internal names for edit menu
+            available_map = discover_available_providers # {display_name => internal_name}
+            display_name_for = available_map.invert # {internal_name => display_name}
+            to_edit = prompt.select("Select a provider to edit or add:") do |menu|
+              editable.each do |prov|
+                display_label = display_name_for.fetch(prov, prov.capitalize)
+                menu.choice display_label, prov
+              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 "Done", :done
+            end
+
+            case to_edit
+            when :done
+              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 }
+              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"
+                ensure_provider_billing_config(add_choice, force: true)
+                editable = ([provider_choice] + cleaned_fallbacks).uniq.reject { |p| p == "custom" }
+              end
+            else
+              edit_provider_configuration(to_edit)
+            end
+          end
+        end
 
         # Provide informational note (no secret handling stored)
         show_provider_info_note(provider_choice) unless provider_choice == "custom"
+
+        # Show summary of configured providers (replaces the earlier inline summary)
+        show_provider_summary(provider_choice, cleaned_fallbacks) unless provider_choice == "custom"
       end
 
       # Removed MCP configuration step (MCP now expected to be provider-specific if used)
@@ -262,13 +354,19 @@ module Aidp
         enabled = prompt.yes?("Enable coverage tracking?", default: existing.fetch(:enabled, false))
         return set([:work_loop, :coverage], {enabled: false}) unless enabled
 
-        tool = prompt.select("Which coverage tool do you use?", default: existing[:tool]) do |menu|
-          menu.choice "SimpleCov (Ruby)", "simplecov"
-          menu.choice "NYC/Istanbul (JavaScript)", "nyc"
-          menu.choice "Coverage.py (Python)", "coverage.py"
-          menu.choice "go test -cover (Go)", "go-cover"
-          menu.choice "Jest (JavaScript)", "jest"
-          menu.choice "Other", "other"
+        coverage_tool_choices = [
+          ["SimpleCov (Ruby)", "simplecov"],
+          ["NYC/Istanbul (JavaScript)", "nyc"],
+          ["Coverage.py (Python)", "coverage.py"],
+          ["go test -cover (Go)", "go-cover"],
+          ["Jest (JavaScript)", "jest"],
+          ["Other", "other"]
+        ]
+        coverage_tool_default = existing[:tool]
+        coverage_tool_default_label = coverage_tool_choices.find { |label, value| value == coverage_tool_default }&.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 }
         end
 
         run_command = ask_with_default("Coverage run command", existing[:run_command] || detect_coverage_command(tool))
@@ -300,10 +398,16 @@ module Aidp
         enabled = prompt.yes?("Enable interactive testing tools?", default: existing.fetch(:enabled, false))
         return set([:work_loop, :interactive_testing], {enabled: false}) unless enabled
 
-        app_type = prompt.select("What type of application are you testing?", default: existing[:app_type]) do |menu|
-          menu.choice "Web application", "web"
-          menu.choice "CLI application", "cli"
-          menu.choice "Desktop application", "desktop"
+        app_type_choices = [
+          ["Web application", "web"],
+          ["CLI application", "cli"],
+          ["Desktop application", "desktop"]
+        ]
+        app_type_default = existing[:app_type]
+        app_type_default_label = app_type_choices.find { |label, value| value == app_type_default }&.first
+
+        app_type = prompt.select("What type of application are you testing?", default: app_type_default_label) do |menu|
+          app_type_choices.each { |label, value| menu.choice label, value }
         end
 
         tools = {}
@@ -382,17 +486,21 @@ module Aidp
 
         # Detect VCS
         detected_vcs = detect_vcs_tool
+        vcs_choices = [
+          ["git", "git"],
+          ["svn", "svn"],
+          ["none (no VCS)", "none"]
+        ]
+        vcs_default = existing[:tool] || detected_vcs || "git"
+        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: existing[:tool] || detected_vcs) do |menu|
-            menu.choice "git", "git"
-            menu.choice "svn", "svn"
-            menu.choice "none (no VCS)", "none"
+          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
-          prompt.select("Which version control system do you use?", default: existing[:tool] || "git") do |menu|
-            menu.choice "git", "git"
-            menu.choice "svn", "svn"
-            menu.choice "none (no VCS)", "none"
+          prompt.select("Which version control system do you use?", default: vcs_default_label) do |menu|
+            vcs_choices.each { |label, value| menu.choice label, value }
           end
         end
 
@@ -400,10 +508,18 @@ module Aidp
 
         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.")
-        behavior = prompt.select("In copilot mode, should aidp:", default: existing[:behavior] || "nothing") do |menu|
-          menu.choice "Do nothing (manual git operations)", "nothing"
-          menu.choice "Stage changes only", "stage"
-          menu.choice "Stage and commit changes", "commit"
+
+        # Map value defaults to choice labels for TTY::Prompt validation
+        behavior_choices = [
+          ["Do nothing (manual git operations)", "nothing"],
+          ["Stage changes only", "stage"],
+          ["Stage and commit changes", "commit"]
+        ]
+        behavior_default = existing[:behavior] || "nothing"
+        behavior_default_label = behavior_choices.find { |label, value| value == behavior_default }&.first
+
+        behavior = prompt.select("In copilot mode, should aidp:", default: behavior_default_label) do |menu|
+          behavior_choices.each { |label, value| menu.choice label, value }
         end
 
         # Commit message configuration
@@ -437,10 +553,16 @@ module Aidp
 
         # Commit message style
         commit_style = if conventional_commits
-          prompt.select("Conventional commit style:", default: existing[:commit_style] || "default") do |menu|
-            menu.choice "Default (e.g., 'feat: add user authentication')", "default"
-            menu.choice "Angular (with scope: 'feat(auth): add login')", "angular"
-            menu.choice "Emoji (e.g., '✨ feat: add user authentication')", "emoji"
+          commit_style_choices = [
+            ["Default (e.g., 'feat: add user authentication')", "default"],
+            ["Angular (with scope: 'feat(auth): add login')", "angular"],
+            ["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
+
+          prompt.select("Conventional commit style:", default: commit_style_default_label) do |menu|
+            commit_style_choices.each { |label, value| menu.choice label, value }
           end
         else
           "default"
@@ -476,10 +598,16 @@ module Aidp
         )
 
         if auto_create_pr
-          pr_strategy = prompt.select("PR creation strategy:", default: existing[:pr_strategy] || "draft") do |menu|
-            menu.choice "Create as draft PR (safe, allows review before merge)", "draft"
-            menu.choice "Create as ready PR (immediately reviewable)", "ready"
-            menu.choice "Create and auto-merge (fully autonomous, requires approval rules)", "auto_merge"
+          pr_strategy_choices = [
+            ["Create as draft PR (safe, allows review before merge)", "draft"],
+            ["Create as ready PR (immediately reviewable)", "ready"],
+            ["Create and auto-merge (fully autonomous, requires approval rules)", "auto_merge"]
+          ]
+          pr_strategy_default = existing[:pr_strategy] || "draft"
+          pr_strategy_default_label = pr_strategy_choices.find { |label, value| value == pr_strategy_default }&.first
+
+          pr_strategy = prompt.select("PR creation strategy:", default: pr_strategy_default_label) do |menu|
+            pr_strategy_choices.each { |label, value| menu.choice label, value }
           end
 
           {
@@ -614,11 +742,16 @@ module Aidp
         prompt.say("-" * 40)
         existing = get([:logging]) || {}
 
-        # TODO: Add default back once TTY-Prompt default validation issue is resolved
-        log_level = prompt.select("Log level:") do |menu|
-          menu.choice "Debug", "debug"
-          menu.choice "Info", "info"
-          menu.choice "Error", "error"
+        log_level_choices = [
+          ["Debug", "debug"],
+          ["Info", "info"],
+          ["Error", "error"]
+        ]
+        log_level_default = existing[:level] || "info"
+        log_level_default_label = log_level_choices.find { |label, value| value == log_level_default }&.first
+
+        log_level = prompt.select("Log level:", default: log_level_default_label) do |menu|
+          log_level_choices.each { |label, value| menu.choice label, value }
         end
         json = prompt.yes?("Use JSON log format?", default: existing.fetch(:json, false))
         max_size = ask_with_default("Max log size (MB)", (existing[:max_size_mb] || 10).to_s) { |value| value.to_i }
@@ -897,44 +1030,132 @@ module Aidp
         prompt.say("Only the billing model (subscription vs usage_based) is recorded for fallback decisions.")
       end
 
+      def show_provider_summary(primary, fallbacks)
+        prompt.say("\n📋 Provider Configuration Summary:")
+        providers_config = get([:providers]) || {}
+
+        # Show primary
+        if primary && primary != "custom"
+          primary_cfg = providers_config[primary.to_sym] || {}
+          prompt.say("  ✓ Primary: #{primary} (#{primary_cfg[:type] || "not configured"}, #{primary_cfg[:model_family] || "auto"})")
+        end
+
+        # Show fallbacks
+        if fallbacks && !fallbacks.empty?
+          fallbacks.each do |fallback|
+            fallback_cfg = providers_config[fallback.to_sym] || {}
+            prompt.say("  ✓ Fallback: #{fallback} (#{fallback_cfg[:type] || "not configured"}, #{fallback_cfg[:model_family] || "auto"})")
+          end
+        end
+      end
+
       # Ensure a minimal billing configuration exists for a selected provider (no secrets)
-      def ensure_provider_billing_config(provider_name)
+      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]
 
-        if existing && existing[:type]
+        if existing && existing[:type] && !force
           prompt.say("  • Provider '#{provider_name}' already configured (type: #{existing[:type]})")
-          # Still ask for model family if not set
           unless existing[:model_family]
-            model_family = ask_model_family(provider_name, existing[:model_family])
+            model_family = ask_model_family(provider_name)
             set([:providers, provider_name.to_sym, :model_family], model_family)
           end
           return
         end
 
-        provider_type = ask_provider_billing_type(provider_name)
-        model_family = ask_model_family(provider_name)
-        set([:providers, provider_name.to_sym], {type: provider_type, model_family: model_family})
-        prompt.say("  • Added provider '#{provider_name}' with billing type '#{provider_type}' and model family '#{model_family}' (no secrets stored)")
+        provider_type = ask_provider_billing_type_with_default(provider_name, existing&.dig(:type))
+        model_family = ask_model_family(provider_name, existing&.dig(:model_family) || "auto")
+        merged = (existing || {}).merge(type: provider_type, model_family: model_family)
+        set([:providers, provider_name.to_sym], merged)
+        normalize_existing_model_families!
+        action_word = if existing
+          force ? "reconfigured" : "updated"
+        else
+          "added"
+        end
+        # Enhance messaging with display name when available
+        display_name = discover_available_providers.invert.fetch(provider_name, provider_name)
+        prompt.say("  • #{action_word.capitalize} provider '#{display_name}' (#{provider_name}) with billing type '#{provider_type}' and model family '#{model_family}'")
+      end
+
+      def edit_provider_configuration(provider_name)
+        existing = get([:providers, provider_name.to_sym]) || {}
+        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})
+        # Normalize immediately so tests relying on canonical value see 'claude' rather than label
+        normalize_existing_model_families!
+        prompt.ok("Updated '#{provider_name}' → type=#{new_type}, model_family=#{new_family}")
       end
 
       def ask_provider_billing_type(provider_name)
-        prompt.select("Billing model for #{provider_name}:") do |menu|
-          menu.choice "Subscription / flat-rate", "subscription"
-          # e.g. tools that expose an integrated model under a subscription cost
-          menu.choice "Usage-based / metered (API)", "usage_based"
-          menu.choice "Passthrough / local (no billing)", "passthrough"
+        ask_provider_billing_type_with_default(provider_name, nil)
+      end
+
+      BILLING_TYPE_CHOICES = [
+        ["Subscription / flat-rate", "subscription"],
+        ["Usage-based / metered (API)", "usage_based"],
+        ["Passthrough / local (no billing)", "passthrough"]
+      ].freeze
+
+      def ask_provider_billing_type_with_default(provider_name, default_value)
+        default_label = BILLING_TYPE_CHOICES.find { |label, value| value == default_value }&.first
+        suffix = default_value ? " (current: #{default_value})" : ""
+        prompt.select("Billing model for #{provider_name}:#{suffix}", default: default_label) do |menu|
+          BILLING_TYPE_CHOICES.each do |label, value|
+            menu.choice(label, value)
+          end
         end
       end
 
+      MODEL_FAMILY_CHOICES = [
+        ["Auto (let provider decide)", "auto"],
+        ["OpenAI o-series (reasoning models)", "openai_o"],
+        ["Anthropic Claude (balanced)", "claude"],
+        ["Mistral (European/open)", "mistral"],
+        ["Local LLM (self-hosted)", "local"]
+      ].freeze
+
       def ask_model_family(provider_name, default = "auto")
-        prompt.select("Preferred model family for #{provider_name}:", default: default) do |menu|
-          menu.choice "Auto (let provider decide)", "auto"
-          menu.choice "OpenAI o-series (reasoning models)", "openai_o"
-          menu.choice "Anthropic Claude (balanced)", "claude"
-          menu.choice "Mistral (European/open)", "mistral"
-          menu.choice "Local LLM (self-hosted)", "local"
+        # TTY::Prompt validates defaults against the displayed choice labels, not values.
+        # Map the value default (e.g. "auto") to its corresponding label.
+        default_label = MODEL_FAMILY_CHOICES.find { |label, value| value == default }&.first
+
+        prompt.select("Preferred model family for #{provider_name}:", default: default_label) do |menu|
+          MODEL_FAMILY_CHOICES.each do |label, value|
+            menu.choice(label, value)
+          end
+        end
+      end
+
+      # Canonicalization helpers ------------------------------------------------
+      MODEL_FAMILY_LABEL_TO_VALUE = MODEL_FAMILY_CHOICES.each_with_object({}) do |(label, value), h|
+        h[label] = value
+      end.freeze
+      MODEL_FAMILY_VALUES = MODEL_FAMILY_CHOICES.map { |(_, value)| value }.freeze
+
+      def normalize_model_family(value)
+        return "auto" if value.nil? || value.to_s.strip.empty?
+        # Already a canonical value
+        return value if MODEL_FAMILY_VALUES.include?(value)
+        # Try label -> value
+        mapped = MODEL_FAMILY_LABEL_TO_VALUE[value]
+        return mapped if mapped
+        # Unknown legacy entry -> fallback to auto
+        "auto"
+      end
+
+      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)
+          prov_cfg[:model_family] = normalized
         end
       end
 

data/lib/aidp/version.rb

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

data/lib/aidp/workflows/guided_agent.rb

@@ -18,7 +18,7 @@ module Aidp
 
       class ConversationError < StandardError; end
 
-      def initialize(project_dir, prompt: nil, use_enhanced_input: true)
+      def initialize(project_dir, prompt: nil, use_enhanced_input: true, verbose: false)
         @project_dir = project_dir
 
         # Use EnhancedInput with Reline for full readline-style key bindings
@@ -32,6 +32,9 @@ module Aidp
         @provider_manager = Aidp::Harness::ProviderManager.new(@config_manager, prompt: @prompt)
         @conversation_history = []
         @user_input = {}
+        @invalid_planning_responses = 0
+        @verbose = verbose
+        @debug_env = ENV["DEBUG"] == "1" || ENV["DEBUG"] == "2"
       end
 
       # Main entry point for guided workflow selection
@@ -79,6 +82,7 @@ module Aidp
           iteration += 1
           # Ask AI for next question based on current plan
           question_response = get_planning_questions(plan)
+          emit_verbose_iteration(plan, question_response)
 
           # Debug: show raw provider response and parsed result
           debug_log("Planning iteration #{iteration} provider response", level: :debug, data: {
@@ -131,9 +135,10 @@ module Aidp
         end
 
         response = call_provider_for_analysis(system_prompt, user_prompt)
-        parsed = parse_planning_response(response)
+        parsed = safe_parse_planning_response(response)
         # Attach raw response for debug
         parsed[:raw_response] = response
+        emit_verbose_raw_prompt(system_prompt, user_prompt, response)
         parsed
       end
 
@@ -239,16 +244,64 @@ module Aidp
 
           if classified && attempts < max_attempts
             display_message("⚠️  Provider '#{provider_name}' #{classified.tr("_", " ")} – attempting fallback...", type: :warning)
-            switched = @provider_manager.switch_provider_for_error(classified, stderr: message) if @provider_manager.respond_to?(:switch_provider_for_error)
-            if switched && switched != provider_name
-              display_message("↩️  Switched to provider '#{switched}'", type: :info)
-              retry
+            if @provider_manager.respond_to?(:switch_provider_for_error)
+              switched = @provider_manager.switch_provider_for_error(classified, stderr: message)
+              if switched && switched != provider_name
+                display_message("↩️  Switched to provider '#{switched}'", type: :info)
+                retry
+              elsif switched == provider_name
+                # ProviderManager could not advance; mark current as rate limited to encourage next attempt to move on.
+                Aidp.logger.debug("guided_agent", "provider_switch_noop", provider: provider_name, reason: classified)
+                if @provider_manager.respond_to?(:mark_rate_limited)
+                  @provider_manager.mark_rate_limited(provider_name)
+                  next_provider = @provider_manager.switch_provider("rate_limit_forced", previous_error: message)
+                  if next_provider && next_provider != provider_name
+                    display_message("↩️  Switched to provider '#{next_provider}' (forced)", type: :info)
+                    retry
+                  end
+                end
+              end
             end
           end
           raise
         end
       end
 
+      # Verbose output helpers
+      def emit_verbose_raw_prompt(system_prompt, user_prompt, raw_response)
+        return unless @verbose || @debug_env
+        if @verbose
+          display_message("\n--- Prompt Sent (Planning) ---", type: :muted)
+          display_message(system_prompt.strip, type: :muted)
+          display_message(user_prompt.strip, type: :muted)
+          display_message("--- Raw Provider Response ---", type: :muted)
+          display_message(raw_response.to_s.strip, type: :muted)
+          display_message("------------------------------\n", type: :muted)
+        elsif @debug_env
+          Aidp.logger.debug("guided_agent", "planning_prompt", system: system_prompt.strip, user: user_prompt.strip)
+          Aidp.logger.debug("guided_agent", "planning_raw_response", raw: raw_response.to_s.strip)
+        end
+      rescue => e
+        Aidp.logger.warn("guided_agent", "Failed verbose prompt emit", error: e.message)
+      end
+
+      def emit_verbose_iteration(plan, question_response)
+        return unless @verbose || @debug_env
+        summary = {complete: question_response[:complete], questions: question_response[:questions], reasoning: question_response[:reasoning], error: question_response[:error]}
+        if @verbose
+          display_message("\n=== Planning Iteration Summary ===", type: :info)
+          display_message("Questions: #{(summary[:questions] || []).join(" | ")}", type: :info)
+          display_message("Complete? #{summary[:complete]}", type: :info)
+          display_message("Reasoning: #{summary[:reasoning]}", type: :muted) if summary[:reasoning]
+          display_message("Error: #{summary[:error]}", type: :warning) if summary[:error]
+          display_message("=================================", type: :info)
+        elsif @debug_env
+          Aidp.logger.debug("guided_agent", "iteration_summary", summary: summary, plan_progress_keys: plan.keys)
+        end
+      rescue => e
+        Aidp.logger.warn("guided_agent", "Failed verbose iteration emit", error: e.message)
+      end
+
       def validate_provider_configuration!
         configured = @provider_manager.configured_providers
         if configured.nil? || configured.empty?
@@ -307,20 +360,53 @@ module Aidp
         json_match = response_text.match(/```json\s*(\{.*?\})\s*```/m) ||
           response_text.match(/(\{.*\})/m)
 
-        unless json_match
-          return {complete: false, questions: ["Could you tell me more about your requirements?"]}
-        end
-
+        return {error: :invalid_format} unless json_match
         JSON.parse(json_match[1], symbolize_names: true)
       rescue JSON::ParserError
-        {complete: false, questions: ["Could you tell me more about your requirements?"]}
+        {error: :invalid_format}
+      end
+
+      # Provides structured fallback sequence when provider keeps returning invalid planning JSON.
+      # After exceeding sequence length, switches to manual entry question.
+      def safe_parse_planning_response(response_text)
+        parsed = parse_planning_response(response_text)
+        return parsed unless parsed.is_a?(Hash) && parsed[:error] == :invalid_format
+
+        @invalid_planning_responses += 1
+        fallback_sequence = [
+          "Provide scope (key features) and primary users.",
+          "List 3-5 key functional requirements and any technical constraints.",
+          "Supply any non-functional requirements (performance/security) or type 'skip'."
+        ]
+
+        if @invalid_planning_responses <= fallback_sequence.size
+          {complete: false, questions: [fallback_sequence[@invalid_planning_responses - 1]], reasoning: "Fallback due to invalid provider response (format)", error: :fallback}
+        else
+          display_message("[ERROR] Provider returned invalid planning JSON #{@invalid_planning_responses} times. Enter combined plan details manually.", type: :error)
+          {complete: false, questions: ["Enter plan details manually (features; users; requirements; constraints) or type 'skip'"], reasoning: "Manual recovery mode", error: :manual_recovery}
+        end
       end
 
       def update_plan_from_answer(plan, question, answer)
         # Simple heuristic-based plan updates
         # In a more sophisticated implementation, use AI to categorize answers
 
-        if question.downcase.include?("scope") || question.downcase.include?("include")
+        # IMPORTANT: Check manual recovery sentinel prompt first so it isn't misclassified
+        # by broader keyword heuristics (e.g., it contains the word 'users').
+        if question.start_with?("Enter plan details manually")
+          unless answer.strip.downcase == "skip"
+            parts = answer.split(/;|\|/).map(&:strip).reject(&:empty?)
+            features, users, requirements, constraints = parts
+            plan[:scope][:included] ||= []
+            plan[:scope][:included] << features if features
+            plan[:users][:personas] ||= []
+            plan[:users][:personas] << users if users
+            plan[:requirements][:functional] ||= []
+            plan[:requirements][:functional] << requirements if requirements
+            plan[:constraints][:technical] ||= []
+            plan[:constraints][:technical] << constraints if constraints
+          end
+        elsif question.downcase.include?("scope") || question.downcase.include?("include")
           plan[:scope][:included] ||= []
           plan[:scope][:included] << answer
         elsif question.downcase.include?("user") || question.downcase.include?("who")
@@ -338,7 +424,6 @@ module Aidp
         elsif question.downcase.include?("complete") || question.downcase.include?("done") || question.downcase.include?("success")
           plan[:completion_criteria] << answer
         else
-          # General information
           plan[:additional_context] ||= []
           plan[:additional_context] << {question: question, answer: answer}
         end

data/lib/aidp.rb

@@ -7,6 +7,7 @@ require_relative "aidp/core_ext/class_attribute"
 require_relative "aidp/version"
 require_relative "aidp/config"
 require_relative "aidp/util"
+require_relative "aidp/rescue_logging"
 require_relative "aidp/message_display"
 require_relative "aidp/concurrency"
 require_relative "aidp/setup/wizard"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: aidp
 version: !ruby/object:Gem::Version
-  version: 0.19.1
+  version: 0.20.0
 platform: ruby
 authors:
 - Bart Agapinan