aidp 0.32.0 → 0.34.0

data/lib/aidp/cli.rb

@@ -2,12 +2,14 @@
 
 require "optparse"
 require "tty-prompt"
+require "stringio"
 require_relative "harness/runner"
 require_relative "execute/workflow_selector"
 require_relative "harness/ui/enhanced_tui"
 require_relative "harness/ui/enhanced_workflow_selector"
 require_relative "harness/enhanced_runner"
 require_relative "cli/first_run_wizard"
+require_relative "cli/issue_importer"
 require_relative "rescue_logging"
 require_relative "concurrency"
 
@@ -45,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
@@ -55,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)
@@ -146,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 = {}
 
@@ -216,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:"
@@ -256,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)
@@ -268,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)
@@ -280,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
@@ -422,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"
@@ -632,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"
 
@@ -669,7 +818,7 @@ module Aidp
             return
           end
 
-          importer = IssueImporter.new
+          importer = Aidp::IssueImporter.new
           issue_data = importer.import_issue(identifier)
 
           if issue_data
@@ -825,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
 
@@ -836,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
@@ -853,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)
 
@@ -876,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/comment_consolidator.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module Aidp
+  # Consolidates comments for GitHub issues and PRs by category
+  class CommentConsolidator
+    CATEGORY_HEADERS = {
+      progress: "## 🔄 Progress Report",
+      exceptions: "## 🚨 Exceptions and Errors",
+      completion: "## ✅ Completion Summary"
+    }
+
+    # @param repository_client [Aidp::Watch::RepositoryClient] GitHub repository client
+    # @param number [Integer] Issue or PR number
+    def initialize(repository_client:, number:)
+      @client = repository_client
+      @number = number
+    end
+
+    # Search for an existing comment by its category header
+    # @param category [Symbol] Comment category (:progress, :exceptions, :completion)
+    # @return [Hash, nil] Existing comment or nil if not found
+    def find_category_comment(category)
+      Aidp.log_debug("comment_consolidator", "searching_category_comment",
+        number: @number, category: category)
+
+      header = CATEGORY_HEADERS[category]
+      raise ArgumentError, "Invalid category: #{category}" unless header
+
+      comment = @client.find_comment(@number, header)
+      Aidp.log_debug("comment_consolidator", "find_category_comment_result",
+        found: !comment.nil?)
+      comment
+    end
+
+    # Update an existing category comment or create a new one
+    # @param category [Symbol] Comment category (:progress, :exceptions, :completion)
+    # @param new_content [String] New content to add to the comment
+    # @param append [Boolean] Whether to append or replace existing content
+    # @return [String] Result of comment operation (comment ID or response body)
+    def consolidate_comment(category:, new_content:, append: true)
+      Aidp.log_debug("comment_consolidator", "consolidating_comment", number: @number, category: category, append: append)
+
+      header = CATEGORY_HEADERS[category]
+      raise ArgumentError, "Invalid category: #{category}" unless header
+
+      existing_comment = find_category_comment(category)
+
+      content = if existing_comment && append
+        # Append new content with timestamp
+        existing_body = existing_comment[:body]
+        updated_body = if existing_body.include?(header)
+          existing_body.lines.first(1).join +
+            "### #{Time.now.strftime("%Y-%m-%d %H:%M:%S")}\n\n" +
+            new_content + "\n\n" +
+            existing_body.lines[1..]&.join
+        else
+          # Reconstruct comment if header is missing
+          "#{header}\n\n### #{Time.now.strftime("%Y-%m-%d %H:%M:%S")}\n\n" +
+            new_content + "\n\n" +
+            existing_body
+        end
+        updated_body
+      else
+        # Create new or replace content
+        "#{header}\n\n### #{Time.now.strftime("%Y-%m-%d %H:%M:%S")}\n\n" + new_content
+      end
+
+      # Update or create comment
+      if existing_comment
+        Aidp.log_debug("comment_consolidator", "updating_existing_comment", comment_id: existing_comment[:id])
+        @client.update_comment(existing_comment[:id], content)
+      else
+        Aidp.log_debug("comment_consolidator", "creating_new_comment")
+        @client.post_comment(@number, content)
+      end
+    end
+  end
+end

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/concurrency.rb

