brainiac-basecamp 0.0.13 → 0.0.15

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8adcfd4dedeee9ee8fee1e9439e80f7f3917d81ece1c5420a3777619df8d7ab5
-  data.tar.gz: d88eb5a5e18d8bea39522ccfa6c8fbac13b2b50f87a28a29c6c1b8958e4f3eea
+  metadata.gz: e8e71f8f043a52cb54d83e974031b0bb83339f02452e701bf381e4e87b32274d
+  data.tar.gz: ac57b522a30cdb3cdf42c0aca069c52bb1ce27b2b93fdbdf4b63a2c9f57088b9
 SHA512:
-  metadata.gz: 311711ad321fe576e24aeb51d82d9dffc4b9d2b6199b8f6b6242b7405583f224d1686d4b91cc395d3e16985dd73834324cbe539fe216f2eb22962a4f34d05d2d
-  data.tar.gz: 7ccb5d585757a9b87b5dfa88512e44528048c153d4d5e159c4e62baa9c78f904dec5333899abdbaeec46b0a8da0ac6bfbd1cd39ca2530030f1d6e05e3a1d096c
+  metadata.gz: 955cfcffe81b1856b0ee90e8c2124b48d13b3de28db1e258054069442b8a67096deeb95cda1b5ce0e21b20cd2b78e3bd7c73fd107c5753c3de82ef0ead916d01
+  data.tar.gz: 7b6e92a54b136065013d178d3422bc7583958f83b161184c9905b2d950898907ee1eebdffa6d2cf07bc7394836b98aef52acd8bb50583231b2b6b8f2f9ca3247

data/lib/brainiac/plugins/basecamp/hooks.rb

@@ -16,7 +16,7 @@ module Brainiac
       #   :resolve_base_branch — returns epic branch as worktree base
       #   :resolve_pr_target — returns epic branch as PR target
       module Hooks
-        class << self
+        class << self # rubocop:disable Metrics/ClassLength
           def register_all!
             register_agent_completed
             register_pr_merged
@@ -380,14 +380,39 @@ module Brainiac
               next unless epic["review_gate"] == "epic_branch" && ReviewGate.enabled?
 
               task = epic["tasks"].find { |t| t["fizzy_card"] == card_number.to_i }
-              # Re-trigger gates if task is in_flight (agent working/pushed fixes)
-              # No need to check for prior reviews — if task is in_flight with a PR, gates should review
-              next unless task && task["status"] == "in_flight" && task["pr_number"]
+              next unless task && task["status"] == "in_flight"
+
+              # Ensure pr_number is set — it may be missing if initial gate dispatch
+              # failed to persist it or if state was lost during serialization.
+              unless task["pr_number"]
+                pr_number = ctx.dig(:pull_request, "number") || ctx[:pr_number]
+                if pr_number
+                  task["pr_number"] = pr_number.to_i
+                  LOG.info "[Basecamp:Hooks] Backfilled pr_number=#{pr_number} for card ##{card_number}" if defined?(LOG)
+                else
+                  # Try to find it from the branch
+                  project_key = task["project"] || Config.brainiac_project_for(epic["basecamp_project_id"])
+                  projects_file = File.join(ENV.fetch("BRAINIAC_DIR", File.join(Dir.home, ".brainiac")), "projects.json")
+                  projects = File.exist?(projects_file) ? JSON.parse(File.read(projects_file)) : {}
+                  repo_path = projects.dig(project_key, "repo_path")
+                  if repo_path
+                    branch = ctx[:branch] || "fizzy-#{card_number}-*"
+                    found_pr = find_pr_number(repo_path: repo_path, branch: branch)
+                    if found_pr
+                      task["pr_number"] = found_pr
+                      LOG.info "[Basecamp:Hooks] Resolved pr_number=#{found_pr} for card ##{card_number} via branch lookup" if defined?(LOG)
+                    end
+                  end
+                end
+              end
+
+              next unless task["pr_number"]
 
               LOG.info "[Basecamp:Hooks] PR updated for card ##{card_number} — re-triggering review gates" if defined?(LOG)
 
               # Reset approvals and re-dispatch gates
               ReviewGate.reset_approvals(task)
+              task["changes_requested_by"] = []
               task["status"] = "in_review"
               epic["updated_at"] = Time.now.iso8601
               save_epic_state(epic)
@@ -821,6 +846,21 @@ module Brainiac
               return
             end
 
