aidp 0.14.2 → 0.15.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e9ed49c611f18d153eef9794e7ad5077a4bd369988b21dc6849b26b4f9489691
-  data.tar.gz: 97d9812b8cb6437471b4e4bdfdff218b588e20d0187fe6878dd03fdc6fed9b25
+  metadata.gz: 9a7dbc13b3136399f56fc64c00753506be8cbb35d5d3bf0f932799cc12a10504
+  data.tar.gz: 20afb73742ef4379f51fc05a9ae9cfb71ec95269856d79da0c0ce48c07c0aa39
 SHA512:
-  metadata.gz: f88b7ff6548415eb12a364782a7b2f1a8dfdbc2983c9a776a4714c8d2cc0c58501c4180795ff62734b6dee26e2448d0cbfcab1a1a0e5ecb577b49bb24d2184b9
-  data.tar.gz: 67867d11f4909e48f2b6954f966e06291a3b4e3ad2196fc993bf5ebe0ad5f411547f6ed0bdd76bb864a0f0850148a87a2d0ba5265207a447788bb020f72b29b4
+  metadata.gz: 41837e458506b1dc31724b611d46792d446da2f9b0303a37ded28fddbb8f29cfbaeeb417fddc24a3f34a0ed40f5ef3b9d96bf6c827c548be92436ca5ead751c2
+  data.tar.gz: fd57d77e5f8a85c38b3343c4db7a96ec7764066c420e2810d650ef97b51b4d47461c6779d3d9d856baa6730e15a204708b0c0b151d2bc4c00b71d86df68f988d

data/README.md

@@ -20,11 +20,8 @@ aidp config --interactive
 aidp init
 # Creates LLM_STYLE_GUIDE.md, PROJECT_ANALYSIS.md, CODE_QUALITY_PLAN.md
 
-# Start an interactive workflow
-aidp execute
-
-# Or run in background
-aidp execute --background
+# Start Copilot interactive mode (default)
+aidp
 ```
 
 ### First-Time Setup
@@ -58,16 +55,12 @@ AIDP implements **work loops** - an iterative execution pattern where AI agents
 
 See [Work Loops Guide](docs/WORK_LOOPS_GUIDE.md) for details.
 
-### Background Execution
+### Job Management
 
-Run workflows in the background while monitoring progress from separate terminals:
+Monitor and control background jobs:
 
 ```bash
-# Start in background
-aidp execute --background
-✓ Started background job: 20251005_235912_a1b2c3d4
-
-# Monitor progress
+# List and manage jobs
 aidp jobs list                        # List all jobs
 aidp jobs status <job_id>             # Show job status
 aidp jobs logs <job_id> --tail        # View recent logs
@@ -102,17 +95,14 @@ aidp checkpoint history 20
 
 ## Command Reference
 
-### Execution Modes
+### Copilot Mode
 
 ```bash
-# Execute mode - Build new features
-aidp execute                    # Interactive workflow selection
-aidp execute --background       # Run in background
-aidp execute --background --follow  # Start and follow logs
-
-# Analyze mode - Analyze codebase
-aidp analyze                    # Interactive analysis
-aidp analyze --background       # Background analysis
+# Start interactive Copilot mode (default)
+aidp                            # AI-guided workflow selection
+
+# Copilot can perform both analysis and development based on your needs
+# It will interactively help you choose the right approach
 ```
 
 ### Job Management
@@ -207,6 +197,21 @@ harness:
       - "bundle exec rspec"
     lint_commands:
       - "bundle exec standardrb"
+    units:
+      deterministic:
+        - name: run_full_tests
+          command: "bundle exec rake spec"
+          enabled: false
+          next:
+            success: agentic
+            failure: decide_whats_next
+        - name: wait_for_github
+          type: "wait"
+          metadata:
+            interval_seconds: 60
+      defaults:
+        on_no_next_step: wait_for_github
+        fallback_agentic: decide_whats_next
 
 providers:
   claude:
@@ -329,40 +334,36 @@ The questions file is only created when the AI needs additional information beyo
 ### Standard Interactive Workflow
 
 ```bash
-# Start execute mode
-aidp execute
-
-# Select workflow type (e.g., "Full PRD to Implementation")
-# Answer any questions interactively
-# Review generated files (PRD, architecture, etc.)
-# Workflow runs automatically with harness managing retries
+# Start Copilot mode (default)
+aidp
+
+# Copilot will guide you through:
+# - Understanding your project goals
+# - Selecting the right workflow (analysis, development, or both)
+# - Answering questions about your requirements
+# - Reviewing generated files (PRD, architecture, etc.)
+# - Automatic execution with harness managing retries
 ```
 
-### Background Workflow with Monitoring
+### Project Analysis
 
 ```bash
-# Terminal 1: Start background execution
-aidp execute --background
-✓ Started background job: 20251005_235912_a1b2c3d4
-
-# Terminal 2: Watch progress in real-time
-aidp checkpoint summary --watch
-
-# Terminal 3: Monitor job status
-aidp jobs status 20251005_235912_a1b2c3d4 --follow
+# High-level project analysis and documentation
+aidp init
 
-# Later: Check final results
-aidp checkpoint summary
-aidp jobs logs 20251005_235912_a1b2c3d4 --tail
+# Creates:
+# - LLM_STYLE_GUIDE.md
+# - PROJECT_ANALYSIS.md
+# - CODE_QUALITY_PLAN.md
 ```
 
