brainiac-basecamp 0.0.7 → 0.0.11

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6bffdae0c7f62eef1cf55ee5c2c23fb8594dd63afc96ffee5cf3c58cdca9ce9f
-  data.tar.gz: 3b61e5ae5ef532935c07603c55f6fa36000796ed55951e8277205c219306600b
+  metadata.gz: d4d21875fecdd7aa33718a8db5fa446800e8a85924490b6716a455b211d79483
+  data.tar.gz: 9601289488c260e891a6df6da2b63be3e9965c9c8235d11c4366622d27a24d0b
 SHA512:
-  metadata.gz: 6eaa711a5cd134e1838335dbf31813d44ac66b6bb596d731a8c89dde9f99ecc8bca8aea65054fa166da8f40f16cec5df1509719fc201bc82bdeb55fce99abca5
-  data.tar.gz: d60e2e46e81dd1a1798127583e6be1620fcd136c482e369fd7b7c129f5a5074cf88edf2cb2b6f6d7bd3a258372feea0886834cfabcc421081f872c89e9bd96a5
+  metadata.gz: f24339950cce469195888d59fbc7ddecb0b75f9a7f8279df58cc2bb681637916525341ce8b9fc86c2f38bb9e8b1718a27c9f164d14afa4acff9376f4394da3eb
+  data.tar.gz: 39d9128c65180e56fe30e59d6b384dbc9ce2b7648f8586498b88e7e44b4c516fcea6d06b279bc1956373f84f1a8602aa1fb697699a40b98e699b2c6ef2f97c59

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

@@ -214,16 +214,12 @@ module Brainiac
                   # All gates have reviewed — dispatch implementation agent to address ALL feedback
                   LOG.info "[Basecamp:Hooks] All gates responded for card ##{card_number} — dispatching fixes" if defined?(LOG)
                   task["status"] = "in_flight"
+                  task["dispatched_at"] = Time.now.iso8601
                   task.delete("changes_debounce_started")
                   save_epic_state(epic)
 
-                  # Re-assign card to implementation agent to trigger dispatch
-                  impl_agent = epic["agent"]
-                  fizzy_user_id = Orchestrator.send(:resolve_fizzy_user_id, impl_agent)
-                  if fizzy_user_id
-                    LOG.info "[Basecamp:Hooks] Re-assigning card ##{card_number} to #{impl_agent} for fixes" if defined?(LOG)
-                    safe_assign_card(card_number, fizzy_user_id)
-                  end
+                  # Spawn agent directly — safe_assign_card won't work if already assigned
+                  dispatch_impl_directly(epic, task)
                 else
                   # Wait for remaining gates to respond
                   responded = (task["gate_approvals"]&.size || 0) + (task["changes_requested_by"]&.size || 0)
@@ -246,11 +242,11 @@ module Brainiac
                       if task_reloaded && task_reloaded["status"] == "in_review" && task_reloaded["changes_requested_by"]&.any?
                         LOG.info "[Basecamp:Hooks] Debounce timeout for card ##{card_number} — forcing dispatch" if defined?(LOG)
                         task_reloaded["status"] = "in_flight"
+                        task_reloaded["dispatched_at"] = Time.now.iso8601
                         task_reloaded.delete("changes_debounce_started")
                         save_epic_state(epic_reloaded)
-                        # Re-assign card to trigger dispatch
-                        fizzy_user_id = Orchestrator.send(:resolve_fizzy_user_id, epic_reloaded["agent"])
-                        safe_assign_card(card_number, fizzy_user_id) if fizzy_user_id
+                        # Spawn agent directly — safe_assign_card won't work if already assigned
+                        dispatch_impl_directly(epic_reloaded, task_reloaded)
                       end
                     rescue StandardError => e
                       LOG.error "[Basecamp:Hooks] Debounce dispatch failed: #{e.message}" if defined?(LOG)
@@ -728,14 +724,123 @@ module Brainiac
             end
           end
 
-          def mark_in_review(epic, card_number)
-            task = epic["tasks"].find { |t| t["fizzy_card"] == card_number.to_i }
-            return unless task
+          # Dispatch the implementation agent directly (spawns via run_agent) to address
+          # changes_requested feedback. Used by resume and health-check when the agent is
+          # no longer running but the Fizzy card is still assigned (so safe_assign_card
+          # would bail out with "already assigned, skipping").
+          #
+          # @param epic [Hash] Epic state
+          # @param task [Hash] Task within the epic
+          # @return [void]
+          def dispatch_impl_directly(epic, task)
+            card_number = task["fizzy_card"]
+            agent_name = epic["agent"]
+            pr_number = task["pr_number"]
+            project_key = task["project"]
+            card_key = "changes-requested-#{card_number}"
+
+            # Guard: don't spawn a duplicate if a session is already running for this task
+            session_alive = if defined?(session_active?)
+                             session_active?(card_key)
+                           elsif Object.respond_to?(:session_active?, true)
+                             Object.send(:session_active?, card_key)
+                           else
+                             false
+                           end
+
+            if session_alive
+              LOG.info "[Basecamp:Hooks] Session already active for #{card_key} — skipping dispatch" if defined?(LOG)
+              return
+            end
 