+            # Ensure pr_number is set — look it up if missing.
+            # This is critical for the pr_synchronized hook to re-trigger gates after fixes.
+            unless pr_number
+              found_pr = find_pr_number(repo_path: repo_path, branch: "fizzy-#{card_number}-*")
+              if found_pr
+                pr_number = found_pr
+                task["pr_number"] = pr_number
+                task["pr_repo"] = project_config["github_repo"]
+                save_epic_state(epic)
+                LOG.info "[Basecamp:Hooks] Backfilled pr_number=#{pr_number} for card ##{card_number} during direct dispatch" if defined?(LOG)
+              elsif defined?(LOG)
+                LOG.warn "[Basecamp:Hooks] Could not find PR for card ##{card_number} — gates won't re-trigger after fixes"
+              end
+            end
+
             # Find the worktree for this card
             work_items_file = File.join(ENV.fetch("BRAINIAC_DIR", File.join(Dir.home, ".brainiac")), "work_items.json")
             worktree_path = repo_path  # Default to main repo

data/lib/brainiac/plugins/basecamp/orchestrator.rb

@@ -189,6 +189,8 @@ module Brainiac
             load_epics.find { |e| e["id"] == epic_id }
           end
 
+          WEBHOOK_CHECK_COOLDOWN = 300 # 5 minutes
+
           private
 
           # Resolve current todolist state from Basecamp and dispatch unblocked cards.
@@ -264,7 +266,9 @@ module Brainiac
           end
 
           # Dispatch unblocked tasks that aren't already in-flight or complete.
+          # Ensures Fizzy webhooks are active before dispatching (prevents silent failures).
           def dispatch_unblocked_tasks(epic)
