aidp 0.22.0 → 0.23.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e07daf05fddb6301340e9a01b1c6d8eea60ddcf53b2ec2d56e914be610cd67a7
-  data.tar.gz: 21f26ed81af8f996cbb50c4a4dfe7603230f29499399c134c7a83492042a39e2
+  metadata.gz: 1dedfe324bb5255c43e42a4ac3f716bb99f9db453ae436a1e2aa57b68754a28f
+  data.tar.gz: 24b5a225e474c14dabad326455e4d5286e175dc6a929a1bffab4ffb29c1c063c
 SHA512:
-  metadata.gz: 45a1c8c35dbf2f3f672f1990d652c238dd050b3dae3a96edf4d69960475a9e9ee27f1f4ced5ed4a6b0639de6256f56c78d25931e08adacf05ed2aa444e23c9fe
-  data.tar.gz: 85560929fa2c4a1b51a862e8c541ed92d85e51a3c025eede695a5211c7b30b0a2115c098969fbfbb3a7e4237d5d0c074d194f0df0c50b7cdb025a75e7fc9249a
+  metadata.gz: b842c15a0169d3b3c7361cbdf633b5bb66d0189f40fb16e12099436b3db7eda3e983fb624326b2160dd018d63090feae2b92042f46758990c31cef9172252d36
+  data.tar.gz: 1c614a680d74d56fff4561a62eee471ab1d8f7b8b2cc801786da25a63c12b142948f8e418477a4b479b3b119abe2275b954d9202662f7acbb36cdd82401a68eb

data/README.md

@@ -48,8 +48,8 @@ AIDP provides first-class devcontainer support for sandboxed, secure AI agent ex
 
 - **Network Security**: Strict firewall with allowlisted domains only
 - **Sandboxed Environment**: Isolated from your host system
-- **Elevated Permissions**: AI agents can run with full permissions inside the container
 - **Consistent Setup**: Same environment across all developers
+- **Automatic Management**: AIDP can generate and update your devcontainer configuration
 
 ### For AIDP Development
 
@@ -73,43 +73,54 @@ See [.devcontainer/README.md](.devcontainer/README.md) for complete documentatio
 
 ### Generating Devcontainers for Your Projects
 
-Use `aidp init` to generate a devcontainer for any project:
+AIDP can automatically generate and manage devcontainer configurations through the interactive wizard:
 
 ```bash
-# Initialize project with devcontainer
-aidp init
+# Launch the interactive configuration wizard
+aidp config --interactive
 
-# When prompted:
-# "Generate devcontainer configuration for sandboxed development?" → Yes
+# During the wizard, you'll be asked:
+# - Whether you want AIDP to manage your devcontainer configuration
+# - If you want to add custom ports beyond auto-detected ones
 
-# Or use the flag directly
-aidp init --with-devcontainer
+# The wizard will detect ports based on your project type and generate
+# a complete devcontainer.json configuration
 ```
 
-This creates:
+You can also manage devcontainer configuration manually:
+
+```yaml
+# .aidp/aidp.yml
+devcontainer:
+  manage: true
+  custom_ports:
+    - number: 3000
+      label: "Application Server"
+    - number: 5432
+      label: "PostgreSQL"
+```
 
-- `.devcontainer/Dockerfile` - Customized for your project's language/framework
-- `.devcontainer/devcontainer.json` - VS Code configuration and extensions
-- `.devcontainer/init-firewall.sh` - Network security rules
-- `.devcontainer/README.md` - Setup and usage documentation
+Then apply the configuration:
 
-### Elevated Permissions in Devcontainers
+```bash
+# Preview changes
+aidp devcontainer diff
 
-When running inside a devcontainer, you can enable elevated permissions for AI agents:
+# Apply configuration
+aidp devcontainer apply
 
-```yaml
-# aidp.yml
-devcontainer:
-  enabled: true
-  full_permissions_when_in_devcontainer: true  # Run all providers with full permissions
+# List backups
+aidp devcontainer list-backups
 