-### Quick Analysis
+### Progress Monitoring
 
 ```bash
-# Run analysis in background
-aidp analyze --background
+# Watch progress in real-time
+aidp checkpoint summary --watch
 
-# Check progress
+# Check job status
 aidp jobs list
 aidp checkpoint summary
 ```

data/lib/aidp/cli.rb

@@ -196,15 +196,15 @@ module Aidp
         tui.start_display_loop
 
         begin
-          # First question: Choose mode
-          mode = select_mode_interactive(tui)
+          # Copilot is now the default mode - no menu selection
+          # The guided workflow selector will internally choose appropriate mode
+          mode = :guided
 
           # Get workflow configuration (no spinner - may wait for user input)
           workflow_config = workflow_selector.select_workflow(harness_mode: false, mode: mode)
 
-          # For guided mode, use the mode determined by the guided workflow selector
-          # Otherwise use the initially selected mode
-          actual_mode = workflow_config[:mode] || mode
+          # Use the mode determined by the guided workflow selector
+          actual_mode = workflow_config[:mode] || :execute
 
           # Pass workflow configuration to harness
           harness_options = {
@@ -265,8 +265,7 @@ module Aidp
           opts.separator "AI Development Pipeline - Autonomous development workflow automation"
           opts.separator ""
           opts.separator "Commands:"
-          opts.separator "  analyze [--background]   Start analyze mode workflow"
-          opts.separator "  execute [--background]   Start execute mode workflow"
+          opts.separator "  (no command)             Start Copilot interactive mode (default)"
           opts.separator "  init                     Analyse project and bootstrap quality docs"
           opts.separator "  watch <issues_url>       Run fully automatic watch mode"
           opts.separator "  status                   Show current system status"
@@ -302,9 +301,12 @@ module Aidp
 
           opts.separator ""
           opts.separator "Examples:"
-          opts.separator "  # Start background execution"
-          opts.separator "  aidp execute --background"
-          opts.separator "  aidp execute --background --follow    # Start and follow logs"
+          opts.separator "  # Start interactive Copilot mode"
+          opts.separator "  aidp"
+          opts.separator ""
+          opts.separator "  # Project bootstrap"
+          opts.separator "  aidp init                             # High-level analysis and docs"
+          opts.separator "  aidp config --interactive             # Configure providers"
           opts.separator ""
           opts.separator "  # Monitor background jobs"
           opts.separator "  aidp jobs list                        # List all jobs"
@@ -315,20 +317,14 @@ module Aidp
           opts.separator "  aidp checkpoint summary --watch       # Auto-refresh every 5s"
           opts.separator "  aidp checkpoint summary --watch --interval 10"
           opts.separator ""
-          opts.separator "  # Project bootstrap"
-          opts.separator "  aidp init"
-          opts.separator "  aidp config --interactive"
           opts.separator "  # Fully automatic orchestration"
-          opts.separator ""
           opts.separator "  aidp watch https://github.com/<org>/<repo>/issues"
           opts.separator "  aidp watch owner/repo --interval 120 --provider claude"
           opts.separator ""
           opts.separator "  # Other commands"
           opts.separator "  aidp providers                        # Check provider health"
           opts.separator "  aidp providers info claude            # Show detailed provider info"
-          opts.separator "  aidp providers refresh                # Refresh all provider info"
           opts.separator "  aidp mcp                              # Show MCP server dashboard"
-          opts.separator "  aidp mcp check dash-api filesystem    # Check provider eligibility"
           opts.separator "  aidp checkpoint history 20            # Show last 20 checkpoints"
           opts.separator ""
           opts.separator "For more information, visit: https://github.com/viamin/aidp"
@@ -342,7 +338,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 execute analyze providers checkpoint mcp issue config init watch].include?(args.first)
+        %w[status jobs kb harness providers checkpoint mcp issue config init watch].include?(args.first)
       end
 
       def run_subcommand(args)
@@ -352,8 +348,6 @@ module Aidp
         when "jobs" then run_jobs_command(args)
         when "kb" then run_kb_command(args)
         when "harness" then run_harness_command(args)
-        when "execute" then run_execute_command(args)
-        when "analyze" then run_execute_command(args, mode: :analyze) # symmetry
         when "providers" then run_providers_command(args)
         when "checkpoint" then run_checkpoint_command(args)
         when "mcp" then run_mcp_command(args)
@@ -923,25 +917,6 @@ module Aidp
         mode&.to_sym
       end
 
-      def select_mode_interactive(tui)
-        mode_options = [
-          "🤖 Guided Workflow (Copilot) - AI helps you choose the right workflow",
-          "🔬 Analyze Mode - Analyze your codebase for insights and recommendations",
-          "🏗️ Execute Mode - Build new features with guided development workflow"
-        ]
-        selected = tui.single_select("Welcome to AI Dev Pipeline! Choose your mode", mode_options, default: 1)
-        # Announce mode explicitly in headless contexts (handled internally otherwise)
-        if (defined?(RSpec) || ENV["RSPEC_RUNNING"]) && tui.respond_to?(:announce_mode)
-          tui.announce_mode(:guided) if selected == mode_options[0]
-          tui.announce_mode(:analyze) if selected == mode_options[1]
-          tui.announce_mode(:execute) if selected == mode_options[2]
-        end
-        return :guided if selected == mode_options[0]
-        return :analyze if selected == mode_options[1]
-        return :execute if selected == mode_options[2]
-        :analyze
-      end
-
       def display_harness_result(result)
         case result[:status]
         when "completed"