+            ensure_fizzy_webhooks_active
             tasks = epic["tasks"].map do |t|
               Epic::Task.new(
                 todo_id: t["todo_id"],
@@ -316,7 +320,9 @@ module Brainiac
 
             log_event(epic, "dispatched", "Card ##{card_number} dispatched to #{agent}")
 
-            # Assign the card in Fizzy via CLI — this triggers the normal Fizzy webhook flow
+            # Assign the card in Fizzy via CLI — this triggers the normal Fizzy webhook flow.
+            # If the agent is already assigned (stale state from a disabled webhook),
+            # the method will cycle the assignment to re-trigger the webhook.
             assign_fizzy_card(card_number, agent)
 
             # Post a comment on the Basecamp todo
@@ -416,7 +422,10 @@ module Brainiac
           end
 
           # Assign a Fizzy card to an agent via Fizzy CLI.
-          # If the agent is already assigned, skip — the webhook should have already fired.
+          # If the agent is already assigned, unassigns and reassigns to re-trigger the webhook
+          # (Fizzy webhooks can silently become disabled, causing the original assignment to be lost).
+          #
+          # @return [Symbol] :assigned, :reassigned, or :failed
           def assign_fizzy_card(card_number, agent)
             agent_config = load_agent_registry[agent.downcase]
             fizzy_name = agent_config&.dig("fizzy_name") || agent
@@ -425,18 +434,34 @@ module Brainiac
             fizzy_user_id = resolve_fizzy_user_id(fizzy_name)
             unless fizzy_user_id
               LOG.error "[Basecamp:Orchestrator] Could not resolve Fizzy user ID for '#{fizzy_name}'" if defined?(LOG)
-              return
+              return :failed
             end
 
-            # Check if agent is already assigned — if so, skip (webhook should have fired)
+            # Check if agent is already assigned
             stdout, _, status = Open3.capture3("fizzy", "card", "show", card_number.to_s, "--json")
             if status.success?
               card_data = JSON.parse(stdout).dig("data") rescue nil
               if card_data
                 current_assignees = (card_data["assignees"] || []).map { |a| a["id"] }
                 if current_assignees.include?(fizzy_user_id)
-                  LOG.info "[Basecamp:Orchestrator] Agent already assigned to ##{card_number}, skipping (webhook should have fired)" if defined?(LOG)
-                  return
+                  # Agent is already assigned — webhook may not have fired (disabled webhook).
+                  # Unassign then reassign to trigger a fresh webhook delivery.
+                  LOG.warn "[Basecamp:Orchestrator] Agent already assigned to ##{card_number} — " \
+                           "cycling assignment to re-trigger webhook" if defined?(LOG)
+
+                  # Fizzy assign TOGGLES, so calling it removes the assignment
+                  Open3.capture3("fizzy", "card", "assign", card_number.to_s, "--user", fizzy_user_id)
+                  sleep 1 # Brief pause to ensure the unassign is processed
+
+                  # Now reassign — this should trigger the webhook
+                  stdout2, stderr2, status2 = Open3.capture3("fizzy", "card", "assign", card_number.to_s, "--user", fizzy_user_id)
+                  if status2.success?
+                    LOG.info "[Basecamp:Orchestrator] Reassigned Fizzy ##{card_number} to #{fizzy_name} (webhook re-triggered)" if defined?(LOG)
+                    return :reassigned
+                  else
+                    LOG.error "[Basecamp:Orchestrator] Failed to reassign Fizzy ##{card_number}: #{stderr2.strip}" if defined?(LOG)
+                    return :failed
+                  end
                 end
               end
             end
@@ -445,11 +470,77 @@ module Brainiac
 
             if status.success?
               LOG.info "[Basecamp:Orchestrator] Assigned Fizzy ##{card_number} to #{fizzy_name} (#{fizzy_user_id})" if defined?(LOG)
+              :assigned
             else
               LOG.error "[Basecamp:Orchestrator] Failed to assign Fizzy ##{card_number}: #{stderr.strip}" if defined?(LOG)
+              :failed
             end
           rescue Errno::ENOENT => e
             LOG.error "[Basecamp:Orchestrator] fizzy CLI not found: #{e.message}" if defined?(LOG)
+            :failed
+          end
+
+          # Ensure Fizzy webhooks are active before dispatching cards.
+          # Fizzy webhooks can silently become disabled (e.g., after repeated delivery failures),
+          # causing assigned cards to never trigger agent work. This pre-flight check reactivates
+          # any disabled brainiac webhooks.
+          #
+          # Uses a cooldown to avoid hammering the API on every dispatch batch.
+          def ensure_fizzy_webhooks_active
+            now = Time.now
+            @last_webhook_check ||= Time.at(0)
+            return if (now - @last_webhook_check) < WEBHOOK_CHECK_COOLDOWN
+
+            @last_webhook_check = now
+
+            # Read fizzy config to get admin_token and board list
+            fizzy_config_file = File.join(BRAINIAC_DIR, "fizzy.json")
+            return unless File.exist?(fizzy_config_file)
+
+            fizzy_config = JSON.parse(File.read(fizzy_config_file))
+            admin_token = fizzy_config["admin_token"]
+            boards = fizzy_config["boards"] || {}
+
+            unless admin_token
+              LOG.debug "[Basecamp:Orchestrator] Fizzy webhook check skipped (no admin_token in fizzy.json)" if defined?(LOG)
+              return
+            end
+
+            env = { "FIZZY_TOKEN" => admin_token }
+            reactivated = 0
+
+            boards.each do |board_key, board_config|
+              board_id = board_config["board_id"]
+              next unless board_id
+
+              stdout, _, status = Open3.capture3(env, "fizzy", "webhook", "list",
+                                                 "--board", board_id, "--all", "--json",
+                                                 chdir: Dir.home)
+              next unless status.success?
+
+              webhooks = JSON.parse(stdout)["data"] || []
+              webhooks.each do |webhook|
+                next unless webhook["name"]&.start_with?("brainiac")
+                next if webhook["active"]
+
+                wh_name = webhook["name"]
+                LOG.warn "[Basecamp:Orchestrator] Fizzy webhook '#{wh_name}' on board '#{board_key}' is INACTIVE — reactivating" if defined?(LOG)
+                _, _, reactivate_status = Open3.capture3(env, "fizzy", "webhook", "reactivate", webhook["id"],
+                                                         "--board", board_id, chdir: Dir.home)
+                if reactivate_status.success?
+                  reactivated += 1
+                  LOG.info "[Basecamp:Orchestrator] Reactivated webhook '#{webhook['name']}' on board '#{board_key}'" if defined?(LOG)
+                else
+                  LOG.error "[Basecamp:Orchestrator] Failed to reactivate webhook '#{webhook['name']}' on board '#{board_key}'" if defined?(LOG)
+                end
+              end
+            rescue StandardError => e
+              LOG.warn "[Basecamp:Orchestrator] Webhook check failed for board '#{board_key}': #{e.message}" if defined?(LOG)
+            end
+
+            LOG.info "[Basecamp:Orchestrator] Fizzy webhook health check: #{reactivated} reactivated" if reactivated.positive?
+          rescue StandardError => e
+            LOG.warn "[Basecamp:Orchestrator] Fizzy webhook health check failed: #{e.message}" if defined?(LOG)
           end
 
           # Resolve a Fizzy user ID from their display name.
@@ -631,6 +722,15 @@ module Brainiac
                            profile: epic["agent"]&.downcase)
           end
 