-            task["status"] = "in_review"
-            task["review_started_at"] = Time.now.iso8601
-            epic["updated_at"] = Time.now.iso8601
-            save_epic_state(epic)
+            LOG.info "[Basecamp:Hooks] Direct-dispatching #{agent_name} for changes_requested on card ##{card_number}" if defined?(LOG)
+
+            # Get project config
+            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)) : {}
+            project_config = projects[project_key]
+
+            unless project_config
+              LOG.error "[Basecamp:Hooks] No project config for '#{project_key}' — cannot direct-dispatch" if defined?(LOG)
+              return
+            end
+
+            repo_path = project_config["repo_path"]
+            unless repo_path
+              LOG.error "[Basecamp:Hooks] No repo_path for project '#{project_key}' — cannot direct-dispatch" if defined?(LOG)
+              return
+            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
+            if File.exist?(work_items_file)
+              work_items = JSON.parse(File.read(work_items_file))
+              work_item = work_items.values.find { |wi| wi.dig("sources", "fizzy", "card_number") == card_number }
+              worktree_path = work_item["worktree"] if work_item&.dig("worktree")
+            end
+
+            # Build prompt
+            changers = (task["changes_requested_by"] || []).join(", ")
+            prompt = <<~PROMPT
+              ## Changes Requested — Fizzy Card ##{card_number}
+
+              Review gates have requested changes on your PR#{pr_number ? " ##{pr_number}" : ""}.
+              Reviewers who requested changes: #{changers}
+
+              Your job:
+              1. Read the review feedback: #{pr_number ? "`gh pr view #{pr_number} --comments`" : "check the Fizzy card comments"}
+              2. Address all requested changes
+              3. Commit and push your fixes
+
+              After pushing, update the Fizzy card with a brief status comment noting what you fixed.
+            PROMPT
+
+            # Resolve GitHub App token so agent's `gh` commands run as their bot identity
+            github_repo = project_config&.dig("github_repo")
+            agent_env = github_repo ? ReviewGate.send(:resolve_agent_github_env, agent_name, github_repo) : {}
+
+            # Spawn the agent directly
+            pid = nil
+            log_file = nil
+
+            begin
+              pid, log_file = method(:run_agent).call(
+                prompt,
+                project_config: project_config,
+                chdir: worktree_path,
+                log_name: "changes-requested-#{card_number}",
+                agent_name: agent_name,
+                source: :basecamp,
+                card_number: card_number,
+                env: agent_env
+              )
+            rescue NameError
+              if Object.respond_to?(:run_agent, true)
+                pid, log_file = Object.send(:run_agent,
+                  prompt,
+                  project_config: project_config,
+                  chdir: worktree_path,
+                  log_name: "changes-requested-#{card_number}",
+                  agent_name: agent_name,
+                  source: :basecamp,
+                  card_number: card_number,
+                  env: agent_env)
+              else
+                LOG.warn "[Basecamp:Hooks] run_agent not available — direct impl dispatch skipped" if defined?(LOG)
+                return
+              end
+            end
+
+            # Register session for waybar visibility
+            if pid
+              if defined?(register_session)
+                register_session(card_key, pid, log_file: log_file, agent_name: agent_name)
+              elsif Object.respond_to?(:register_session, true)
+                Object.send(:register_session, card_key, pid, log_file: log_file, agent_name: agent_name)
+              end
+              LOG.info "[Basecamp:Hooks] Spawned #{agent_name} (pid #{pid}) for changes_requested on card ##{card_number}" if defined?(LOG)
+            end
           end
 
           def auto_merge_and_advance(epic, card_number, ctx)

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

@@ -203,6 +203,74 @@ module Brainiac
             dispatched
           end
 