-  # Or enable per-provider
-  permissions:
-    skip_permission_checks:
-      - claude  # Adds --dangerously-skip-permissions for Claude Code
+# Restore from backup
+aidp devcontainer restore 0
 ```
 
-AIDP automatically detects when it's running in a devcontainer and adjusts agent permissions accordingly. This is safe because the container is sandboxed from your host system.
+See [docs/DEVELOPMENT_CONTAINER.md](docs/DEVELOPMENT_CONTAINER.md) for complete devcontainer management documentation.
+
+### Devcontainer Detection
+
+AIDP automatically detects when it's running inside a devcontainer and adjusts its behavior accordingly. This detection uses multiple heuristics including environment variables, filesystem markers, and cgroup information. See [DevcontainerDetector](lib/aidp/utils/devcontainer_detector.rb) for implementation details.
 
 ## Core Features
 
@@ -190,6 +201,101 @@ aidp ws rm issue-123-fix-auth --delete-branch
 
 See [Workstreams Guide](docs/WORKSTREAMS.md) for detailed usage.
 
+### Watch Mode (Automated GitHub Integration)
+
+AIDP can automatically monitor GitHub repositories and respond to labeled issues, creating plans and executing implementations autonomously:
+
+```bash
+# Start watch mode for a repository
+aidp watch https://github.com/owner/repo/issues
+
+# Optional: specify polling interval, provider, and verbose output
+aidp watch owner/repo --interval 60 --provider claude --verbose
+
+# Run a single cycle (useful for CI/testing)
+aidp watch owner/repo --once
+```
+
+**Label Workflow:**
+
+AIDP uses a smart label-based workflow to manage the lifecycle of automated issue resolution:
+
+1. **Planning Phase** (`aidp-plan` label):
+   - Add this label to an issue to trigger plan generation
+   - AIDP generates an implementation plan with task breakdown and clarifying questions
+   - Posts the plan as a comment on the issue
+   - Automatically removes the `aidp-plan` label
+
+2. **Review & Clarification**:
+   - **If questions exist**: AIDP adds `aidp-needs-input` label and waits for user response
+     - User responds to questions in a comment
+     - User manually removes `aidp-needs-input` and adds `aidp-build` to proceed
+   - **If no questions**: AIDP adds `aidp-ready` label, indicating it's ready to build
+     - User can review the plan before proceeding
+     - User manually adds `aidp-build` label when ready
+
+3. **Implementation Phase** (`aidp-build` label):
+   - Triggers autonomous implementation via work loops
+   - Creates a feature branch and commits changes
+   - Runs tests and linters with automatic fixes
+   - **If clarification needed during implementation**:
+     - Posts clarification questions as a comment
+     - Automatically removes `aidp-build` label and adds `aidp-needs-input`
+     - Preserves work-in-progress for later resumption
+     - User responds to questions, then manually removes `aidp-needs-input` and re-adds `aidp-build`
+   - **On success**:
+     - Posts completion comment with summary
+     - Automatically removes the `aidp-build` label
+
+**Customizable Labels:**
+
+All label names are configurable to match your repository's existing label scheme. Configure via the interactive wizard or manually in `aidp.yml`:
+
+```yaml
+# .aidp/aidp.yml
+watch:
+  labels:
+    plan_trigger: aidp-plan        # Label to trigger plan generation
+    needs_input: aidp-needs-input  # Label when plan needs user input
+    ready_to_build: aidp-ready     # Label when plan is ready to build
+    build_trigger: aidp-build      # Label to trigger implementation
+```
+
+Run `aidp config --interactive` and enable watch mode to configure labels interactively.
+
+**Safety Features:**
+
+- **Public Repository Protection**: Disabled by default for public repos (require explicit opt-in)
+- **Author Allowlist**: Restrict automation to trusted GitHub users only
+- **Container Requirement**: Optionally require sandboxed environment
+- **Force Override**: `--force` flag to bypass safety checks (dangerous!)
+
+**Safety Configuration:**
+
+```yaml
+# .aidp/aidp.yml
+watch:
+  safety:
+    allow_public_repos: true  # Required for public repositories
+    author_allowlist:          # Only these users can trigger automation
+      - trusted-maintainer
+      - team-member
+    require_container: true    # Require devcontainer/Docker environment
+```
+
+Run `aidp config --interactive` and enable watch mode to configure safety settings interactively.
+
+**Clarification Requests:**
+
+AIDP can automatically request clarification when it needs more information during implementation. This works in both watch mode and interactive mode:
+
+- **Watch Mode**: Posts clarification questions as a GitHub comment, updates labels to `aidp-needs-input`, and waits for user response
+- **Interactive Mode**: Prompts the user directly in the terminal to answer questions before continuing
+
+This ensures AIDP never gets stuck - if it needs more information, it will ask for it rather than making incorrect assumptions or failing silently.
+
+See [Watch Mode Guide](docs/FULLY_AUTOMATIC_MODE.md) and [Watch Mode Safety](docs/WATCH_MODE_SAFETY.md) for complete documentation.
+
 ## Command Reference
 
 ### Copilot Mode
@@ -263,6 +369,20 @@ aidp ws rm <slug> --delete-branch  # Also delete git branch
 aidp ws rm <slug> --force          # Skip confirmation
 ```
 