+          # Mark a Basecamp todo as incomplete (undo premature completion).
+          def uncheck_todo(epic, card_number)
+            task = epic["tasks"].find { |t| t["fizzy_card"] == card_number.to_i }
+            return unless task && task["todo_id"]
+
+            Client.run_safe("todos", "uncomplete", task["todo_id"].to_s, "--json",
+                           profile: epic["agent"]&.downcase)
+          end
+
           # Post a completion comment on the Basecamp todo.
           def post_completion_comment(epic, card_number)
             task = epic["tasks"].find { |t| t["fizzy_card"] == card_number.to_i }

data/lib/brainiac/plugins/basecamp/version.rb

@@ -3,7 +3,7 @@
 module Brainiac
   module Plugins
     module Basecamp
-      VERSION = "0.0.13"
+      VERSION = "0.0.15"
     end
   end
 end

data/lib/brainiac/plugins/basecamp.rb

@@ -160,7 +160,19 @@ module Brainiac
 
             when "in_review"
               # Check if all gates have actually approved (webhook might have missed)
-              if pr_number && project_key && ReviewGate.enabled?
+              # Resolve pr_number if missing/zero (same pattern as final_decision)
+              effective_pr = pr_number
+              if (effective_pr.nil? || effective_pr.zero?) && project_key
+                resolved = resolve_pr_for_task(task)
+                if resolved
+                  task["pr_number"] = resolved[:number]
+                  task["pr_repo"] = resolved[:repo] if resolved[:repo]
+                  effective_pr = resolved[:number]
+                  LOG.info "[Basecamp:HealthCheck] Resolved PR ##{effective_pr} for in_review card ##{card_number}" if defined?(LOG)
+                end
+              end
+
+              if effective_pr&.positive? && project_key && ReviewGate.enabled?
                 projects_file = File.join(ENV.fetch("BRAINIAC_DIR", File.join(Dir.home, ".brainiac")), "projects.json")
                 projects = File.exist?(projects_file) ? JSON.parse(File.read(projects_file)) : {}
                 repo_path = projects.dig(project_key, "repo_path")
@@ -178,6 +190,28 @@ module Brainiac
                     Hooks.send(:save_epic_state, epic)
                     Hooks.send(:dispatch_final_decision, epic, task, {})
                     healed_any = true
+                  elsif task["changes_requested_by"]&.any? && pr_has_newer_commits_than_reviews?(task, repo_path: repo_path)
+                    # Changes were requested but the impl agent has already pushed fixes.
+                    # The pr_synchronized hook missed this (pr_number was 0, or status wasn't in_flight).
+                    # Reset approvals and re-dispatch gates to review the new code.
+                    LOG.info "[Basecamp:HealthCheck] PR has commits newer than last changes_requested review for ##{card_number} — re-dispatching gates" if defined?(LOG)
+                    ReviewGate.reset_approvals(task)
+                    task["changes_requested_by"] = []
+                    task["gates_dispatched_at"] = Time.now.iso8601
+                    Hooks.send(:save_epic_state, epic)
+
+                    Thread.new do
+                      ReviewGate.dispatch_gates(
+                        epic: epic,
+                        task: task,
+                        pr_number: effective_pr,
+                        repo_name: github_repo,
+                        repo_path: repo_path
+                      )
+                    rescue StandardError => e
+                      LOG.error "[Basecamp:HealthCheck] Gate re-dispatch failed for ##{card_number}: #{e.message}" if defined?(LOG)
+                    end
+                    healed_any = true
                   elsif Hooks.send(:all_gates_responded?, task) && task["changes_requested_by"]&.any?
                     # All gates responded but some requested changes — need to dispatch impl agent
                     impl_agent = epic["agent"]
@@ -208,7 +242,7 @@ module Brainiac
                       ReviewGate.dispatch_gates(
                         epic: epic,
                         task: task,
-                        pr_number: pr_number,
+                        pr_number: effective_pr,
                         repo_name: github_repo,
                         repo_path: repo_path
                       )
@@ -226,7 +260,7 @@ module Brainiac
                         ReviewGate.dispatch_missing_gates(
                           epic: epic,
                           task: task,
-                          pr_number: pr_number,
+                          pr_number: effective_pr,
                           repo_name: github_repo,
                           repo_path: repo_path
                         )
@@ -237,6 +271,65 @@ module Brainiac
                   end
                 end
               end