+          # Dispatch only gate agents that have NOT yet responded (no approval, no changes_requested).
+          # Used during resume/health-check when some gates responded but others didn't.
+          #
+          # Tracks per-gate re-dispatch count to prevent infinite loops when a gate agent
+          # keeps crashing. After MAX_GATE_REDISPATCH_RETRIES, stops retrying that gate.
+          #
+          # IMPORTANT: Does NOT overwrite gates_dispatched_at — that timestamp represents
+          # the original dispatch and is used for stale detection. Overwriting it would
+          # reset the timeout window on every partial re-dispatch, causing infinite loops.
+          #
+          # @param epic [Hash] Epic state
+          # @param task [Hash] Task state
+          # @param pr_number [Integer, String] PR number
+          # @param repo_name [String] e.g. "stowzilla/brainiac-basecamp"
+          # @param repo_path [String] Local repo path
+          # @return [Array<String>] Agent names dispatched
+          def dispatch_missing_gates(epic:, task:, pr_number:, repo_name:, repo_path:)
+            responded_agents = Set.new
+            (task["gate_approvals"] || []).each { |a| responded_agents << a["agent"].downcase }
+            (task["changes_requested_by"] || []).each { |a| responded_agents << a.downcase }
+
+            missing_gates = gates.reject { |g| responded_agents.include?(g["agent"].downcase) }
+            return [] if missing_gates.empty?
+
+            # Track per-gate re-dispatch counts to prevent infinite loops
+            task["gate_redispatch_counts"] ||= {}
+
+            dispatched = []
+
+            missing_gates.each do |gate|
+              agent_name = gate["agent"]
+              role = gate["role"] || "review"
+
+              # Check retry count — stop if we've exceeded the max
+              retries = task["gate_redispatch_counts"][agent_name.downcase] || 0
+              if retries >= MAX_GATE_REDISPATCH_RETRIES
+                LOG.warn "[Basecamp:ReviewGate] Gate #{agent_name} exceeded max re-dispatch retries (#{retries}/#{MAX_GATE_REDISPATCH_RETRIES}) — skipping" if defined?(LOG)
+                next
+              end
+
+              LOG.info "[Basecamp:ReviewGate] Re-dispatching missing gate #{agent_name} (#{role}) to review PR ##{pr_number} (retry #{retries + 1}/#{MAX_GATE_REDISPATCH_RETRIES})" if defined?(LOG)
+
+              task["gate_redispatch_counts"][agent_name.downcase] = retries + 1
+
+              Thread.new do
+                dispatch_agent_for_review(
+                  agent_name: agent_name,
+                  role: role,
+                  pr_number: pr_number,
+                  repo_name: repo_name,
+                  repo_path: repo_path,
+                  card_number: task["fizzy_card"],
+                  epic: epic
+                )
+              rescue StandardError => e
+                LOG.error "[Basecamp:ReviewGate] Failed to dispatch #{agent_name}: #{e.message}" if defined?(LOG)
+              end
+
+              dispatched << agent_name
+            end
+
+            # Record when this partial re-dispatch happened (for diagnostics)
+            # but do NOT overwrite gates_dispatched_at — that's the original timestamp
+            task["last_redispatch_at"] = Time.now.iso8601
+
+            dispatched
+          end
+
           # Build the summary comment for Fizzy after all gates pass and merge completes.
           #
           # @param task [Hash] Task state

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

@@ -3,7 +3,7 @@
 module Brainiac
   module Plugins
     module Basecamp
-      VERSION = "0.0.7"
+      VERSION = "0.0.11"
     end
   end
 end

data/lib/brainiac/plugins/basecamp.rb

@@ -16,6 +16,15 @@ require_relative "basecamp/cli"
 module Brainiac
   module Plugins
     module Basecamp
+      # Maximum seconds to wait for a dispatched agent/gate to respond before
+      # considering it stale and re-dispatching. Used across resume, health-check,
+      # and dispatch_missing_gates.
+      STALE_DISPATCH_TIMEOUT = 300 # 5 minutes
+
+      # Maximum number of times a gate will be re-dispatched for the same review
+      # cycle before giving up (prevents infinite re-dispatch loops).
+      MAX_GATE_REDISPATCH_RETRIES = 3
+
       class << self
         # Called by Brainiac plugin system during server startup.
         #
@@ -107,22 +116,34 @@ module Brainiac
               end
 
             when "in_flight"