data/lib/aidp/execute/agent_signal_parser.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Aidp
+  module Execute
+    module AgentSignalParser
+      def self.extract_next_unit(output)
+        return nil unless output
+
+        output.to_s.each_line do |line|
+          token = token_from_line(line)
+          next unless token
+
+          return normalize_token(token)
+        end
+
+        nil
+      end
+
+      def self.normalize_token(raw)
+        return nil if raw.nil? || raw.empty?
+
+        token = raw.downcase.strip
+        token.gsub!(/\s+/, "_")
+        token.to_sym
+      end
+
+      def self.token_from_line(line)
+        return nil unless line
+
+        trimmed = line.lstrip
+        separator_index = trimmed.index(":") || trimmed.index("=")
+        return nil unless separator_index
+
+        key = trimmed[0...separator_index].strip
+        value = trimmed[(separator_index + 1)..]&.strip
+
+        return nil unless key && value
+        return value if key.casecmp("next_unit").zero? || key.casecmp("next_step").zero?
+
+        nil
+      end
+
+      private_class_method :token_from_line
+    end
+  end
+end

data/lib/aidp/execute/deterministic_unit.rb

@@ -0,0 +1,254 @@
+# frozen_string_literal: true
+
+require "yaml"
+require_relative "../message_display"
+require_relative "../rescue_logging"
+require_relative "../util"
+
+module Aidp
+  module Execute
+    module DeterministicUnits
+      # Represents a deterministic unit configured in aidp.yml.
+      # Definitions are immutable and provide helper accessors used by the scheduler.
+      class Definition
+        VALID_TYPES = [:command, :wait].freeze
+        NEXT_KEY_ALIASES = {
+          if_pass: :success,
+          if_success: :success,
+          if_fail: :failure,
+          if_failure: :failure,
+          if_error: :failure,
+          if_timeout: :timeout,
+          if_wait: :waiting,
+          if_new_item: :event,
+          if_event: :event
+        }.freeze
+
+        attr_reader :name, :type, :command, :output_file, :next_map,
+          :min_interval_seconds, :max_backoff_seconds, :backoff_multiplier,
+          :enabled, :metadata
+
+        def initialize(config)
+          @name = config.fetch(:name)
+          @type = normalize_type(config[:type]) || default_type_for(config)
+          validate_type!
+
+          @command = config[:command]
+          @output_file = config[:output_file]
+          @next_map = normalize_next_config(config[:next] || {})
+          @min_interval_seconds = config.fetch(:min_interval_seconds, 60)
+          @max_backoff_seconds = config.fetch(:max_backoff_seconds, 900)
+          @backoff_multiplier = config.fetch(:backoff_multiplier, 2.0)
+          @enabled = config.fetch(:enabled, true)
+          @metadata = config.fetch(:metadata, {}).dup
+        end
+
+        def command?
+          type == :command
+        end
+
+        def wait?
+          type == :wait
+        end
+
+        def next_for(result_status, default: nil)
+          next_map[result_status.to_sym] || default || next_map[:else]
+        end
+
+        private
+
+        def normalize_type(type)
+          return nil if type.nil?
+          symbol = type.to_sym
+          VALID_TYPES.include?(symbol) ? symbol : nil
+        end
+
+        def default_type_for(config)
+          return :command if config[:command]
+          :wait
+        end
+
+        def validate_type!
+          return if VALID_TYPES.include?(type)
+          raise ArgumentError, "Unsupported deterministic unit type: #{type.inspect}"
+        end
+
+        def normalize_next_config(raw)
+          return {} unless raw
+
+          raw.each_with_object({}) do |(key, value), normalized|
+            symbol_key = key.to_sym
+            normalized[NEXT_KEY_ALIASES.fetch(symbol_key, symbol_key)] = value
+          end
+        end
+      end
+
+      # Result wrapper returned after executing a deterministic unit.
+      class Result
+        attr_reader :name, :status, :output_path, :started_at, :finished_at,
+          :duration, :data, :error
+
+        def initialize(name:, status:, output_path:, started_at:, finished_at:, data: {}, error: nil)
+          @name = name
+          @status = status.to_sym
+          @output_path = output_path
+          @started_at = started_at
+          @finished_at = finished_at
+          @duration = finished_at - started_at
+          @data = data
+          @error = error
+        end
+
+        def success?
+          status == :success
+        end
+
+        def failure?
+          status == :failure
+        end
+
+        def timeout?
+          status == :timeout
+        end
+      end
+
+      # Executes deterministic units by running commands or internal behaviours.
+      class Runner
+        include Aidp::MessageDisplay
+        include Aidp::RescueLogging
+
+        DEFAULT_TIMEOUT = 3600 # One hour ceiling for long-running commands
+
+        def initialize(project_dir, command_runner: nil, clock: Time)
+          @project_dir = project_dir
+          @clock = clock
+          @command_runner = command_runner || build_default_command_runner
+        end
+
+        def run(definition, context = {})
+          raise ArgumentError, "Unit #{definition.name} is not enabled" unless definition.enabled
+
+          case definition.type
+          when :command
+            execute_command_unit(definition, context)
+          when :wait
+            execute_wait_unit(definition, context)
+          else
+            raise ArgumentError, "Unsupported deterministic unit type: #{definition.type}"
+          end
+        end
+
+        private
+
+        def execute_command_unit(definition, context)
+          started_at = @clock.now
+          display_message("🛠️  Running deterministic unit: #{definition.name}", type: :info)
+
+          result = @command_runner.call(definition.command, context)
+
+          data = {
+            exit_status: result[:exit_status],
+            stdout: result[:stdout],
+            stderr: result[:stderr]
+          }
+
+          status = result[:exit_status].to_i.zero? ? :success : :failure
+          output_path = write_output(definition, data)
+
+          display_message("✅ Deterministic unit #{definition.name} finished with status #{status}", type: :success) if status == :success
+          display_message("⚠️  Deterministic unit #{definition.name} finished with status #{status}", type: :warning) if status != :success
+
+          DeterministicUnits::Result.new(
+            name: definition.name,
+            status: status,
+            output_path: output_path,
+            started_at: started_at,
+            finished_at: @clock.now,
+            data: data
+          )
+        rescue => e
+          finished_at = @clock.now
+          log_rescue(e, component: "deterministic_runner", action: "execute_command_unit", fallback: "failure", unit: definition.name)
+          display_message("❌ Deterministic unit #{definition.name} failed: #{e.message}", type: :error)
+
+          output_path = write_output(definition, {error: e.message})
+
+          DeterministicUnits::Result.new(
+            name: definition.name,
+            status: :failure,
+            output_path: output_path,
+            started_at: started_at,
+            finished_at: finished_at,
+            data: {error: e.message},
+            error: e
+          )
+        end
+
+        def execute_wait_unit(definition, context)
+          started_at = @clock.now
+
+          wait_seconds = definition.metadata.fetch(:interval_seconds, 60)
+          backoff_seconds = definition.metadata.fetch(:backoff_seconds, wait_seconds)
+          reason = context[:reason] || "Waiting for GitHub activity"
+
+          display_message("🕒 Deterministic wait: #{definition.name} (#{reason})", type: :info)
+          max_window = definition.max_backoff_seconds || backoff_seconds
+          sleep_duration = backoff_seconds.clamp(1, max_window)
+
+          sleep_handler = context[:sleep_handler] || method(:sleep)
+          sleep_handler.call(sleep_duration)
+
+          event_detected = context[:event_detected] == true
+
+          payload = {
+            message: "Waited #{sleep_duration} seconds",
+            reason: reason,
+            backoff_seconds: sleep_duration,
+            event_detected: event_detected
+          }
+
+          output_path = write_output(definition, payload)
+
+          DeterministicUnits::Result.new(
+            name: definition.name,
+            status: event_detected ? :event : :waiting,
+            output_path: output_path,
+            started_at: started_at,
+            finished_at: @clock.now,
+            data: payload
+          )
+        end
+
+        def write_output(definition, payload)
+          return nil unless definition.output_file
+
+          path = File.join(@project_dir, definition.output_file)
+          Aidp::Util.safe_file_write(path, payload.to_yaml)
+          path
+        end
+
+        def build_default_command_runner
+          lambda do |command, _context|
+            require "tty-command"
+
+            cmd = TTY::Command.new(printer: :quiet)
+            result = cmd.run(command, chdir: @project_dir)
+
+            {
+              exit_status: result.exit_status,
+              stdout: result.out,
+              stderr: result.err
+            }
+          rescue TTY::Command::ExitError => e
+            result = e.result
+            {
+              exit_status: result.exit_status,
+              stdout: result.out,
+              stderr: result.err
+            }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/aidp/execute/steps.rb