+### Configuration Commands
+
+```bash
+# Interactive configuration wizard (recommended)
+aidp config --interactive       # Configure all settings including watch mode
+
+# Legacy setup wizard
+aidp --setup-config             # Re-run basic setup wizard
+
+# Help and version
+aidp --help                     # Show all commands
+aidp --version                  # Show version
+```
+
 ### System Commands
 
 ```bash
@@ -275,11 +395,6 @@ aidp providers
 # Harness state management
 aidp harness status
 aidp harness reset
-
-# Configuration
-aidp --setup-config             # Re-run setup wizard
-aidp --help                     # Show all commands
-aidp --version                  # Show version
 ```
 
 ## AI Providers
@@ -291,7 +406,6 @@ AIDP intelligently manages multiple providers with automatic switching:
 - **Cursor CLI** - IDE-integrated provider for code-specific tasks
 - **Gemini CLI** - Google's Gemini command-line interface for general tasks
 - **GitHub Copilot CLI** - GitHub's AI pair programmer command-line interface
-- **macOS UI** - macOS-specific UI automation provider
 - **OpenCode** - Alternative open-source code generation provider
 
 The system automatically switches providers when:

data/lib/aidp/cli.rb

@@ -1231,7 +1231,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]", type: :info)
+          display_message("Usage: aidp watch <issues_url> [--interval SECONDS] [--provider NAME] [--once] [--no-workstreams] [--force] [--verbose]", type: :info)
           return
         end
 
@@ -1240,6 +1240,8 @@ module Aidp
         provider_name = nil
         once = false
         use_workstreams = true # Default to using workstreams
+        force = false
+        verbose = false
 
         until args.empty?
           token = args.shift
@@ -1253,11 +1255,20 @@ module Aidp
             once = true
           when "--no-workstreams"
             use_workstreams = false
+          when "--force"
+            force = true
+          when "--verbose"
+            verbose = true
           else
             display_message("⚠️  Unknown watch option: #{token}", type: :warn)
           end
         end
 
+        # Load watch safety configuration
+        config_manager = Aidp::Harness::ConfigManager.new(Dir.pwd)
+        config = config_manager.config || {}
+        watch_config = config[:watch] || config["watch"] || {}
+
         runner = Aidp::Watch::Runner.new(
           issues_url: issues_url,
           interval: interval.positive? ? interval : Aidp::Watch::Runner::DEFAULT_INTERVAL,
@@ -1265,7 +1276,10 @@ module Aidp
           project_dir: Dir.pwd,
           once: once,
           use_workstreams: use_workstreams,
-          prompt: create_prompt
+          prompt: create_prompt,
+          safety_config: watch_config,
+          force: force,
+          verbose: verbose
         )
         runner.start
       rescue ArgumentError => e

data/lib/aidp/harness/runner.rb

@@ -27,11 +27,12 @@ module Aidp
         waiting_for_rate_limit: "waiting_for_rate_limit",
         stopped: "stopped",
         completed: "completed",
-        error: "error"
+        error: "error",
+        needs_clarification: "needs_clarification"
       }.freeze
 
       # Public accessors for testing and integration
-      attr_reader :current_provider, :current_step, :user_input, :execution_log, :provider_manager
+      attr_reader :current_provider, :current_step, :user_input, :execution_log, :provider_manager, :clarification_questions
 
       def initialize(project_dir, mode = :analyze, options = {})
         @project_dir = project_dir
@@ -132,7 +133,9 @@ module Aidp
           cleanup
         end
 
-        {status: @state, message: get_completion_message}
+        result = {status: @state, message: get_completion_message}
+        result[:clarification_questions] = @clarification_questions if @clarification_questions
+        result
       end
 
       # Pause the harness execution
@@ -248,12 +251,23 @@ module Aidp
       end
 
       def handle_user_feedback_request(result)
-        @state = STATES[:waiting_for_user]
-        log_execution("Waiting for user feedback")
-
         # Extract questions from result
         questions = @condition_detector.extract_questions(result)
 
+        # Check if we're in watch mode (non-interactive)
+        if @options[:workflow_type] == :watch_mode
+          # Store questions for later retrieval and set state to needs_clarification
+          @clarification_questions = questions
+          @state = STATES[:needs_clarification]
+          log_execution("Clarification needed in watch mode", {question_count: questions.size})
+          # Don't continue - exit the loop so we can return this status
+          return
+        end
+
+        # Interactive mode: collect feedback from user
+        @state = STATES[:waiting_for_user]
+        log_execution("Waiting for user feedback")
+
         # Collect user input
         user_responses = @user_interface.collect_feedback(questions)
 

data/lib/aidp/setup/devcontainer/backup_manager.rb

