brainiac-basecamp 0.0.12 → 0.0.14

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1eb44286a14e4c833e7ee753cf3ced44e6579eea0d37ff0c1289db149cc1c97c
-  data.tar.gz: b24e2ed8efe6a611f3d3790dfd38a906cd753c8c766743ab50302f365430d8db
+  metadata.gz: 14642b9582bda42dff7932fe0b518957bdeb638431de432df6beae906c3206e5
+  data.tar.gz: 2fac38d27c6c89445d49af1b8e3148bcfa25d8d6632de11984fca1dbd772dcf2
 SHA512:
-  metadata.gz: 106c01e99ca88a0ee5d2801cb632b17fdcace3bd3ea9fe17278cae2cbfa3560f1669c164bf6a12472fc4451bdc81833889aaad2c273b936df77ead50f1736450
-  data.tar.gz: f766419152f38af5404a7640ac87c19540814480e67a1e12ee14621595075d0fc7fc204ed33475022a090c74fbfa97ab8b5a3929c9eedfe3458b2f46345a7fa0
+  metadata.gz: f1c4b21c180b3a8306770e922c8c4c8bdb65976a1a62f9dbe02541cb4049d635ac4745f469275ad13bd1168811148cb772965e0b64e4d5b0fdac9b0eb4b7c200
+  data.tar.gz: 7a063d983c097531096ff5d8f954050842f0b775f136f6ec1694111ab0bd9561f061b859e33a9497a7b69b8ed7e3a1aa0725d7c70895556e83789920fedc1f72

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

@@ -156,10 +156,75 @@ module Brainiac
             # If project is set, look up directly
             return epic_branches[project_key] if project_key && epic_branches[project_key]
 
-            # Fallback: if there's only one epic branch, use it (single-project epic)
-            return epic_branches.values.first if epic_branches.size == 1
+            # Fallback: if there's only one epic branch AND the task has no specific project set,
+            # use it (assumed single-project epic).
+            # Do NOT fallback if the task has a specific project that isn't in epic_branches —
+            # that means the branch wasn't created for this repo and we should return nil
+            # (letting the default branch be used) rather than returning a branch from a different repo.
+            return epic_branches.values.first if epic_branches.size == 1 && !project_key
+
+            # Multi-project epic but no matching branch for this task's project — return nil
+            nil
+          end
+
+          # Lazily ensure an epic branch exists for a card's project.
+          # Called when epic_branch_for_card returns nil but the card IS in an active epic.
+          # Creates the branch in the task's repo and registers it in epic state.
+          #
+          # @param card_number [Integer, String] Fizzy card number
+          # @return [String, nil] Epic branch name or nil
+          def ensure_epic_branch_for_card(card_number)
+            epic = Orchestrator.find_epic_for_card(card_number.to_i)
+            return nil unless epic
+            return nil unless epic["review_gate"] == "epic_branch"
+
+            task = epic["tasks"]&.find { |t| t["fizzy_card"] == card_number.to_i }
+            return nil unless task
+
+            project_key = task["project"]
+            return nil unless project_key
 
-            # Multi-project epic but no project on task — can't determine which branch
+            # Already have a branch for this project
+            epic_branches = epic["epic_branches"] || {}
+            return epic_branches[project_key] if epic_branches[project_key]
+
+            # Resolve repo path for this project
+            projects_file = File.join(BRAINIAC_DIR, "projects.json")
+            return nil unless File.exist?(projects_file)
+
+            all_projects = JSON.parse(File.read(projects_file))
+            repo_path = all_projects.dig(project_key, "repo_path")
+            return nil unless repo_path
+
+            # Create the branch
+            slug = branch_slug(epic["title"])
+            branch_name = "epic/#{slug}"
+            default_branch = detect_default_branch(repo_path)
+
+            run_git("fetch", "origin", chdir: repo_path)
+
+            # Check if branch already exists remotely
+            remote_exists = system("git", "ls-remote", "--exit-code", "--heads", "origin", branch_name,
+                                   chdir: repo_path, out: File::NULL, err: File::NULL)
+
+            if remote_exists
+              run_git("fetch", "origin", "#{branch_name}:#{branch_name}", chdir: repo_path)
+              LOG.info "[Basecamp:EpicBranch] Lazy-created: reusing existing '#{branch_name}' in #{project_key}" if defined?(LOG)
+            else
+              run_git("branch", branch_name, "origin/#{default_branch}", chdir: repo_path)
+              run_git("push", "-u", "origin", branch_name, chdir: repo_path)
+              LOG.info "[Basecamp:EpicBranch] Lazy-created: new '#{branch_name}' in #{project_key}" if defined?(LOG)
+            end
+
+            # Register in epic state
+            epic["epic_branches"] ||= {}
+            epic["epic_branches"][project_key] = branch_name
+            epic["updated_at"] = Time.now.iso8601
+            Orchestrator.send(:save_epic, epic)
+
+            branch_name
+          rescue StandardError => e
+            LOG.error "[Basecamp:EpicBranch] Lazy branch creation failed for #{project_key}: #{e.message}" if defined?(LOG)
             nil
           end
 

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

@@ -482,12 +482,17 @@ module Brainiac
           end
 
           # Return the epic branch as the worktree base for cards in an active epic.
+          # If the epic branch doesn't exist for this task's project yet, create it lazily.
           def register_resolve_base_branch
             Brainiac.on(:resolve_base_branch) do |ctx|
               card_number = ctx[:card_number]
               next unless card_number
 
               branch = EpicBranch.epic_branch_for_card(card_number)
+
+              # Lazy creation: if no branch exists for this task's project, create one now
+              branch ||= EpicBranch.ensure_epic_branch_for_card(card_number)
+
               next unless branch
 
               "origin/#{branch}"
@@ -495,12 +500,15 @@ module Brainiac
           end
 
           # Return the epic branch as the PR target for cards in an active epic.
+          # Same lazy-creation logic as resolve_base_branch.
           def register_resolve_pr_target
             Brainiac.on(:resolve_pr_target) do |ctx|
               card_number = ctx[:card_number]
               next unless card_number
 
-              EpicBranch.epic_branch_for_card(card_number)
+              branch = EpicBranch.epic_branch_for_card(card_number)
+              branch ||= EpicBranch.ensure_epic_branch_for_card(card_number)
+              branch
             end
           end
 

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.12"
+      VERSION = "0.0.14"
     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.12
+  version: 0.0.14
 platform: ruby
 authors:
 - Andy Davis