@@ -128,7 +128,7 @@ module Aidp
         # Simple task execution - for one-off commands and simple fixes
         "99_SIMPLE_TASK" => {
           "templates" => ["implementation/simple_task.md"],
-          "description" => "Execute Simple Task (one-off commands, quick fixes, linting)",
+          "description" => "Execute Simple Task (one-off commands, quick fixes, linting; emit NEXT_UNIT when more tooling is needed)",
           "outs" => [],
           "gate" => false,
           "simple" => true # Special step for simple, focused tasks

data/lib/aidp/execute/work_loop_runner.rb

@@ -4,6 +4,9 @@ require_relative "prompt_manager"
 require_relative "checkpoint"
 require_relative "checkpoint_display"
 require_relative "guard_policy"
+require_relative "work_loop_unit_scheduler"
+require_relative "deterministic_unit"
+require_relative "agent_signal_parser"
 require_relative "../harness/test_runner"
 
 module Aidp
@@ -53,6 +56,8 @@ module Aidp
         @options = options
         @current_state = :ready
         @state_history = []
+        @deterministic_runner = DeterministicUnits::Runner.new(project_dir)
+        @unit_scheduler = nil
       end
 
       # Execute a step using fix-forward work loop pattern
@@ -63,86 +68,212 @@ module Aidp
         @iteration_count = 0
         transition_to(:ready)
 
-        Aidp.logger.info("work_loop", "Starting fix-forward execution", step: step_name, max_iterations: MAX_ITERATIONS)
+        Aidp.logger.info("work_loop", "Starting hybrid work loop execution", step: step_name, max_iterations: MAX_ITERATIONS)
 
-        display_message("🔄 Starting fix-forward work loop for step: #{step_name}", type: :info)
-        display_message("  State machine: READY → APPLY_PATCH → TEST → {PASS → DONE | FAIL → DIAGNOSE → NEXT_PATCH}", type: :info)
+        display_message("🔄 Starting hybrid work loop for step: #{step_name}", type: :info)
+        display_message("  Flow: Deterministic ↔ Agentic with fix-forward core", type: :info)
 
-        # Display guard policy status
         display_guard_policy_status
 
-        # Create initial PROMPT.md
+        @unit_scheduler = WorkLoopUnitScheduler.new(units_config)
+        base_context = context.dup
+
+        loop do
+          unit = @unit_scheduler.next_unit
+          break unless unit
+
+          if unit.deterministic?
+            result = @deterministic_runner.run(unit.definition, reason: "scheduled by work loop")
+            @unit_scheduler.record_deterministic_result(unit.definition, result)
+            next
+          end
+
+          enriched_context = base_context.merge(
+            deterministic_outputs: @unit_scheduler.deterministic_context,
+            previous_agent_summary: @unit_scheduler.last_agentic_summary
+          )
+
+          agentic_payload = if unit.name == :decide_whats_next
+            run_decider_agentic_unit(enriched_context)
+          else
+            run_primary_agentic_unit(step_spec, enriched_context)
+          end
+
+          @unit_scheduler.record_agentic_result(
+            agentic_payload[:raw_result] || {},
+            requested_next: agentic_payload[:requested_next],
+            summary: agentic_payload[:summary],
+            completed: agentic_payload[:completed]
+          )
+
+          return agentic_payload[:response] if agentic_payload[:terminate]
+        end
+
+        build_max_iterations_result
+      end
+
+      private
+
+      def run_primary_agentic_unit(step_spec, context)
+        Aidp.logger.info("work_loop", "Running primary agentic unit", step: @step_name)
+
+        display_message("  State machine: READY → APPLY_PATCH → TEST → {PASS → DONE | FAIL → DIAGNOSE → NEXT_PATCH}", type: :info)
+
+        @iteration_count = 0
+        @current_state = :ready
+        @state_history.clear
+
         create_initial_prompt(step_spec, context)
 
-        # Main fix-forward work loop
         loop do
           @iteration_count += 1
           display_message("  Iteration #{@iteration_count} [State: #{STATES[@current_state]}]", type: :info)
 
           if @iteration_count > MAX_ITERATIONS
             Aidp.logger.error("work_loop", "Max iterations exceeded", step: @step_name, iterations: @iteration_count)
-            break
+            display_message("⚠️  Max iterations (#{MAX_ITERATIONS}) reached for #{@step_name}", type: :warning)
+            display_state_summary
+            archive_and_cleanup
+            return build_agentic_payload(
+              agent_result: nil,
+              response: build_max_iterations_result,
+              summary: nil,
+              completed: false,
+              terminate: true
+            )
           end
 
-          # State: READY - Starting new iteration
           transition_to(:ready) unless @current_state == :ready
 
-          # State: APPLY_PATCH - Agent applies changes
           transition_to(:apply_patch)
-          result = apply_patch
+          agent_result = apply_patch
 
-          # State: TEST - Run tests and linters
           transition_to(:test)
           test_results = @test_runner.run_tests
           lint_results = @test_runner.run_linters
 
-          # Record checkpoint at intervals
           record_periodic_checkpoint(test_results, lint_results)
 
-          # Check if tests passed
           tests_pass = test_results[:success] && lint_results[:success]
 
           if tests_pass
-            # State: PASS - Tests passed
             transition_to(:pass)
 
-            # Check if agent marked work complete
-            if agent_marked_complete?(result)
-              # State: DONE - Work complete
+            if agent_marked_complete?(agent_result)
               transition_to(:done)
               record_final_checkpoint(test_results, lint_results)
-              display_message("✅ Step #{step_name} completed after #{@iteration_count} iterations", type: :success)
+              display_message("✅ Step #{@step_name} completed after #{@iteration_count} iterations", type: :success)
               display_state_summary
               archive_and_cleanup
-              return build_success_result(result)
+
+              return build_agentic_payload(
+                agent_result: agent_result,
+                response: build_success_result(agent_result),
+                summary: agent_result[:output],
+                completed: true,
+                terminate: true
+              )
             else
-              # Tests pass but work not complete - continue
               display_message("  Tests passed but work not marked complete", type: :info)
               transition_to(:next_patch)
             end
           else
-            # State: FAIL - Tests failed
             transition_to(:fail)
             display_message("  Tests or linters failed", type: :warning)
 
-            # State: DIAGNOSE - Analyze failures
             transition_to(:diagnose)
             diagnostic = diagnose_failures(test_results, lint_results)
 
-            # State: NEXT_PATCH - Prepare for next iteration
             transition_to(:next_patch)
             prepare_next_iteration(test_results, lint_results, diagnostic)
           end
         end
+      end
 
-        # Safety: max iterations reached
-        display_message("⚠️  Max iterations (#{MAX_ITERATIONS}) reached for #{step_name}", type: :warning)
-        display_state_summary
-        archive_and_cleanup
-        build_max_iterations_result
+      def run_decider_agentic_unit(context)
+        Aidp.logger.info("work_loop", "Running decide_whats_next agentic unit", step: @step_name)
+
+        prompt = build_decider_prompt(context)
+
+        agent_result = @provider_manager.execute_with_provider(
+          @provider_manager.current_provider,
+          prompt,
+          {
+            step_name: @step_name,
+            iteration: @iteration_count,
+            project_dir: @project_dir,
+            mode: :decide_whats_next
+          }
+        )
+
+        requested = AgentSignalParser.extract_next_unit(agent_result[:output])
+
+        build_agentic_payload(
+          agent_result: agent_result,
+          response: agent_result,
+          summary: agent_result[:output],
+          completed: false,
+          terminate: false,
+          requested_next: requested
+        )
       end
 
-      private
+      def units_config
+        if @config.respond_to?(:work_loop_units_config)
+          @config.work_loop_units_config
+        else
+          {}
+        end
+      end
+
+      def build_agentic_payload(agent_result:, response:, summary:, completed:, terminate:, requested_next: nil)
+        {
+          raw_result: agent_result,
+          response: response,
+          summary: summary,
+          requested_next: requested_next || AgentSignalParser.extract_next_unit(agent_result&.dig(:output)),
+          completed: completed,
+          terminate: terminate
+        }
+      end
+
+      def build_decider_prompt(context)
+        outputs = Array(context[:deterministic_outputs])
+        summary = context[:previous_agent_summary]
+
+        sections = []
+        sections << "# Decide Next Work Loop Unit"
+        sections << ""
+        sections << "You are operating in the Aidp work loop. Determine what should happen next."
+        sections << ""
+        sections << "## Recent Deterministic Outputs"
+
+        if outputs.empty?
+          sections << "- None recorded yet."
+        else
+          outputs.each do |entry|
+            sections << "- #{entry[:name]} (status: #{entry[:status]}, finished_at: #{entry[:finished_at]})"
+            sections << "  Output: #{entry[:output_path] || "n/a"}"
+          end
+        end
+
+        if summary
+          sections << ""
+          sections << "## Previous Agent Summary"
+          sections << summary
+        end
+
+        sections << ""
+        sections << "## Instructions"
+        sections << "- Decide whether to run another deterministic unit or resume agentic editing."
+        sections << "- Announce your decision with `NEXT_UNIT: <unit_name>`."
+        sections << "- Valid values: names defined in configuration, `agentic`, or `wait_for_github`."
+        sections << "- Provide a concise rationale below."
+        sections << ""
+        sections << "## Rationale"
+
+        sections.join("\n")
+      end
 
       # Transition to a new state in the fix-forward state machine
       def transition_to(new_state)
@@ -216,20 +347,24 @@ module Aidp
         prd_content = load_prd
         style_guide = load_style_guide
         user_input = format_user_input(context[:user_input])
+        deterministic_outputs = Array(context[:deterministic_outputs])
+        previous_summary = context[:previous_agent_summary]
 
         initial_prompt = build_initial_prompt_content(
           template: template_content,
           prd: prd_content,
           style_guide: style_guide,
           user_input: user_input,
-          step_name: @step_name
+          step_name: @step_name,
+          deterministic_outputs: deterministic_outputs,
+          previous_agent_summary: previous_summary
         )
 
         @prompt_manager.write(initial_prompt)
         display_message("  Created PROMPT.md (#{initial_prompt.length} chars)", type: :info)
       end
 
-      def build_initial_prompt_content(template:, prd:, style_guide:, user_input:, step_name:)
+      def build_initial_prompt_content(template:, prd:, style_guide:, user_input:, step_name:, deterministic_outputs:, previous_agent_summary:)
         parts = []
 
         parts << "# Work Loop: #{step_name}"
@@ -259,6 +394,21 @@ module Aidp
           parts << ""
         end
 
+        if previous_agent_summary && !previous_agent_summary.empty?
+          parts << "## Previous Agent Summary"
+          parts << previous_agent_summary
+          parts << ""
+        end
+
+        unless deterministic_outputs.empty?
+          parts << "## Recent Deterministic Outputs"
+          deterministic_outputs.each do |entry|
+            parts << "- #{entry[:name]} (status: #{entry[:status]})"
+            parts << "  Output: #{entry[:output_path] || "n/a"}"
+          end
+          parts << ""
+        end
+
         if style_guide
           parts << "## LLM Style Guide"
           parts << style_guide

data/lib/aidp/execute/work_loop_unit_scheduler.rb

@@ -0,0 +1,190 @@
+# frozen_string_literal: true
+
+require_relative "deterministic_unit"
+require_relative "../logger"
+
+module Aidp
+  module Execute
+    class WorkLoopUnitScheduler
+      Unit = Struct.new(:type, :name, :definition, keyword_init: true) do
+        def agentic?
+          type == :agentic
+        end
+
+        def deterministic?
+          type == :deterministic
+        end
+      end
+
+      attr_reader :last_agentic_summary
+
+      def initialize(units_config, clock: Time)
+        @clock = clock
+        @deterministic_definitions = build_deterministic_definitions(units_config[:deterministic])
+        @defaults = default_options.merge(units_config[:defaults] || {})
+        @pending_units = []
+        @deterministic_history = []
+        @deterministic_state = Hash.new { |h, key| h[key] = default_deterministic_state }
+        @agentic_runs = []
+        @last_agentic_summary = nil
+        @consecutive_deciders = 0
+        @completed = false
+        @started = false
+      end
+
+      def next_unit
+        return nil if @completed
+
+        unless @started
+          @started = true
+          queue_requested_unit(@defaults[:initial_unit] || :agentic)
+        end
+
+        unit = @pending_units.shift
+        return unit if unit
+
+        queue_requested_unit(@defaults[:on_no_next_step] || :agentic)
+
+        @pending_units.shift
+      end
+
+      def record_agentic_result(result, requested_next: nil, summary: nil, completed: false)
+        @last_agentic_summary = summarize(summary)
+        @agentic_runs << {timestamp: @clock.now, result: result}
+
+        queue_requested_unit(requested_next) if requested_next
+
+        mark_completed if completed && !requested_next
+      end
+
+      def record_deterministic_result(definition, result)
+        state = @deterministic_state[definition.name]
+        state[:last_run_at] = result.finished_at
+
+        state[:current_backoff] = if result.success? || result.status == :event
+          definition.min_interval_seconds
+        else
+          [
+            state[:current_backoff] * definition.backoff_multiplier,
+            definition.max_backoff_seconds
+          ].min
+        end
+
+        @deterministic_history << {
+          name: definition.name,
+          status: result.status,
+          output_path: result.output_path,
+          finished_at: result.finished_at,
+          data: result.data
+        }
+
+        requested = definition.next_for(result.status)
+        queue_requested_unit(requested) if requested
+      end
+
+      def deterministic_context(limit: 5)
+        @deterministic_history.last(limit)
+      end
+
+      def completed?
+        @completed
+      end
+
+      private
+
+      def summarize(summary)
+        return nil unless summary
+        content = summary.to_s.strip
+        return nil if content.empty?
+        (content.length > 500) ? "#{content[0...500]}…" : content
+      end
+
+      def mark_completed
+        @completed = true
+        @pending_units.clear
+      end
+
+      def queue_requested_unit(identifier)
+        return if identifier.nil?
+
+        case identifier.to_sym
+        when :agentic
+          enqueue_agentic(:primary)
+        when :decide_whats_next
+          enqueue_agentic(:decide_whats_next)
+        else
+          enqueue_deterministic(identifier.to_s)
+        end
+      rescue NoMethodError
+        enqueue_agentic(:primary)
+      end
+
+      def enqueue_agentic(name)
+        if name == :decide_whats_next
+          if @consecutive_deciders >= @defaults[:max_consecutive_deciders]
+            enqueue_agentic(:primary)
+            return
+          end
+          @consecutive_deciders += 1
+        else
+          @consecutive_deciders = 0
+        end
+
+        @pending_units << Unit.new(type: :agentic, name: name)
+      end
+
+      def enqueue_deterministic(name)
+        definition = @deterministic_definitions[name]
+        unless definition
+          enqueue_agentic((@defaults[:fallback_agentic] || :agentic).to_sym)
+          return
+        end
+        return unless definition.enabled
+
+        state = @deterministic_state[definition.name]
+        state[:current_backoff] ||= definition.min_interval_seconds
+
+        if cooldown_remaining(definition).positive?
+          enqueue_agentic((@defaults[:fallback_agentic] || :agentic).to_sym)
+          return
+        end
+
+        @pending_units << Unit.new(type: :deterministic, name: definition.name, definition: definition)
+      end
+
+      def cooldown_remaining(definition)
+        state = @deterministic_state[definition.name]
+        state[:current_backoff] ||= definition.min_interval_seconds
+
+        return 0 unless state[:last_run_at]
+
+        next_allowed_at = state[:last_run_at] + state[:current_backoff]
+        remaining = next_allowed_at - @clock.now
+        remaining.positive? ? remaining : 0
+      end
+
+      def build_deterministic_definitions(config_list)
+        Array(config_list).each_with_object({}) do |config, mapping|
+          definition = DeterministicUnits::Definition.new(config.transform_keys(&:to_sym))
+          mapping[definition.name] = definition
+        rescue KeyError, ArgumentError => e
+          Aidp.logger.warn("work_loop", "Skipping invalid deterministic unit configuration",
+            name: config[:name], error: e.message)
+        end
+      end
+
+      def default_deterministic_state
+        {last_run_at: nil, current_backoff: nil}
+      end
+
+      def default_options
+        {
+          initial_unit: :agentic,
+          on_no_next_step: :agentic,
+          fallback_agentic: :decide_whats_next,
+          max_consecutive_deciders: 1
+        }
+      end
+    end
+  end
+end

data/lib/aidp/harness/config_schema.rb

@@ -374,7 +374,8 @@ module Aidp
                 enabled: true,
                 max_iterations: 50,
                 test_commands: [],
-                lint_commands: []
+                lint_commands: [],
+                units: {}
               },
               properties: {
                 enabled: {
@@ -405,6 +406,95 @@ module Aidp
                     type: :string
                   }
                 },
