aidp 0.33.0 → 0.34.1

data/lib/aidp/cli.rb

@@ -2,6 +2,7 @@
 
 require "optparse"
 require "tty-prompt"
+require "stringio"
 require_relative "harness/runner"
 require_relative "execute/workflow_selector"
 require_relative "harness/ui/enhanced_tui"
@@ -46,6 +47,18 @@ module Aidp
         options = parse_options(args)
         self.last_options = options
 
+        # Validate incompatible options
+        if options[:quiet] && options[:verbose]
+          display_message("❌ --quiet and --verbose are mutually exclusive", type: :error)
+          return 1
+        end
+
+        # --quiet is incompatible with default interactive mode (no subcommand)
+        if options[:quiet] && !options[:help] && !options[:version]
+          display_message("❌ --quiet is not compatible with interactive mode. Use with 'watch' command instead.", type: :error)
+          return 1
+        end
+
         if options[:help]
           display_message(options[:parser].to_s, type: :info)
           return 0
@@ -56,6 +69,12 @@ module Aidp
           return 0
         end
 
+        # Undocumented: Launch test mode for CI/CD validation
+        # Initializes app components and exits cleanly without running full workflows
+        if options[:launch_test]
+          return run_launch_test(:interactive)
+        end
+
         # Initialize logger from aidp.yml config
         # Priority: ENV variable > aidp.yml > default (info)
         setup_logging(Dir.pwd)
@@ -147,6 +166,117 @@ module Aidp
         Aidp.logger.warn("cli", "Failed to load logging config, using defaults", error: e.message)
       end
 
+      # Quick exit launch test for CI/CD validation
+      # Initializes app components and exits cleanly without running full workflows
+      def run_launch_test(mode)
+        Aidp.log_debug("cli", "launch_test_started", mode: mode)
+        display_message("Aidp version #{Aidp::VERSION}", type: :info)
+
+        # Initialize logging
+        setup_logging(Dir.pwd)
+
+        case mode
+        when :interactive
+          run_interactive_launch_test
+        when :watch
+          run_watch_launch_test
+        else
+          display_message("Unknown launch test mode: #{mode}", type: :error)
+          return 1
+        end
+
+        Aidp.log_info("cli", "launch_test_completed", mode: mode)
+        display_message("Launch test completed successfully", type: :success)
+        0
+      rescue => e
+        log_rescue(e, component: "cli", action: "launch_test", fallback: 1, mode: mode)
+        display_message("Launch test failed: #{e.message}", type: :error)
+        1
+      end
+
+      def run_interactive_launch_test
+        Aidp.log_debug("cli", "interactive_launch_test", step: "init_tui")
+
+        # Initialize TUI components (validates they can be created)
+        tui = Aidp::Harness::UI::EnhancedTUI.new
+        Aidp.log_debug("cli", "interactive_launch_test", step: "tui_created")
+
+        # Initialize workflow selector (validates harness loading)
+        _selector = Aidp::Harness::UI::EnhancedWorkflowSelector.new(tui, project_dir: Dir.pwd)
+        Aidp.log_debug("cli", "interactive_launch_test", step: "workflow_selector_created")
+
+        # Initialize config manager (validates config loading)
+        _config_manager = Aidp::Harness::ConfigManager.new(Dir.pwd)
+        Aidp.log_debug("cli", "interactive_launch_test", step: "config_manager_created")
+
+        # Validate EnhancedRunner can be instantiated (orchestrates workflows)
+        Aidp.log_debug("cli", "interactive_launch_test", step: "validate_enhanced_runner")
+        require_relative "harness/enhanced_runner"
+        _runner = Aidp::Harness::EnhancedRunner.new(Dir.pwd, :execute, {mode: :execute})
+        Aidp.log_debug("cli", "interactive_launch_test", step: "enhanced_runner_created")
+        display_message("Enhanced Runner instantiation verified", type: :info)
+
+        # Validate FirstRunWizard can be loaded (critical for setup)
+        Aidp.log_debug("cli", "interactive_launch_test", step: "validate_first_run_wizard")
+        require_relative "cli/first_run_wizard"
+        # Don't instantiate to avoid triggering actual wizard
+        Aidp.log_debug("cli", "interactive_launch_test", step: "first_run_wizard_loaded")
+        display_message("First Run Wizard loaded", type: :info)
+
+        # Validate Init::Runner can be instantiated (init command)
+        Aidp.log_debug("cli", "interactive_launch_test", step: "validate_init_runner")
+        require_relative "init/runner"
+        mock_prompt = TTY::Prompt.new(input: StringIO.new, output: StringIO.new)
+        _init_runner = Aidp::Init::Runner.new(Dir.pwd, prompt: mock_prompt, options: {dry_run: true})
+        Aidp.log_debug("cli", "interactive_launch_test", step: "init_runner_created")
+        display_message("Init Runner instantiation verified", type: :info)
+
+        display_message("Interactive mode initialization verified", type: :info)
+      ensure
+        tui&.restore_screen
+      end
+
+      def run_watch_launch_test
+        Aidp.log_debug("cli", "watch_launch_test", step: "init_config")
+
+        # Load config to validate configuration parsing
+        config_manager = Aidp::Harness::ConfigManager.new(Dir.pwd)
+        config = config_manager.config || {}
+        watch_config = config[:watch] || config["watch"] || {}
+
+        Aidp.log_debug("cli", "watch_launch_test", step: "config_loaded", has_watch_config: !watch_config.empty?)
+
+        display_message("Watch mode configuration verified", type: :info)
+
+        # Instantiate Runner to validate all dependencies are loadable
+        # Use mock GitHub client to avoid external API calls
+        Aidp.log_debug("cli", "watch_launch_test", step: "validate_runner")
+        mock_gh_client = Class.new do
+          def available?
+            false
+          end
+        end.new
+
+        Aidp::Watch::Runner.new(
+          issues_url: "https://github.com/test/test/issues",
+          interval: 30,
+          once: true,
+          gh_available: mock_gh_client,
+          prompt: TTY::Prompt.new(input: StringIO.new, output: StringIO.new)
+        )
+
+        Aidp.log_debug("cli", "watch_launch_test", step: "runner_instantiated")
+        display_message("Watch mode Runner instantiation verified", type: :info)
+
+        # Validate key Watch mode dependencies are loadable
+        Aidp.log_debug("cli", "watch_launch_test", step: "validate_watch_dependencies")
+        require_relative "watch/plan_generator"
+        require_relative "auto_update"
+        require_relative "worktree"
+        Aidp.log_debug("cli", "watch_launch_test", step: "watch_dependencies_loaded")
+        display_message("Watch mode dependencies loaded", type: :info)
+      end
+
       def parse_options(args)
         options = {}
 