@@ -10,9 +10,10 @@ module Aidp
       class BackupManager
         class BackupError < StandardError; end
 
-        def initialize(project_dir)
+        def initialize(project_dir, clock: Time)
           @project_dir = project_dir
           @backup_dir = File.join(project_dir, ".aidp", "backups", "devcontainer")
+          @clock = clock
         end
 
         # Create a backup of the devcontainer file
@@ -26,7 +27,7 @@ module Aidp
 
           ensure_backup_directory_exists
 
-          timestamp = Time.now.utc.strftime("%Y%m%d_%H%M%S")
+          timestamp = current_time.utc.strftime("%Y%m%d_%H%M%S")
           backup_filename = "devcontainer-#{timestamp}.json"
           backup_path = File.join(@backup_dir, backup_filename)
 
@@ -163,11 +164,17 @@ module Aidp
         end
 
         def parse_timestamp(timestamp_str)
-          return Time.now if timestamp_str.nil?
+          return current_time if timestamp_str.nil?
 
           Time.strptime(timestamp_str, "%Y%m%d_%H%M%S")
         rescue ArgumentError
-          Time.now
+          current_time
+        end
+
+        attr_reader :clock
+
+        def current_time
+          clock.respond_to?(:call) ? clock.call : clock.now
         end
       end
     end

data/lib/aidp/setup/wizard.rb

@@ -786,6 +786,79 @@ module Aidp
           watch_enabled: watch,
           quick_mode_default: quick_mode
         })
+
+        # Configure watch mode settings if enabled
+        configure_watch_mode if watch
+      end
+
+      def configure_watch_mode
+        prompt.say("\n👀 Watch Mode Configuration")
+        prompt.say("-" * 40)
+
+        configure_watch_safety
+        configure_watch_labels
+      end
+
+      def configure_watch_safety
+        prompt.say("\n🔒 Watch mode safety settings")
+        existing = get([:watch, :safety]) || {}
+
+        allow_public_repos = prompt.yes?(
+          "Allow watch mode on public repositories?",
+          default: existing.fetch(:allow_public_repos, false)
+        )
+
+        prompt.say("\n📝 Author allowlist (GitHub usernames allowed to trigger watch mode)")
+        prompt.say("  Leave empty to allow all authors (not recommended for public repos)")
+        author_allowlist = ask_list(
+          "Author allowlist (comma-separated GitHub usernames)",
+          existing[:author_allowlist] || [],
+          allow_empty: true
+        )
+
+        require_container = prompt.yes?(
+          "Require watch mode to run in a container?",
+          default: existing.fetch(:require_container, true)
+        )
+
+        set([:watch, :safety], {
+          allow_public_repos: allow_public_repos,
+          author_allowlist: author_allowlist,
+          require_container: require_container
+        })
+      end
+
+      def configure_watch_labels
+        prompt.say("\n🏷️  Watch mode label configuration")
+        prompt.say("  Configure GitHub issue labels that trigger watch mode actions")
+        existing = get([:watch, :labels]) || {}
+
+        plan_trigger = ask_with_default(
+          "Label to trigger plan generation",
+          existing[:plan_trigger] || "aidp-plan"
+        )
+
+        needs_input = ask_with_default(
+          "Label for plans needing user input",
+          existing[:needs_input] || "aidp-needs-input"
+        )
+
+        ready_to_build = ask_with_default(
+          "Label for plans ready to build",
+          existing[:ready_to_build] || "aidp-ready"
+        )
+
+        build_trigger = ask_with_default(
+          "Label to trigger implementation",
+          existing[:build_trigger] || "aidp-build"
+        )
+
+        set([:watch, :labels], {
+          plan_trigger: plan_trigger,
+          needs_input: needs_input,
+          ready_to_build: ready_to_build,
+          build_trigger: build_trigger
+        })
       end
 
       # -------------------------------------------
@@ -816,6 +889,7 @@ module Aidp
           .sub(/^nfrs:/, "# Non-functional requirements to reference during planning\nnfrs:")
           .sub(/^logging:/, "# Logging configuration\nlogging:")
           .sub(/^modes:/, "# Defaults for background/watch/quick modes\nmodes:")
+          .sub(/^watch:/, "# Watch mode safety and label configuration\nwatch:")
       end
 
       def display_preview(yaml_content)

data/lib/aidp/version.rb

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

data/lib/aidp/watch/build_processor.rb

@@ -15,14 +15,22 @@ module Aidp
     class BuildProcessor
       include Aidp::MessageDisplay
 
-      BUILD_LABEL = "aidp-build"
+      DEFAULT_BUILD_LABEL = "aidp-build"
+      DEFAULT_NEEDS_INPUT_LABEL = "aidp-needs-input"
       IMPLEMENTATION_STEP = "16_IMPLEMENTATION"
 