@@ -1,9 +1,6 @@
 # frozen_string_literal: true
 
 require "concurrent-ruby"
-require_relative "concurrency/wait"
-require_relative "concurrency/backoff"
-require_relative "concurrency/exec"
 
 module Aidp
   # Concurrency utilities for deterministic waiting, retry/backoff, and executor management.

data/lib/aidp/config.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 require "yaml"
-require_relative "config/paths"
 
 module Aidp
   # Configuration management for both execute and analyze modes
@@ -171,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
 
@@ -288,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)
@@ -394,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

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+require "fileutils"
+
+module Aidp
+  # Centralized path management for all AIDP internal files
+  # Ensures consistent file locations and prevents path-related bugs
+  module ConfigPaths
+    def self.aidp_dir(project_dir = Dir.pwd) = File.join(project_dir, ".aidp")
+    def self.config_file(project_dir = Dir.pwd) = File.join(aidp_dir(project_dir), "aidp.yml")
+    def self.config_dir(project_dir = Dir.pwd) = aidp_dir(project_dir)
+    def self.progress_dir(project_dir = Dir.pwd) = File.join(aidp_dir(project_dir), "progress")
+    def self.execute_progress_file(project_dir = Dir.pwd) = File.join(progress_dir(project_dir), "execute.yml")
+    def self.analyze_progress_file(project_dir = Dir.pwd) = File.join(progress_dir(project_dir), "analyze.yml")
+    def self.harness_state_dir(project_dir = Dir.pwd) = File.join(aidp_dir(project_dir), "harness")
+    def self.harness_state_file(mode, project_dir = Dir.pwd) = File.join(harness_state_dir(project_dir), "#{mode}_state.json")
+    def self.providers_dir(project_dir = Dir.pwd) = File.join(aidp_dir(project_dir), "providers")
+    def self.provider_info_file(provider_name, project_dir = Dir.pwd) = File.join(providers_dir(project_dir), "#{provider_name}_info.yml")
+    def self.jobs_dir(project_dir = Dir.pwd) = File.join(aidp_dir(project_dir), "jobs")
+    def self.checkpoint_file(project_dir = Dir.pwd) = File.join(aidp_dir(project_dir), "checkpoint.yml")
+    def self.checkpoint_history_file(project_dir = Dir.pwd) = File.join(aidp_dir(project_dir), "checkpoint_history.jsonl")
+    def self.json_storage_dir(project_dir = Dir.pwd) = File.join(aidp_dir(project_dir), "json")
+    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))
+    end
+
+    def self.ensure_aidp_dir(project_dir = Dir.pwd)
+      dir = aidp_dir(project_dir)
+      FileUtils.mkdir_p(dir) unless Dir.exist?(dir)
+      dir
+    end
+
+    def self.ensure_config_dir(project_dir = Dir.pwd)
+      ensure_aidp_dir(project_dir)
+    end
+
+    def self.ensure_progress_dir(project_dir = Dir.pwd)
+      dir = progress_dir(project_dir)
+      FileUtils.mkdir_p(dir) unless Dir.exist?(dir)
+      dir
+    end
+
+    def self.ensure_harness_state_dir(project_dir = Dir.pwd)
+      dir = harness_state_dir(project_dir)
+      FileUtils.mkdir_p(dir) unless Dir.exist?(dir)
+      dir
+    end
+
+    def self.ensure_providers_dir(project_dir = Dir.pwd)
+      dir = providers_dir(project_dir)
+      FileUtils.mkdir_p(dir) unless Dir.exist?(dir)
+      dir
+    end
+
+    def self.ensure_jobs_dir(project_dir = Dir.pwd)
+      dir = jobs_dir(project_dir)
+      FileUtils.mkdir_p(dir) unless Dir.exist?(dir)
+      dir
+    end
+
+    def self.ensure_json_storage_dir(project_dir = Dir.pwd)
+      dir = json_storage_dir(project_dir)
+      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