@@ -217,6 +347,9 @@ module Aidp
           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.on("--quiet", "Suppress non-critical output (incompatible with --verbose and --interactive)") { options[:quiet] = true }
+          # Undocumented: Quick exit launch test for CI/CD validation
+          opts.on("--launch-test", nil) { options[:launch_test] = true }
 
           opts.separator ""
           opts.separator "Examples:"
@@ -257,7 +390,7 @@ module Aidp
       # Determine if the invocation is a subcommand style call
       def subcommand?(args)
         return false if args.nil? || args.empty?
-        %w[status jobs kb harness providers checkpoint mcp issue config init watch ws work skill settings models tools].include?(args.first)
+        %w[status jobs kb harness providers checkpoint eval mcp issue config init watch ws work skill settings models tools security].include?(args.first)
       end
 
       def run_subcommand(args)
@@ -269,6 +402,7 @@ module Aidp
         when "harness" then run_harness_command(args)
         when "providers" then run_providers_command(args)
         when "checkpoint" then run_checkpoint_command(args)
+        when "eval" then run_eval_command(args)
         when "mcp" then run_mcp_command(args)
         when "issue" then run_issue_command(args)
         when "config" then run_config_command(args)
@@ -281,6 +415,7 @@ module Aidp
         when "settings" then run_settings_command(args)
         when "models" then run_models_command(args)
         when "tools" then run_tools_command(args)
+        when "security" then run_security_command(args)
         else
           display_message("Unknown command: #{cmd}", type: :info)
           return 1
@@ -423,6 +558,13 @@ module Aidp
         command.run(args)
       end
 
+      def run_eval_command(args)
+        # Delegate to EvalCommand
+        require_relative "cli/eval_command"
+        command = EvalCommand.new(prompt: create_prompt)
+        command.run(args)
+      end
+
       def format_time_ago_simple(seconds)
         if seconds < 60
           "#{seconds.to_i}s ago"
@@ -633,6 +775,12 @@ module Aidp
         tools_cmd.run(args)
       end
 
+      def run_security_command(args)
+        require_relative "cli/security_command"
+        security_cmd = Aidp::CLI::SecurityCommand.new(project_dir: Dir.pwd, prompt: create_prompt)
+        security_cmd.run(args)
+      end
+
       def run_issue_command(args)
         require_relative "cli/issue_importer"
 
@@ -826,7 +974,7 @@ module Aidp
 
       def run_watch_command(args)
         if args.empty?