-      def initialize(repository_client:, state_store:, project_dir: Dir.pwd, use_workstreams: true)
+      attr_reader :build_label, :needs_input_label
+
+      def initialize(repository_client:, state_store:, project_dir: Dir.pwd, use_workstreams: true, verbose: false, label_config: {})
         @repository_client = repository_client
         @state_store = state_store
         @project_dir = project_dir
         @use_workstreams = use_workstreams
+        @verbose = verbose
+
+        # Load label configuration
+        @build_label = label_config[:build_trigger] || label_config["build_trigger"] || DEFAULT_BUILD_LABEL
+        @needs_input_label = label_config[:needs_input] || label_config["needs_input"] || DEFAULT_NEEDS_INPUT_LABEL
       end
 
       def process(issue)
@@ -55,6 +63,8 @@ module Aidp
 
         if result[:status] == "completed"
           handle_success(issue: issue, slug: slug, branch_name: branch_name, base_branch: base_branch, plan_data: plan_data, working_dir: working_dir)
+        elsif result[:status] == "needs_clarification"
+          handle_clarification_request(issue: issue, slug: slug, result: result)
         else
           handle_failure(issue: issue, slug: slug, result: result)
         end
@@ -203,15 +213,33 @@ module Aidp
         prompt_manager = Aidp::Execute::PromptManager.new(working_dir)
         prompt_manager.write(content)
         display_message("📝 Wrote PROMPT.md with implementation contract", type: :info)
+
+        if @verbose
+          display_message("\n--- Implementation Prompt ---", type: :muted)
+          display_message(content.strip, type: :muted)
+          display_message("--- End Prompt ---\n", type: :muted)
+        end
       end
 
       def build_user_input(issue:, plan_data:)
         tasks = Array(plan_value(plan_data, "tasks"))
-        {
+        user_input = {
           "Implementation Contract" => plan_value(plan_data, "summary").to_s,
           "Tasks" => tasks.map { |task| "- #{task}" }.join("\n"),
           "Issue URL" => issue[:url]
         }.delete_if { |_k, v| v.nil? || v.empty? }
+
+        if @verbose
+          display_message("\n--- User Input for Harness ---", type: :muted)
+          user_input.each do |key, value|
+            display_message("#{key}:", type: :muted)
+            display_message(value, type: :muted)
+            display_message("", type: :muted)
+          end
+          display_message("--- End User Input ---\n", type: :muted)
+        end
+
+        user_input
       end
 
       def run_harness(user_input:, working_dir: @project_dir)
@@ -220,8 +248,20 @@ module Aidp
           workflow_type: :watch_mode,
           user_input: user_input
         }
+
+        display_message("🚀 Running harness in execute mode...", type: :info) if @verbose
+
         runner = Aidp::Harness::Runner.new(working_dir, :execute, options)
-        runner.run
+        result = runner.run
+
+        if @verbose
+          display_message("\n--- Harness Result ---", type: :muted)
+          display_message("Status: #{result[:status]}", type: :muted)
+          display_message("Message: #{result[:message]}", type: :muted) if result[:message]
+          display_message("--- End Result ---\n", type: :muted)
+        end
+
+        result
       end
 
       def handle_success(issue:, slug:, branch_name:, base_branch:, plan_data:, working_dir:)
@@ -257,12 +297,62 @@ module Aidp
         )
         display_message("🎉 Posted completion comment for issue ##{issue[:number]}", type: :success)
 
+        # Remove build label after successful completion
+        begin
+          @repository_client.remove_labels(issue[:number], @build_label)
+          display_message("🏷️  Removed '#{@build_label}' label after completion", type: :info)
+        rescue => e
+          display_message("⚠️  Failed to remove build label: #{e.message}", type: :warn)
+          # Don't fail the process if label removal fails
+        end
+
         # Keep workstream for review - don't auto-cleanup on success
         if @use_workstreams
           display_message("ℹ️  Workstream #{slug} preserved for review. Remove with: aidp ws rm #{slug}", type: :muted)
         end
       end
 