+                units: {
+                  type: :hash,
+                  required: false,
+                  default: {},
+                  properties: {
+                    deterministic: {
+                      type: :array,
+                      required: false,
+                      default: [],
+                      items: {
+                        type: :hash,
+                        properties: {
+                          name: {
+                            type: :string,
+                            required: true
+                          },
+                          command: {
+                            type: :string,
+                            required: false
+                          },
+                          type: {
+                            type: :string,
+                            required: false,
+                            enum: ["command", "wait"]
+                          },
+                          output_file: {
+                            type: :string,
+                            required: false
+                          },
+                          enabled: {
+                            type: :boolean,
+                            required: false,
+                            default: true
+                          },
+                          min_interval_seconds: {
+                            type: :integer,
+                            required: false,
+                            min: 1
+                          },
+                          max_backoff_seconds: {
+                            type: :integer,
+                            required: false,
+                            min: 1
+                          },
+                          backoff_multiplier: {
+                            type: :number,
+                            required: false,
+                            min: 1.0
+                          },
+                          metadata: {
+                            type: :hash,
+                            required: false,
+                            default: {}
+                          },
+                          next: {
+                            type: :hash,
+                            required: false,
+                            default: {}
+                          }
+                        }
+                      }
+                    },
+                    defaults: {
+                      type: :hash,
+                      required: false,
+                      default: {},
+                      properties: {
+                        initial_unit: {
+                          type: :string,
+                          required: false
+                        },
+                        on_no_next_step: {
+                          type: :string,
+                          required: false
+                        },
+                        fallback_agentic: {
+                          type: :string,
+                          required: false
+                        },
+                        max_consecutive_deciders: {
+                          type: :integer,
+                          required: false,
+                          min: 1,
+                          max: 10
+                        }
+                      }
+                    }
+                  }
+                },
                 guards: {
                   type: :hash,
                   required: false,

data/lib/aidp/harness/configuration.rb

@@ -150,6 +150,10 @@ module Aidp
         harness_config[:work_loop] || default_work_loop_config
       end
 
+      def work_loop_units_config
+        work_loop_config[:units] || default_units_config
+      end
+
       # Check if work loops are enabled
       def work_loop_enabled?
         work_loop_config[:enabled]
@@ -483,7 +487,62 @@ module Aidp
           max_iterations: 50,
           test_commands: [],
           lint_commands: [],
-          guards: default_guards_config
+          guards: default_guards_config,
+          units: default_units_config
+        }
+      end
+
+      def default_units_config
+        {
+          deterministic: [
+            {
+              name: "run_full_tests",
+              command: "bundle exec rake spec",
+              output_file: ".aidp/out/run_full_tests.yml",
+              enabled: false,
+              min_interval_seconds: 300,
+              max_backoff_seconds: 1800,
+              next: {
+                success: :agentic,
+                failure: :decide_whats_next,
+                else: :decide_whats_next
+              }
+            },
+            {
+              name: "run_lint",
+              command: "bundle exec standardrb",
+              output_file: ".aidp/out/run_lint.yml",
+              enabled: false,
+              min_interval_seconds: 300,
+              max_backoff_seconds: 1800,
+              next: {
+                success: :agentic,
+                failure: :decide_whats_next,
+                else: :decide_whats_next
+              }
+            },
+            {
+              name: "wait_for_github",
+              type: :wait,
+              output_file: ".aidp/out/wait_for_github.yml",
+              metadata: {
+                interval_seconds: 60,
+                backoff_seconds: 60
+              },
+              min_interval_seconds: 60,
+              max_backoff_seconds: 900,
+              next: {
+                event: :agentic,
+                else: :wait_for_github
+              }
+            }
+          ],
+          defaults: {
+            initial_unit: :agentic,
+            on_no_next_step: :wait_for_github,
+            fallback_agentic: :decide_whats_next,
+            max_consecutive_deciders: 1
+          }
         }
       end
 