-          display_message("Usage: aidp watch <issues_url> [--interval SECONDS] [--provider NAME] [--once] [--no-workstreams] [--force] [--verbose]", type: :info)
+          display_message("Usage: aidp watch <issues_url> [--interval SECONDS] [--provider NAME] [--once] [--no-workstreams] [--force] [--verbose] [--quiet]", type: :info)
           return
         end
 
@@ -837,6 +985,8 @@ module Aidp
         use_workstreams = true # Default to using workstreams
         force = false
         verbose = false
+        quiet = false
+        launch_test = false
 
         until args.empty?
           token = args.shift
@@ -854,11 +1004,27 @@ module Aidp
             force = true
           when "--verbose"
             verbose = true
+          when "--quiet"
+            quiet = true
+          when "--launch-test"
+            launch_test = true
           else
             display_message("⚠️  Unknown watch option: #{token}", type: :warn)
           end
         end
 
+        # Validate incompatible options
+        if quiet && verbose
+          display_message("❌ --quiet and --verbose are mutually exclusive", type: :error)
+          return 1
+        end
+
+        # Undocumented: Launch test mode for CI/CD validation
+        # Exits after validating watch mode initialization
+        if launch_test
+          return run_launch_test(:watch)
+        end
+
         # Initialize logger for watch mode
         setup_logging(Dir.pwd)
 
@@ -877,7 +1043,8 @@ module Aidp
           prompt: create_prompt,
           safety_config: watch_config,
           force: force,
-          verbose: verbose
+          verbose: verbose,
+          quiet: quiet
         )
         runner.start
       rescue ArgumentError => e

data/lib/aidp/concurrency/exec.rb

@@ -21,6 +21,9 @@ module Aidp
     #   Exec.shutdown_all
     module Exec
       class << self
+        # Expose for testability - reset pool cache between tests
+        attr_writer :pools, :default_pool
+
         # Get or create a named thread pool.
         #
         # Pools are cached by name. Calling this method multiple times with the

data/lib/aidp/config.rb

@@ -170,6 +170,64 @@ module Aidp
           method: "zfc_automatic",
           allow_parallel: true
         }
+      },
+      evaluations: {
+        enabled: true,
+        prompt_after_work_loop: false,
+        capture_full_context: true,
+        directory: ".aidp/evaluations"
+      },
+      security: {
+        rule_of_two: {
+          enabled: true,
+          policy: "strict"  # strict or relaxed
+        },
+        secrets_proxy: {
+          enabled: true,
+          token_ttl: 300  # seconds
+        },
+        watch_mode: {
+          max_retry_attempts: 3,
+          fail_forward_enabled: true,
+          needs_input_label: "aidp-needs-input"
+        }
+      },
+      watch: {
+        enabled: false,
+        polling_interval: 30,
+        labels: {
+          plan_trigger: "aidp-plan",
+          build_trigger: "aidp-build",
+          review_trigger: "aidp-review",
+          fix_ci_trigger: "aidp-fix-ci",
+          change_request_trigger: "aidp-request-changes",
+          auto_trigger: "aidp-auto",
+          parent_pr: "aidp-parent-pr",
+          sub_pr: "aidp-sub-pr"
+        },
+        projects: {
+          enabled: false,
+          default_project_id: nil,
+          field_mappings: {
+            status: "Status",
+            priority: "Priority",
+            skills: "Skills",
+            personas: "Personas",
+            blocking: "Blocking"
+          },
+          auto_create_fields: true,
+          sync_interval: 60,
+          default_status_values: ["Backlog", "Todo", "In Progress", "In Review", "Done"],
+          default_priority_values: ["Low", "Medium", "High", "Critical"]
+        },
+        auto_merge: {
+          enabled: true,
+          sub_issue_prs_only: true,
+          require_ci_success: true,
+          require_reviews: 0,
+          merge_method: "squash",
+          delete_branch: true
+        }
       }
     }.freeze
 
@@ -287,6 +345,38 @@ module Aidp
       symbolize_keys(tool_metadata_section)
     end
 