+      def handle_clarification_request(issue:, slug:, result:)
+        questions = result[:clarification_questions] || []
+        workstream_note = @use_workstreams ? " The workstream `#{slug}` has been preserved." : " The branch has been preserved."
+
+        # Build comment with questions
+        comment_parts = []
+        comment_parts << "❓ Implementation needs clarification for ##{issue[:number]}."
+        comment_parts << ""
+        comment_parts << "The AI agent needs additional information to proceed with implementation:"
+        comment_parts << ""
+        questions.each_with_index do |question, index|
+          comment_parts << "#{index + 1}. #{question}"
+        end
+        comment_parts << ""
+        comment_parts << "**Next Steps**: Please reply with answers to the questions above. Once resolved, remove the `#{@needs_input_label}` label and add the `#{@build_label}` label to resume implementation."
+        comment_parts << ""
+        comment_parts << workstream_note.to_s
+
+        comment = comment_parts.join("\n")
+        @repository_client.post_comment(issue[:number], comment)
+
+        # Update labels: remove build trigger, add needs input
+        begin
+          @repository_client.replace_labels(
+            issue[:number],
+            old_labels: [@build_label],
+            new_labels: [@needs_input_label]
+          )
+          display_message("🏷️  Updated labels: removed '#{@build_label}', added '#{@needs_input_label}' (needs clarification)", type: :info)
+        rescue => e
+          display_message("⚠️  Failed to update labels for issue ##{issue[:number]}: #{e.message}", type: :warn)
+        end
+
+        @state_store.record_build_status(
+          issue[:number],
+          status: "needs_clarification",
+          details: {questions: questions, workstream: slug}
+        )
+        display_message("💬 Posted clarification request for issue ##{issue[:number]}", type: :success)
+      end
+
       def handle_failure(issue:, slug:, result:)
         message = result[:message] || "Unknown failure"
         workstream_note = @use_workstreams ? " The workstream `#{slug}` has been left intact for debugging." : " The branch has been left intact for debugging."

data/lib/aidp/watch/plan_generator.rb

@@ -26,8 +26,9 @@ module Aidp
         Focus on concrete engineering tasks. Ensure questions are actionable.
       PROMPT
 
-      def initialize(provider_name: nil)
+      def initialize(provider_name: nil, verbose: false)
         @provider_name = provider_name
+        @verbose = verbose
       end
 
       def generate(issue)
@@ -67,7 +68,21 @@ module Aidp
 
       def generate_with_provider(provider, issue)
         payload = build_prompt(issue)
+
+        if @verbose
+          display_message("\n--- Plan Generation Prompt ---", type: :muted)
+          display_message(payload.strip, type: :muted)
+          display_message("--- End Prompt ---\n", type: :muted)
+        end
+
         response = provider.send_message(prompt: payload)
+
+        if @verbose
+          display_message("\n--- Provider Response ---", type: :muted)
+          display_message(response.strip, type: :muted)
+          display_message("--- End Response ---\n", type: :muted)
+        end
+
         parsed = parse_structured_response(response)
 
         return parsed if parsed

data/lib/aidp/watch/plan_processor.rb

@@ -11,13 +11,32 @@ module Aidp
     class PlanProcessor
       include Aidp::MessageDisplay
 
-      PLAN_LABEL = "aidp-plan"
+      # Default label names
+      DEFAULT_PLAN_LABEL = "aidp-plan"
+      DEFAULT_NEEDS_INPUT_LABEL = "aidp-needs-input"
+      DEFAULT_READY_LABEL = "aidp-ready"
+      DEFAULT_BUILD_LABEL = "aidp-build"
+
       COMMENT_HEADER = "## 🤖 AIDP Plan Proposal"
 
-      def initialize(repository_client:, state_store:, plan_generator:)
+      attr_reader :plan_label, :needs_input_label, :ready_label, :build_label
+
+      def initialize(repository_client:, state_store:, plan_generator:, label_config: {})
         @repository_client = repository_client
         @state_store = state_store
         @plan_generator = plan_generator
+
+        # Load label configuration with defaults
+        @plan_label = label_config[:plan_trigger] || label_config["plan_trigger"] || DEFAULT_PLAN_LABEL
+        @needs_input_label = label_config[:needs_input] || label_config["needs_input"] || DEFAULT_NEEDS_INPUT_LABEL
+        @ready_label = label_config[:ready_to_build] || label_config["ready_to_build"] || DEFAULT_READY_LABEL
+        @build_label = label_config[:build_trigger] || label_config["build_trigger"] || DEFAULT_BUILD_LABEL
+      end
+
+      # For backward compatibility
+      def self.plan_label_from_config(config)
+        labels = config[:labels] || config["labels"] || {}
+        labels[:plan_trigger] || labels["plan_trigger"] || DEFAULT_PLAN_LABEL
       end
 
       def process(issue)
@@ -35,14 +54,39 @@ module Aidp
 
         display_message("💬 Posted plan comment for issue ##{number}", type: :success)
         @state_store.record_plan(number, plan_data.merge(comment_body: comment_body, comment_hint: COMMENT_HEADER))
+
+        # Update labels: remove plan trigger, add appropriate status label
+        update_labels_after_plan(number, plan_data)
       end
 
       private
 