data/lib/aidp/version.rb

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

data/templates/implementation/simple_task.md

@@ -12,6 +12,9 @@ You are executing a simple, focused task within the AIDP work loop.
 2. **Execute the task exactly as described**
 3. **Verify your work** by running any validation commands specified
 4. **Edit this PROMPT.md** to track progress and mark complete when done
+5. **Request follow-up units** by adding `NEXT_UNIT: <unit_name>` to your
+   response when deterministic work (tests, linting, wait states) should run
+   next
 
 ## Completion Criteria
 
@@ -34,3 +37,5 @@ STATUS: COMPLETE
 - Keep your changes minimal and focused on the task
 - If the task involves running commands, show the command output
 - If the task involves fixing issues, list what was fixed
+- When you need automation to continue after this task, emit `NEXT_UNIT: agentic`
+  or a deterministic unit such as `run_full_tests` or `wait_for_github`

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: aidp
 version: !ruby/object:Gem::Version
-  version: 0.14.2
+  version: 0.15.0
 platform: ruby
 authors:
 - Bart Agapinan
@@ -260,9 +260,11 @@ files:
 - lib/aidp/daemon/process_manager.rb
 - lib/aidp/daemon/runner.rb
 - lib/aidp/debug_mixin.rb
+- lib/aidp/execute/agent_signal_parser.rb
 - lib/aidp/execute/async_work_loop_runner.rb
 - lib/aidp/execute/checkpoint.rb
 - lib/aidp/execute/checkpoint_display.rb
+- lib/aidp/execute/deterministic_unit.rb
 - lib/aidp/execute/future_work_backlog.rb
 - lib/aidp/execute/guard_policy.rb
 - lib/aidp/execute/instruction_queue.rb
@@ -274,6 +276,7 @@ files:
 - lib/aidp/execute/steps.rb
 - lib/aidp/execute/work_loop_runner.rb
 - lib/aidp/execute/work_loop_state.rb
+- lib/aidp/execute/work_loop_unit_scheduler.rb
 - lib/aidp/execute/workflow_selector.rb
 - lib/aidp/harness/completion_checker.rb
 - lib/aidp/harness/condition_detector.rb