+    # Get evaluations configuration
+    def self.evaluations_config(project_dir = Dir.pwd)
+      config = load_harness_config(project_dir)
+      evaluations_section = config[:evaluations] || config["evaluations"] || {}
+
+      # Convert string keys to symbols for consistency
+      symbolize_keys(evaluations_section)
+    end
+
+    # Get security configuration
+    def self.security_config(project_dir = Dir.pwd)
+      config = load_harness_config(project_dir)
+      security_section = config[:security] || config["security"] || {}
+
+      # Convert string keys to symbols for consistency
+      symbolize_keys(security_section)
+    end
+
+    # Check if Rule of Two enforcement is enabled
+    def self.rule_of_two_enabled?(project_dir = Dir.pwd)
+      sec_config = security_config(project_dir)
+      rule_of_two = sec_config[:rule_of_two] || {}
+      rule_of_two.fetch(:enabled, true)
+    end
+
+    # Check if Secrets Proxy is enabled
+    def self.secrets_proxy_enabled?(project_dir = Dir.pwd)
+      sec_config = security_config(project_dir)
+      proxy_config = sec_config[:secrets_proxy] || {}
+      proxy_config.fetch(:enabled, true)
+    end
+
     # Check if configuration file exists
     def self.config_exists?(project_dir = Dir.pwd)
       ConfigPaths.config_exists?(project_dir)
@@ -393,9 +483,32 @@ module Aidp
         merged[:waterfall] = merged[:waterfall].merge(symbolize_keys(waterfall_section))
       end
 
+      # Deep merge evaluations config
+      if config[:evaluations] || config["evaluations"]
+        evaluations_section = config[:evaluations] || config["evaluations"]
+        merged[:evaluations] = merged[:evaluations].merge(symbolize_keys(evaluations_section))
+      end
+
+      # Deep merge security config
+      if config[:security] || config["security"]
+        security_section = config[:security] || config["security"]
+        merged[:security] = deep_merge_hash(merged[:security], symbolize_keys(security_section))
+      end
+
       merged
     end
 
+    # Deep merge for nested hashes (preserves nested defaults)
+    private_class_method def self.deep_merge_hash(base, override)
+      base.merge(override) do |_key, base_val, override_val|
+        if base_val.is_a?(Hash) && override_val.is_a?(Hash)
+          deep_merge_hash(base_val, override_val)
+        else
+          override_val
+        end
+      end
+    end
+
     private_class_method def self.symbolize_keys(hash)
       return hash unless hash.is_a?(Hash)
 

data/lib/aidp/config_paths.rb

@@ -23,6 +23,14 @@ module Aidp
     def self.model_cache_dir(project_dir = Dir.pwd) = File.join(aidp_dir(project_dir), "model_cache")
     def self.work_loop_dir(project_dir = Dir.pwd) = File.join(aidp_dir(project_dir), "work_loop")
     def self.logs_dir(project_dir = Dir.pwd) = File.join(aidp_dir(project_dir), "logs")
+    def self.evaluations_dir(project_dir = Dir.pwd) = File.join(aidp_dir(project_dir), "evaluations")
+    def self.evaluations_index_file(project_dir = Dir.pwd) = File.join(evaluations_dir(project_dir), "index.json")
+
+    # Security module paths
+    def self.security_dir(project_dir = Dir.pwd) = File.join(aidp_dir(project_dir), "security")
+    def self.secrets_registry_file(project_dir = Dir.pwd) = File.join(security_dir(project_dir), "secrets_registry.json")
+    def self.security_audit_log_file(project_dir = Dir.pwd) = File.join(security_dir(project_dir), "audit.jsonl")
+    def self.mcp_risk_profile_file(project_dir = Dir.pwd) = File.join(security_dir(project_dir), "mcp_risk_profile.yml")
 
     def self.config_exists?(project_dir = Dir.pwd)
       File.exist?(config_file(project_dir))
@@ -67,5 +75,17 @@ module Aidp
       FileUtils.mkdir_p(dir) unless Dir.exist?(dir)
       dir
     end
+
+    def self.ensure_evaluations_dir(project_dir = Dir.pwd)
+      dir = evaluations_dir(project_dir)
+      FileUtils.mkdir_p(dir) unless Dir.exist?(dir)
+      dir
+    end
+
+    def self.ensure_security_dir(project_dir = Dir.pwd)
+      dir = security_dir(project_dir)
+      FileUtils.mkdir_p(dir) unless Dir.exist?(dir)
+      dir
+    end
   end
 end

data/lib/aidp/daemon/runner.rb

@@ -10,15 +10,19 @@ module Aidp
     # Main daemon runner for background mode execution
     # Manages work loops, watch mode, and IPC communication
     class Runner
-      def initialize(project_dir, config, options = {}, process_manager: nil)
+      # Allow reading/writing @running for testability
+      attr_accessor :running
+
+      def initialize(project_dir, config, options = {}, process_manager: nil,
+        work_loop_runner: nil, watch_runner: nil, ipc_server: nil)
         @project_dir = project_dir
         @config = config
         @options = options
         @process_manager = process_manager || ProcessManager.new(project_dir)
         @running = false