+      def update_labels_after_plan(number, plan_data)
+        questions = Array(plan_data[:questions])
+        has_questions = questions.any? && !questions.all? { |q| q.to_s.strip.empty? }
+
+        # Determine which label to add based on whether there are questions
+        new_label = has_questions ? @needs_input_label : @ready_label
+        status_text = has_questions ? "needs input" : "ready to build"
+
+        begin
+          @repository_client.replace_labels(
+            number,
+            old_labels: [@plan_label],
+            new_labels: [new_label]
+          )
+          display_message("🏷️  Updated labels: removed '#{@plan_label}', added '#{new_label}' (#{status_text})", type: :info)
+        rescue => e
+          display_message("⚠️  Failed to update labels for issue ##{number}: #{e.message}", type: :warn)
+          # Don't fail the whole process if label update fails
+        end
+      end
+
       def build_comment(issue:, plan:)
         summary = plan[:summary].to_s.strip
         tasks = Array(plan[:tasks])
         questions = Array(plan[:questions])
+        has_questions = questions.any? && !questions.all? { |q| q.to_s.strip.empty? }
 
         parts = []
         parts << COMMENT_HEADER
@@ -59,7 +103,14 @@ module Aidp
         parts << "### Clarifying Questions"
         parts << format_numbered(questions, placeholder: "_No questions identified_")
         parts << ""
-        parts << "Please reply inline with answers to the questions above. Once the discussion is resolved, apply the `aidp-build` label to begin implementation."
+
+        # Add instructions based on whether there are questions
+        parts << if has_questions
+          "**Next Steps**: Please reply with answers to the questions above. Once resolved, remove the `#{@needs_input_label}` label and add the `#{@build_label}` label to begin implementation."
+        else
+          "**Next Steps**: This plan is ready for implementation. Add the `#{@build_label}` label to begin."
+        end
+
         parts.join("\n")
       end
 

data/lib/aidp/watch/repository_client.rb

@@ -65,6 +65,20 @@ module Aidp
         gh_available? ? create_pull_request_via_gh(title: title, body: body, head: head, base: base, issue_number: issue_number) : raise("GitHub CLI not available - cannot create PR")
       end
 
+      def add_labels(number, *labels)
+        gh_available? ? add_labels_via_gh(number, labels.flatten) : add_labels_via_api(number, labels.flatten)
+      end
+
+      def remove_labels(number, *labels)
+        gh_available? ? remove_labels_via_gh(number, labels.flatten) : remove_labels_via_api(number, labels.flatten)
+      end
+
+      def replace_labels(number, old_labels:, new_labels:)
+        # Remove old labels and add new ones atomically where possible
+        remove_labels(number, *old_labels) unless old_labels.empty?
+        add_labels(number, *new_labels) unless new_labels.empty?
+      end
+
       private
 
       def list_issues_via_gh(labels:, state:)
@@ -180,6 +194,66 @@ module Aidp
         stdout.strip
       end
 