+
+            when "complete"
+              # Sanity check: verify the PR is actually merged before accepting "complete" status.
+              # Catches race conditions where rapid review cycles cause premature task completion.
+              next unless project_key
+
+              effective_pr = pr_number
+              if effective_pr.nil? || effective_pr.zero?
+                resolved = resolve_pr_for_task(task)
+                if resolved
+                  task["pr_number"] = resolved[:number]
+                  task["pr_repo"] = resolved[:repo] if resolved[:repo]
+                  effective_pr = resolved[:number]
+                end
+              end
+
+              # If we can't find a PR, we can't verify — skip (might be a no-code task)
+              next unless effective_pr&.positive?
+
+              projects_file = File.join(ENV.fetch("BRAINIAC_DIR", File.join(Dir.home, ".brainiac")), "projects.json")
+              projects = File.exist?(projects_file) ? JSON.parse(File.read(projects_file)) : {}
+              github_repo = projects.dig(project_key, "github_repo")
+              repo_path = projects.dig(project_key, "repo_path")
+              next unless github_repo
+
+              pr_state, = Open3.capture2("gh", "pr", "view", effective_pr.to_s, "--repo", github_repo, "--json", "state", "-q", ".state")
+              pr_state = pr_state.strip
+
+              if pr_state == "OPEN"
+                # PR is NOT merged — task was prematurely marked complete.
+                # Revert to in_review and re-dispatch gates to review current state.
+                LOG.info "[Basecamp:HealthCheck] Task ##{card_number} marked complete but PR ##{effective_pr} is still OPEN — reverting to in_review" if defined?(LOG)
+
+                task["status"] = "in_review"
+                task.delete("completed_at")
+                task["gate_approvals"] = []
+                task["changes_requested_by"] = []
+                task["gates_dispatched_at"] = Time.now.iso8601
+                Hooks.send(:save_epic_state, epic)
+
+                # Uncheck the Basecamp todo (it was incorrectly checked)
+                Orchestrator.send(:uncheck_todo, epic, card_number) if Orchestrator.respond_to?(:uncheck_todo, true)
+
+                # Re-dispatch review gates
+                if ReviewGate.enabled? && repo_path
+                  Thread.new do
+                    ReviewGate.dispatch_gates(
+                      epic: epic,
+                      task: task,
+                      pr_number: effective_pr,
+                      repo_name: github_repo,
+                      repo_path: repo_path
+                    )
+                  rescue StandardError => e
+                    LOG.error "[Basecamp:HealthCheck] Gate dispatch failed for ##{card_number}: #{e.message}" if defined?(LOG)
+                  end
+                end
+                healed_any = true
+              end
             end
           end
 
@@ -249,6 +342,36 @@ module Brainiac
 
         private
 
+        # Check if a PR has commits newer than the most recent changes_requested review.
+        # This detects when the impl agent pushed fixes but gates weren't re-triggered.
+        #
+        # @param task [Hash] Task state with pr_number
+        # @param repo_path [String] Local repo path for gh CLI
+        # @return [Boolean] true if PR has commits after the last changes_requested review
+        def pr_has_newer_commits_than_reviews?(task, repo_path:)
+          pr_number = task["pr_number"]
+          return false unless pr_number&.positive?
+
+          # Get the last changes_requested review timestamp and the latest commit timestamp
+          stdout, _, status = Open3.capture3(
+            "gh", "pr", "view", pr_number.to_s,
+            "--json", "reviews,commits",
+            "--jq", "[(.reviews | map(select(.state == \"CHANGES_REQUESTED\")) | sort_by(.submittedAt) | last | .submittedAt), (.commits | last | .committedDate)] | @tsv",
+            chdir: repo_path
+          )
+          return false unless status.success? && !stdout.strip.empty?
+
+          last_changes_at, last_commit_at = stdout.strip.split("\t")
+          return false if last_changes_at.nil? || last_changes_at.empty? || last_commit_at.nil? || last_commit_at.empty?
+
+          # Compare timestamps — if the latest commit is newer than the last changes_requested review,
+          # the impl agent has pushed fixes that haven't been reviewed yet.
+          Time.parse(last_commit_at) > Time.parse(last_changes_at)
+        rescue StandardError => e
+          LOG.warn "[Basecamp:HealthCheck] Error checking PR commits vs reviews: #{e.message}" if defined?(LOG)
+          false
+        end
+
         # Resume active epics on server startup.
         # For each epic, checks task states and takes appropriate action.
         def resume_active_epics(epics)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: brainiac-basecamp
 version: !ruby/object:Gem::Version
-  version: 0.0.13
+  version: 0.0.15
 platform: ruby
 authors:
 - Andy Davis