-        @work_loop_runner = nil
-        @watch_runner = nil
-        @ipc_server = nil
+        @work_loop_runner = work_loop_runner
+        @watch_runner = watch_runner
+        @ipc_server = ipc_server
       end
 
       # Start daemon in background

data/lib/aidp/errors.rb

@@ -1,5 +1,8 @@
 # frozen_string_literal: true
 
+require "time"
+require "json"
+
 module Aidp
   # Error classes for AIDP
   module Errors
@@ -8,5 +11,136 @@ module Aidp
     class ValidationError < StandardError; end
     class StateError < StandardError; end
     class UserError < StandardError; end
+
+    # Exception raised when a Rule of Two policy violation occurs
+    # Contains detailed context about the violation for logging and debugging
+    class PolicyViolation < StandardError
+      attr_reader :flag, :source, :current_state, :suggested_mitigations
+
+      def initialize(flag:, source:, current_state:, message: nil)
+        @flag = flag
+        @source = source
+        @current_state = current_state
+        @suggested_mitigations = build_suggested_mitigations(flag, current_state)
+
+        super(message || default_message)
+      end
+
+      # Export violation details for logging
+      def to_h
+        {
+          type: "rule_of_two_violation",
+          flag_attempted: @flag,
+          source: @source,
+          current_state: @current_state,
+          suggested_mitigations: @suggested_mitigations,
+          timestamp: Time.now.iso8601
+        }
+      end
+
+      # JSON representation for structured logging
+      def to_json(*args)
+        to_h.to_json(*args)
+      end
+
+      private
+
+      def default_message
+        "Rule of Two violation: Cannot enable '#{@flag}' - would create lethal trifecta"
+      end
+
+      # Build contextual mitigation suggestions based on which flags are enabled
+      def build_suggested_mitigations(flag, state)
+        mitigations = []
+
+        # Suggest based on which flags would form the trifecta
+        if state[:untrusted_input]
+          mitigations << {
+            action: "sanitize_input",
+            description: "Sanitize the untrusted input before processing to remove the untrusted_input flag",
+            command: "aidp security sanitize-input --source <source>"
+          }
+        end
+
+        if state[:private_data]
+          mitigations << {
+            action: "use_secrets_proxy",
+            description: "Route credential access through the Secrets Proxy to get short-lived tokens",
+            command: "aidp security proxy-request --secret <name>"
+          }
+        end
+
+        if state[:egress]
+          mitigations << {
+            action: "disable_egress",
+            description: "Disable external communication for this operation",
+            command: "Use deterministic unit or sandbox the operation"
+          }
+        end
+
+        # Add flag-specific suggestion for the attempted flag
+        case flag
+        when :untrusted_input
+          mitigations << {
+            action: "validate_source",
+            description: "Validate and trust the input source (e.g., from trusted author allowlist)",
+            command: "Add author to watch.safety.author_allowlist in aidp.yml"
+          }
+        when :private_data
+          mitigations << {
+            action: "scope_credentials",
+            description: "Use capability-scoped tokens instead of full credentials",
+            command: "aidp security register-secret --scoped"
+          }
+        when :egress
+          mitigations << {
+            action: "queue_for_approval",
+            description: "Queue the operation for manual execution outside the agent context",
+            command: "Operation will be logged for manual review"
+          }
+        end
+
+        mitigations.uniq { |m| m[:action] }
+      end
+    end
+
+    # Exception raised when secrets proxy cannot fulfill a request
+    class SecretsProxyError < StandardError
+      attr_reader :secret_name, :reason
+
+      def initialize(secret_name:, reason:)
+        @secret_name = secret_name
+        @reason = reason
+        super("Secrets proxy error for '#{secret_name}': #{reason}")
+      end
+    end
+
+    # Exception raised when attempting to access an unregistered secret
+    class UnregisteredSecretError < SecretsProxyError
+      def initialize(secret_name:)
+        super(
+          secret_name: secret_name,
+          reason: "Secret not registered. Use 'aidp security register-secret #{secret_name}' to register."
+        )
+      end
+    end
+
+    # Exception raised when a token has expired
+    class TokenExpiredError < SecretsProxyError
+      def initialize(secret_name:, expired_at:)
+        super(
+          secret_name: secret_name,
+          reason: "Token expired at #{expired_at}. Request a new token via the secrets proxy."
+        )
+      end
+    end
+  end
+
+  # Convenience aliases in Security module for backward compatibility
+  module Security
+    PolicyViolation = Aidp::Errors::PolicyViolation
+    SecretsProxyError = Aidp::Errors::SecretsProxyError
+    UnregisteredSecretError = Aidp::Errors::UnregisteredSecretError
+    TokenExpiredError = Aidp::Errors::TokenExpiredError
   end
 end