-              # Check if impl agent is assigned when changes were requested
-              if task["changes_requested_by"]&.any?
-                impl_agent = epic["agent"]
-                card_json, = Open3.capture2("fizzy", "card", "show", card_number.to_s, "--json")
-                card_data = JSON.parse(card_json) rescue {}
-                assignees = card_data.dig("data", "assignees") || []
-                assignee_names = assignees.map { |a| a["name"]&.downcase }
-
-                unless assignee_names.include?(impl_agent.downcase)
-                  LOG.info "[Basecamp:HealthCheck] Task ##{card_number} in_flight with changes_requested but #{impl_agent} not assigned — healing" if defined?(LOG)
-                  fizzy_user_id = Orchestrator.send(:resolve_fizzy_user_id, impl_agent)
-                  if fizzy_user_id
-                    Open3.capture3("fizzy", "card", "assign", card_number.to_s, "--user", fizzy_user_id)
-                    healed_any = true
-                  end
+              # Check if impl agent session is likely dead after a restart.
+              # Instead of just checking Fizzy assignment (stale artifact), use
+              # dispatched_at as a liveness signal — if dispatched too long ago
+              # without completion, assume the session died and re-dispatch.
+              dispatched_at = task["dispatched_at"]
+              if dispatched_at
+                elapsed = Time.now - Time.parse(dispatched_at)
+                # If task has been in_flight for longer than the stale timeout
+                # AND no agent is actively running (we can't check PID, so use elapsed time)
+                if elapsed > STALE_DISPATCH_TIMEOUT
+                  impl_agent = epic["agent"]
+                  LOG.info "[Basecamp:HealthCheck] Task ##{card_number} in_flight for #{elapsed.round}s — re-dispatching #{impl_agent}" if defined?(LOG)
+
+                  # Spawn the agent directly — safe_assign_card won't work if already assigned
+                  task["dispatched_at"] = Time.now.iso8601
+                  Hooks.send(:dispatch_impl_directly, epic, task)
+                  healed_any = true
                 end
+              elsif task["changes_requested_by"]&.any?
+                # No dispatched_at recorded but changes were requested — legacy state.
+                # Always re-dispatch in this case.
+                impl_agent = epic["agent"]
+                LOG.info "[Basecamp:HealthCheck] Task ##{card_number} in_flight with changes_requested but no dispatched_at — re-dispatching #{impl_agent}" if defined?(LOG)
+
+                # Spawn the agent directly — safe_assign_card won't work if already assigned
+                task["dispatched_at"] = Time.now.iso8601
+                Hooks.send(:dispatch_impl_directly, epic, task)
+                healed_any = true
               end
 
             when "in_review"
@@ -168,7 +189,7 @@ module Brainiac
                   elsif (task["gate_approvals"] || []).empty? && !task["changes_requested_by"]&.any?
                     # No gate responses at all — gates may never have been dispatched or agents crashed
                     gates_dispatched_at = task["gates_dispatched_at"]
-                    should_redispatch = gates_dispatched_at.nil? || (Time.now - Time.parse(gates_dispatched_at)) > 300
+                    should_redispatch = gates_dispatched_at.nil? || (Time.now - Time.parse(gates_dispatched_at)) > STALE_DISPATCH_TIMEOUT
 
                     if should_redispatch && github_repo
                       LOG.info "[Basecamp:HealthCheck] No gate responses for ##{card_number} — re-dispatching review gates" if defined?(LOG)
@@ -182,6 +203,25 @@ module Brainiac
                       Hooks.send(:save_epic_state, epic)
                       healed_any = true
                     end
+                  else
+                    # Partial responses — some gates responded but others haven't
+                    gates_dispatched_at = task["gates_dispatched_at"]
+                    if gates_dispatched_at && (Time.now - Time.parse(gates_dispatched_at)) > STALE_DISPATCH_TIMEOUT
+                      responded_count = (task["gate_approvals"]&.size || 0) + (task["changes_requested_by"]&.size || 0)
+                      total_gates = ReviewGate.gates.size
+                      if responded_count.positive? && responded_count < total_gates && github_repo
+                        LOG.info "[Basecamp:HealthCheck] Partial gate response for ##{card_number} (#{responded_count}/#{total_gates}) — re-dispatching missing gates" if defined?(LOG)
+                        ReviewGate.dispatch_missing_gates(
+                          epic: epic,
+                          task: task,
+                          pr_number: pr_number,
+                          repo_name: github_repo,
+                          repo_path: repo_path
+                        )
+                        Hooks.send(:save_epic_state, epic)
+                        healed_any = true
+                      end
+                    end
                   end
                 end
               end
@@ -278,61 +318,68 @@ module Brainiac
             Hooks.send(:save_epic_state, epic)
             Hooks.send(:dispatch_final_decision, epic, task, {})
           elsif task["changes_requested_by"]&.any?
-            # Gates requested changes — check if impl agent is assigned
+            # Gates requested changes — after a restart, no agent session is running even if assigned.
+            # Always re-dispatch the impl agent to address the feedback.
             impl_agent = epic["agent"]
-            LOG.info "[Basecamp] Resume: ##{card_number} has changes requested, checking assignment" if defined?(LOG)
+            LOG.info "[Basecamp] Resume: ##{card_number} has changes requested — re-dispatching #{impl_agent}" if defined?(LOG)
 