+      def add_labels_via_gh(number, labels)
+        return if labels.empty?
+
+        cmd = ["gh", "issue", "edit", number.to_s, "--repo", full_repo]
+        labels.each { |label| cmd += ["--add-label", label] }
+
+        stdout, stderr, status = Open3.capture3(*cmd)
+        raise "Failed to add labels via gh: #{stderr.strip}" unless status.success?
+
+        stdout.strip
+      end
+
+      def add_labels_via_api(number, labels)
+        return if labels.empty?
+
+        uri = URI("https://api.github.com/repos/#{full_repo}/issues/#{number}/labels")
+        request = Net::HTTP::Post.new(uri)
+        request["Content-Type"] = "application/json"
+        request.body = JSON.dump({labels: labels})
+
+        response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
+          http.request(request)
+        end
+
+        raise "Failed to add labels via API (#{response.code})" unless response.code.start_with?("2")
+        response.body
+      end
+
+      def remove_labels_via_gh(number, labels)
+        return if labels.empty?
+
+        cmd = ["gh", "issue", "edit", number.to_s, "--repo", full_repo]
+        labels.each { |label| cmd += ["--remove-label", label] }
+
+        stdout, stderr, status = Open3.capture3(*cmd)
+        raise "Failed to remove labels via gh: #{stderr.strip}" unless status.success?
+
+        stdout.strip
+      end
+
+      def remove_labels_via_api(number, labels)
+        return if labels.empty?
+
+        labels.each do |label|
+          # URL encode the label name
+          encoded_label = URI.encode_www_form_component(label)
+          uri = URI("https://api.github.com/repos/#{full_repo}/issues/#{number}/labels/#{encoded_label}")
+          request = Net::HTTP::Delete.new(uri)
+
+          response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
+            http.request(request)
+          end
+
+          # 404 is OK - label didn't exist
+          unless response.code.start_with?("2") || response.code == "404"
+            raise "Failed to remove label '#{label}' via API (#{response.code})"
+          end
+        end
+      end
+
       def normalize_issue(raw)
         {
           number: raw["number"],

data/lib/aidp/watch/repository_safety_checker.rb

@@ -163,16 +163,25 @@ module Aidp
       end
 
       def public_repos_allowed?
-        @config.dig(:safety, :allow_public_repos) == true
+        # Support both string and symbol keys
+        safety_config = @config[:safety] || @config["safety"] || {}
+        (safety_config[:allow_public_repos] || safety_config["allow_public_repos"]) == true
       end
 
       def author_allowlist
-        @author_allowlist ||= Array(@config.dig(:safety, :author_allowlist)).compact.map(&:to_s)
+        # Support both string and symbol keys
+        safety_config = @config[:safety] || @config["safety"] || {}
+        @author_allowlist ||= Array(
+          safety_config[:author_allowlist] || safety_config["author_allowlist"]
+        ).compact.map(&:to_s)
       end
 
       def safe_environment?
         # Check if running in a container
-        in_container? || @config.dig(:safety, :require_container) == false
+        # Support both string and symbol keys
+        safety_config = @config[:safety] || @config["safety"] || {}
+        require_container = safety_config[:require_container] || safety_config["require_container"]
+        in_container? || require_container == false
       end
 
       def in_container?

data/lib/aidp/watch/runner.rb

@@ -19,12 +19,13 @@ module Aidp
 
       DEFAULT_INTERVAL = 30
 
-      def initialize(issues_url:, interval: DEFAULT_INTERVAL, provider_name: nil, gh_available: nil, project_dir: Dir.pwd, once: false, use_workstreams: true, prompt: TTY::Prompt.new, safety_config: {}, force: false)
+      def initialize(issues_url:, interval: DEFAULT_INTERVAL, provider_name: nil, gh_available: nil, project_dir: Dir.pwd, once: false, use_workstreams: true, prompt: TTY::Prompt.new, safety_config: {}, force: false, verbose: false)
         @prompt = prompt
         @interval = interval
         @once = once
         @project_dir = project_dir
         @force = force
+        @verbose = verbose
 
         owner, repo = RepositoryClient.parse_issues_url(issues_url)
         @repository_client = RepositoryClient.new(owner: owner, repo: repo, gh_available: gh_available)
@@ -33,16 +34,23 @@ module Aidp
           config: safety_config
         )
         @state_store = StateStore.new(project_dir: project_dir, repository: "#{owner}/#{repo}")
+
+        # Extract label configuration from safety_config (it's actually the full watch config)
+        label_config = safety_config[:labels] || safety_config["labels"] || {}
+
         @plan_processor = PlanProcessor.new(
           repository_client: @repository_client,
           state_store: @state_store,
-          plan_generator: PlanGenerator.new(provider_name: provider_name)
+          plan_generator: PlanGenerator.new(provider_name: provider_name, verbose: verbose),
+          label_config: label_config
         )
         @build_processor = BuildProcessor.new(
           repository_client: @repository_client,
           state_store: @state_store,
           project_dir: project_dir,
-          use_workstreams: use_workstreams
+          use_workstreams: use_workstreams,
+          verbose: verbose,
+          label_config: label_config
         )
       end
 
@@ -73,9 +81,10 @@ module Aidp
       end
 
       def process_plan_triggers
-        issues = @repository_client.list_issues(labels: [PlanProcessor::PLAN_LABEL], state: "open")
+        plan_label = @plan_processor.plan_label
+        issues = @repository_client.list_issues(labels: [plan_label], state: "open")
         issues.each do |issue|
-          next unless issue_has_label?(issue, PlanProcessor::PLAN_LABEL)
+          next unless issue_has_label?(issue, plan_label)
 
           detailed = @repository_client.fetch_issue(issue[:number])
 
@@ -89,9 +98,10 @@ module Aidp
       end
 
       def process_build_triggers
-        issues = @repository_client.list_issues(labels: [BuildProcessor::BUILD_LABEL], state: "open")
+        build_label = @build_processor.build_label
+        issues = @repository_client.list_issues(labels: [build_label], state: "open")
         issues.each do |issue|
-          next unless issue_has_label?(issue, BuildProcessor::BUILD_LABEL)
+          next unless issue_has_label?(issue, build_label)
 
           status = @state_store.build_status(issue[:number])
           next if status["status"] == "completed"

metadata

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