-            # Check current assignees via Fizzy CLI
-            card_json, = Open3.capture2("fizzy", "card", "show", card_number.to_s, "--json")
-            card_data = JSON.parse(card_json) rescue {}
-            assignees = card_data.dig("data", "assignees") || []
-            assignee_names = assignees.map { |a| a["name"]&.downcase }
+            # Transition to in_flight so the agent gets the right context
+            task["status"] = "in_flight"
+            task["dispatched_at"] = Time.now.iso8601
+            Hooks.send(:save_epic_state, epic)
 
-            if assignee_names.include?(impl_agent.downcase)
-              LOG.info "[Basecamp] Resume: ##{card_number} already assigned to #{impl_agent} — waiting for fixes" if defined?(LOG)
-            else
-              # Re-assign to trigger dispatch
-              LOG.info "[Basecamp] Resume: ##{card_number} not assigned to #{impl_agent} — re-assigning" if defined?(LOG)
-              fizzy_user_id = Orchestrator.send(:resolve_fizzy_user_id, impl_agent)
-              if fizzy_user_id
-                Open3.capture3("fizzy", "card", "assign", card_number.to_s, "--user", fizzy_user_id)
-              end
-            end
+            # Spawn the agent directly — safe_assign_card won't work if already assigned
+            Hooks.send(:dispatch_impl_directly, epic, task)
           else
             # No changes requested yet — check if gates need (re-)dispatching
             approvals = task["gate_approvals"]&.size || 0
             gates_dispatched_at = task["gates_dispatched_at"]
 
+            # Calculate how many gates have responded (approved or requested changes)
+            responded_count = approvals + (task["changes_requested_by"]&.size || 0)
+            total_gates = ReviewGate.gates.size
+
             # Re-dispatch gates if:
             # 1. Gates were never dispatched (missed webhook), OR
-            # 2. Gates were dispatched but no responses received after a reasonable window
+            # 2. Gates were dispatched but no responses received after 5 minutes, OR
+            # 3. Some gates responded but others didn't after 5 minutes (partial response)
             should_redispatch = if gates_dispatched_at.nil?
                                   true
-                                elsif approvals.zero?
-                                  # If dispatched more than 5 minutes ago with no responses, re-dispatch
-                                  elapsed = Time.now - Time.parse(gates_dispatched_at)
-                                  elapsed > 300
                                 else
-                                  false
+                                  elapsed = Time.now - Time.parse(gates_dispatched_at)
+                                  elapsed > STALE_DISPATCH_TIMEOUT && responded_count < total_gates
                                 end
 
             if should_redispatch && ReviewGate.enabled?
               github_repo = projects.dig(project_key, "github_repo")
               if github_repo
-                LOG.info "[Basecamp] Resume: ##{card_number} has #{approvals} approvals — re-dispatching review gates" if defined?(LOG)
-                ReviewGate.dispatch_gates(
-                  epic: epic,
-                  task: task,
-                  pr_number: pr_number,
-                  repo_name: github_repo,
-                  repo_path: repo_path
-                )
+                if responded_count.zero?
+                  # No responses at all — dispatch all gates
+                  LOG.info "[Basecamp] Resume: ##{card_number} has 0/#{total_gates} gate responses — re-dispatching all review gates" if defined?(LOG)
+                  ReviewGate.dispatch_gates(
+                    epic: epic,
+                    task: task,
+                    pr_number: pr_number,
+                    repo_name: github_repo,
+                    repo_path: repo_path
+                  )
+                else
+                  # Partial responses — dispatch only the missing gates
+                  LOG.info "[Basecamp] Resume: ##{card_number} has #{responded_count}/#{total_gates} gate responses — re-dispatching missing gates" if defined?(LOG)
+                  ReviewGate.dispatch_missing_gates(
+                    epic: epic,
+                    task: task,
+                    pr_number: pr_number,
+                    repo_name: github_repo,
+                    repo_path: repo_path
+                  )
+                end
                 Hooks.send(:save_epic_state, epic)
               else
                 LOG.warn "[Basecamp] Resume: ##{card_number} — cannot re-dispatch gates, no github_repo for #{project_key}" if defined?(LOG)
               end
             else
-              LOG.info "[Basecamp] Resume: ##{card_number} has #{approvals} approvals, waiting for more reviews" if defined?(LOG)
+              LOG.info "[Basecamp] Resume: ##{card_number} has #{responded_count}/#{total_gates} gate responses, waiting for more reviews" if defined?(LOG)
             end
           end
         end

metadata

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