brainiac-basecamp 0.0.15 → 0.0.17

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e8e71f8f043a52cb54d83e974031b0bb83339f02452e701bf381e4e87b32274d
-  data.tar.gz: ac57b522a30cdb3cdf42c0aca069c52bb1ce27b2b93fdbdf4b63a2c9f57088b9
+  metadata.gz: 632f37b6a52ba851b1f16430cc9f2af1a34b0343adcdc486e950d78470d01eb8
+  data.tar.gz: 7af23b5ee546eacb7b5d51b0dab4879dc642d7f0e8548ba4d94451e2aadc6518
 SHA512:
-  metadata.gz: 955cfcffe81b1856b0ee90e8c2124b48d13b3de28db1e258054069442b8a67096deeb95cda1b5ce0e21b20cd2b78e3bd7c73fd107c5753c3de82ef0ead916d01
-  data.tar.gz: 7b6e92a54b136065013d178d3422bc7583958f83b161184c9905b2d950898907ee1eebdffa6d2cf07bc7394836b98aef52acd8bb50583231b2b6b8f2f9ca3247
+  metadata.gz: 4d69200fb71f7d04244f0bfcd3d1e8b9ecc97920cb9f1488a96a3fab6da51117af64dd4a47a0ba3a4f8857ce2c36fd5ec23efcf48e35efa5b34f29f86e3af72d
+  data.tar.gz: c2253c409cdc64c02ec853dfca0623cc483ddd527b6f8135d9af9eb7ee256745a86a5992f998f6fcc73d10175593150f2288beb6437a4fc25e3c2ce7c278d8e1

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

@@ -30,6 +30,8 @@ module Brainiac
               cmd_projects(args)
             when "set"
               cmd_set(args)
+            when "reset"
+              cmd_reset(args)
             else
               print_help
             end
@@ -172,8 +174,23 @@ module Brainiac
 
               status_icon = epic["status"] == "active" ? "🚀" : "✅"
               puts "#{status_icon} #{epic['title']}"
-              puts "   Agent: #{epic['agent']} | Tasks: #{complete}/#{total} complete, #{in_flight} in-flight"
+              puts "   Todolist: #{epic['basecamp_todolist_id']} | Agent: #{epic['agent']}"
+              puts "   Tasks: #{complete}/#{total} complete, #{in_flight} in-flight"
               puts "   Started: #{epic['started_at']}"
+
+              # Show per-task detail if verbose or few tasks
+              if args.include?("--verbose") || args.include?("-v")
+                tasks.each do |t|
+                  icon = case t["status"]
+                         when "complete" then "✅"
+                         when "in_flight" then "🚀"
+                         when "in_review" then "👀"
+                         when "final_decision" then "⚡"
+                         else "⬜"
+                         end
+                  puts "     #{icon} ##{t['fizzy_card']} — #{t['title']} [#{t['status']}]"
+                end
+              end
               puts ""
             end
           end
@@ -317,9 +334,12 @@ module Brainiac
                 projects map <key> <basecamp-id>        Map a Brainiac project to Basecamp
                 projects list                           List project mappings
                 projects unmap <key>                    Remove a project mapping
-                set fizzy-account-id <id>                Set Fizzy account ID (for card URLs)
+                set fizzy-account-id <id>               Set Fizzy account ID (for card URLs)
                 set review-gate <mode>                  Set review gate (on_complete or on_pr_merge)
                 set epic-prefix <prefix>                Set epic todolist prefix (default: "Epic:")
+                reset task <card-number> [--to <status>] Reset a task to a given status (default: pending)
+                reset epic <todolist-id> [--to <status>] Reset entire epic or all tasks within it
+                reset gates <card-number>               Clear gate approvals and re-dispatch gates
 
               Config file: ~/.brainiac/basecamp.json
               Epics state: ~/.brainiac/basecamp_epics.json
@@ -327,6 +347,13 @@ module Brainiac
               Review gate modes:
                 on_complete   — Advance to next task as soon as agent finishes (default)
                 on_pr_merge   — Wait for PR to be merged before advancing (review gate)
+
+              Task statuses (for reset --to):
+                pending         — Not yet started, waiting for dependencies
+                in_flight       — Agent is actively working on it
+                in_review       — PR open, gates reviewing
+                final_decision  — Gates passed, awaiting implementation agent merge decision
+                complete        — Done
             HELP
           end
 
@@ -385,6 +412,273 @@ module Brainiac
             end
           end
 
+          def cmd_reset(args)
+            subcommand = args.shift
+
+            case subcommand
+            when "task"
+              cmd_reset_task(args)
+            when "epic"
+              cmd_reset_epic(args)
+            when "gates"
+              cmd_reset_gates(args)
+            else
+              puts <<~HELP
+                Usage: brainiac basecamp reset <subcommand>
+
+                Subcommands:
+                  task <card-number> [--to <status>]    Reset a task's status (default: pending)
+                  epic <todolist-id> [--to <status>]    Reset entire epic or all its tasks
+                  gates <card-number>                   Clear gate approvals and re-dispatch
+
+                Task statuses:
+                  pending, in_flight, in_review, final_decision, complete
+
+                Examples:
+                  brainiac basecamp reset task 1234                  # Reset card #1234 to pending
+                  brainiac basecamp reset task 1234 --to in_flight   # Reset to in_flight
+                  brainiac basecamp reset gates 1234                 # Clear gates, re-dispatch reviewers
+                  brainiac basecamp reset epic 10233212224            # Reset all tasks to pending
+                  brainiac basecamp reset epic 10233212224 --to pending  # Same as above
+              HELP
+            end
+          end
+
+          def cmd_reset_task(args)
+            card_number = args.shift&.gsub(/^#/, "")
+            unless card_number
+              puts "Usage: brainiac basecamp reset task <card-number> [--to <status>]"
+              return
+            end
+
+            target_status = parse_to_flag(args) || "pending"
+            unless valid_task_status?(target_status)
+              puts "Error: Invalid status '#{target_status}'"
+              puts "Valid statuses: pending, in_flight, in_review, final_decision, complete"
+              return
+            end
+
+            epics = load_epics
+            epic = epics.find do |e|
+              e["status"] == "active" &&
+                e["tasks"]&.any? { |t| t["fizzy_card"] == card_number.to_i }
+            end
+
+            unless epic
+              puts "Error: Card ##{card_number} not found in any active epic"
+              return
+            end
+
+            task = epic["tasks"].find { |t| t["fizzy_card"] == card_number.to_i }
+            old_status = task["status"]
+
+            # Reset the task
+            reset_task_to(task, target_status)
+
+            save_epics(epics)
+            puts "✓ Reset card ##{card_number} from '#{old_status}' → '#{target_status}'"
+            puts "  Epic: #{epic['title']}"
+
+            return unless target_status == "pending"
+
+            puts "  The task will be picked up on next dispatch cycle (restart brainiac or wait for next event)"
+          end
+
+          def cmd_reset_gates(args)
+            card_number = args.shift&.gsub(/^#/, "")
+            unless card_number
+              puts "Usage: brainiac basecamp reset gates <card-number>"
+              return
+            end
+
+            epics = load_epics
+            epic = epics.find do |e|
+              e["status"] == "active" &&
+                e["tasks"]&.any? { |t| t["fizzy_card"] == card_number.to_i }
+            end
+
+            unless epic
+              puts "Error: Card ##{card_number} not found in any active epic"
+              return
+            end
+
+            task = epic["tasks"].find { |t| t["fizzy_card"] == card_number.to_i }
+
+            # Clear all gate-related state
+            old_approvals = task["gate_approvals"]&.size || 0
+            old_changes = task["changes_requested_by"]&.size || 0
+
+            task["gate_approvals"] = []
+            task["changes_requested_by"] = []
+            task["gates_dispatched_at"] = nil
+            task["awaiting_final_decision"] = nil
+            task["changes_debounce_started"] = nil
+            task["gate_redispatch_counts"] = {}
+            task["last_redispatch_at"] = nil
+            task["status"] = "in_review"
+            epic["updated_at"] = Time.now.iso8601
+
+            save_epics(epics)
+            puts "✓ Cleared gates for card ##{card_number}"
+            puts "  Removed #{old_approvals} approval(s), #{old_changes} changes_requested"
+            puts "  Status set to 'in_review' — gates will be re-dispatched on next health check"
+            puts ""
+            puts "  To force immediate re-dispatch, restart brainiac:"
+            puts "    brainiac restart"
+          end
+
+          def cmd_reset_epic(args)
+            todolist_id = args.shift
+            unless todolist_id
+              puts "Usage: brainiac basecamp reset epic <todolist-id> [--to <status>]"
+              puts ""
+              puts "Options:"
+              puts "  --to <status>    Reset all tasks to this status (default: pending)"
+              puts "  --reactivate     Reset a completed epic back to active"
+              puts ""
+              puts "Find your todolist ID with: brainiac basecamp epics --all"
+              return
+            end
+
+            target_status = parse_to_flag(args) || "pending"
+            reactivate = args.include?("--reactivate")
+
+            unless valid_task_status?(target_status)
+              puts "Error: Invalid status '#{target_status}'"
+              puts "Valid statuses: pending, in_flight, in_review, final_decision, complete"
+              return
+            end
+
+            epics = load_epics
+            epic = epics.find { |e| e["basecamp_todolist_id"] == todolist_id.to_s }
+
+            unless epic
+              puts "Error: No epic found with todolist ID #{todolist_id}"
+              puts ""
+              puts "Active epics:"
+              epics.select { |e| e["status"] == "active" }.each do |e|
+                puts "  #{e['basecamp_todolist_id']} — #{e['title']}"
+              end
+              return
+            end
+
+            if epic["status"] != "active" && !reactivate
+              puts "Error: Epic '#{epic['title']}' is #{epic['status']} (not active)"
+              puts "  Use --reactivate to set it back to active"
+              return
+            end
+
+            # Reactivate if needed
+            if epic["status"] != "active" && reactivate
+              epic["status"] = "active"
+              epic["completed_at"] = nil
+              puts "✓ Reactivated epic '#{epic['title']}'"
+            end
+
+            # Reset all non-complete tasks (unless resetting to pending, in which case reset all)
+            tasks_to_reset = if target_status == "pending"
+                               epic["tasks"]
+                             else
+                               epic["tasks"].reject { |t| t["status"] == "complete" }
+                             end
+
+            tasks_to_reset.each { |t| reset_task_to(t, target_status) }
+            epic["updated_at"] = Time.now.iso8601
+
+            save_epics(epics)
+            puts "✓ Reset #{tasks_to_reset.size} task(s) → '#{target_status}' in epic '#{epic['title']}'"
+            puts ""
+            epic["tasks"].each do |t|
+              icon = case t["status"]
+                     when "complete" then "✅"
+                     when "in_flight" then "🚀"
+                     when "in_review" then "👀"
+                     when "final_decision" then "⚡"
+                     else "⬜"
+                     end
+              puts "  #{icon} ##{t['fizzy_card']} — #{t['title']} [#{t['status']}]"
+            end
+          end
+
+          # --- Reset helpers ---
+
+          def valid_task_status?(status)
+            %w[pending in_flight in_review final_decision complete].include?(status)
+          end
+
+          def parse_to_flag(args)
+            idx = args.index("--to")
+            return nil unless idx
+
+            args.delete_at(idx) # remove --to
+            args.delete_at(idx) # remove the value (now at same index)
+          end
+
+          def reset_task_to(task, status)
+            task["status"] = status
+
+            case status
+            when "pending"
+              # Clear all progress state
+              task["dispatched_at"] = nil
+              task["completed_at"] = nil
+              task["pr_number"] = nil
+              task["pr_repo"] = nil
+              task["gate_approvals"] = []
+              task["changes_requested_by"] = []
+              task["gates_dispatched_at"] = nil
+              task["awaiting_final_decision"] = nil
+              task["changes_debounce_started"] = nil
+              task["gate_redispatch_counts"] = {}
+              task["last_redispatch_at"] = nil
+              task["last_reviewed_sha"] = nil
+            when "in_flight"
+              # Keep PR info but clear gate state
+              task["completed_at"] = nil
+              task["gate_approvals"] = []
+              task["changes_requested_by"] = []
+              task["gates_dispatched_at"] = nil
+              task["awaiting_final_decision"] = nil
+              task["changes_debounce_started"] = nil
+              task["gate_redispatch_counts"] = {}
+              task["last_redispatch_at"] = nil
+              task["dispatched_at"] ||= Time.now.iso8601
+            when "in_review"
+              # Clear gate approvals but keep PR info
+              task["completed_at"] = nil
+              task["gate_approvals"] = []
+              task["changes_requested_by"] = []
+              task["gates_dispatched_at"] = nil
+              task["awaiting_final_decision"] = nil
+              task["changes_debounce_started"] = nil
+              task["gate_redispatch_counts"] = {}
+              task["last_redispatch_at"] = nil
+            when "final_decision"
+              task["completed_at"] = nil
+              task["awaiting_final_decision"] = true
+            when "complete"
+              task["completed_at"] ||= Time.now.iso8601
+            end
+          end
+
+          def load_epics
+            epics_file = File.join(BRAINIAC_DIR, "basecamp_epics.json")
+            return [] unless File.exist?(epics_file)
+
+            data = JSON.parse(File.read(epics_file))
+            data["epics"] || []
+          rescue JSON::ParserError
+            []
+          end
+
+          def save_epics(epics)
+            epics_file = File.join(BRAINIAC_DIR, "basecamp_epics.json")
+            File.write(epics_file, JSON.pretty_generate({
+                                                          "epics" => epics,
+                                                          "updated_at" => Time.now.iso8601
+                                                        }))
+          end
+
           def load_config
             if File.exist?(CONFIG_FILE)
               JSON.parse(File.read(CONFIG_FILE))
@@ -404,7 +698,7 @@ module Brainiac
       end
 
       def self.completions
-        %w[setup config status epics link bot projects set]
+        %w[setup config status epics link bot projects set reset]
       end
     end
   end

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

@@ -0,0 +1,179 @@
+# frozen_string_literal: true
+
+module Brainiac
+  module Plugins
+    module Basecamp
+      # Epic-level shared memory.
+      #
+      # Unlike per-card memory (agent-specific, gitignored), epic memory is shared
+      # across all agents working the epic AND persisted to git. It accumulates
+      # architectural decisions, patterns established, gotchas discovered, and
+      # cross-task learnings.
+      #
+      # The epic review agent writes to this file after each task completes.
+      # All task agents and gate agents read it as part of their context.
+      #
+      # Location: ~/.brainiac/brain/knowledge/epics/epic-<todolist-id>.md
+      #
+      # This is under knowledge/ (not memory/) because:
+      # - memory/ is gitignored — per-card, per-agent, ephemeral
+      # - knowledge/ is synced to git — shared, permanent, valuable
+      # - Epic learnings should persist and be searchable via qmd
+      module EpicMemory
+        BRAINIAC_DIR = ENV.fetch("BRAINIAC_DIR", File.join(Dir.home, ".brainiac"))
+        EPIC_MEMORY_DIR = File.join(BRAINIAC_DIR, "brain", "knowledge", "epics")
+
+        class << self
+          # Path to the epic memory file for a given epic.
+          #
+          # @param todolist_id [String, Integer] Basecamp todolist ID
+          # @return [String] Absolute file path
+          def path_for(todolist_id)
+            File.join(EPIC_MEMORY_DIR, "epic-#{todolist_id}.md")
+          end
+
+          # Ensure the epic memory directory exists.
+          def ensure_directory!
+            FileUtils.mkdir_p(EPIC_MEMORY_DIR) unless File.directory?(EPIC_MEMORY_DIR)
+          end
+
+          # Read the epic memory content, if it exists.
+          #
+          # @param todolist_id [String, Integer] Basecamp todolist ID
+          # @return [String, nil] Content or nil if no memory exists
+          def read(todolist_id)
+            path = path_for(todolist_id)
+            return nil unless File.exist?(path)
+
+            content = File.read(path).strip
+            content.empty? ? nil : content
+          rescue StandardError => e
+            LOG.warn "[Basecamp:EpicMemory] Failed to read epic memory: #{e.message}" if defined?(LOG)
+            nil
+          end
+
+          # Check if epic memory exists.
+          #
+          # @param todolist_id [String, Integer] Basecamp todolist ID
+          # @return [Boolean]
+          def exists?(todolist_id)
+            File.exist?(path_for(todolist_id))
+          end
+
+          # Initialize epic memory with the epic title and initial context.
+          # Called when an epic starts.
+          #
+          # @param epic [Hash] Epic state
+          def initialize_for(epic)
+            ensure_directory!
+            path = path_for(epic["basecamp_todolist_id"])
+
+            # Don't overwrite existing memory (in case of resume)
+            return if File.exist?(path) && !File.read(path).strip.empty?
+
+            initial_content = <<~MARKDOWN
+              # Epic Memory: #{epic['title']}
+
+              Epic started: #{epic['started_at']}
+              Orchestrating agent: #{epic['agent']}
+
+              ---
+
+              ## Architectural Decisions
+
+              (No decisions recorded yet)
+
+              ## Patterns Established
+
+              (No patterns recorded yet)
+
+              ## Gotchas & Learnings
+
+              (No learnings recorded yet)
+
+              ## Cross-Task Notes
+
+              (No notes recorded yet)
+            MARKDOWN
+
+            File.write(path, initial_content)
+            LOG.info "[Basecamp:EpicMemory] Initialized memory for epic #{epic['id']}" if defined?(LOG)
+          rescue StandardError => e
+            LOG.error "[Basecamp:EpicMemory] Failed to initialize: #{e.message}" if defined?(LOG)
+          end
+
+          # Append a section to the epic memory.
+          # Used by the epic review agent after each task completes.
+          #
+          # @param todolist_id [String, Integer] Basecamp todolist ID
+          # @param section [String] Section title (e.g., "After Task #1234")
+          # @param content [String] Content to add
+          def append_section(todolist_id, section:, content:)
+            ensure_directory!
+            path = path_for(todolist_id)
+
+            existing = File.exist?(path) ? File.read(path) : ""
+            timestamp = Time.now.strftime("%Y-%m-%d %H:%M")
+
+            new_section = <<~MARKDOWN
+
+              ---
+
+              ## #{section}
+              _Updated: #{timestamp}_
+
+              #{content.strip}
+            MARKDOWN
+
+            File.write(path, existing + new_section)
+            LOG.info "[Basecamp:EpicMemory] Appended section '#{section}' to epic #{todolist_id}" if defined?(LOG)
+          rescue StandardError => e
+            LOG.error "[Basecamp:EpicMemory] Failed to append: #{e.message}" if defined?(LOG)
+          end
+
+          # Build context injection for an agent prompt.
+          # Returns a formatted string with the epic memory, or nil if none exists.
+          #
+          # @param todolist_id [String, Integer] Basecamp todolist ID
+          # @return [String, nil] Formatted context for prompt injection
+          def build_context(todolist_id)
+            content = read(todolist_id)
+            return nil unless content
+
+            <<~CONTEXT
+              ## Epic Memory (Shared Knowledge)
+
+              The following is shared knowledge accumulated across this epic.
+              Reference this when making implementation decisions.
+
+              #{content}
+            CONTEXT
+          end
+
+          # Clean up epic memory after epic completes.
+          # Optionally archives to a different location rather than deleting.
+          #
+          # @param todolist_id [String, Integer] Basecamp todolist ID
+          # @param archive [Boolean] Whether to archive rather than delete
+          def cleanup(todolist_id, archive: true)
+            path = path_for(todolist_id)
+            return unless File.exist?(path)
+
+            if archive
+              archive_dir = File.join(EPIC_MEMORY_DIR, "archived")
+              FileUtils.mkdir_p(archive_dir)
+              archive_path = File.join(archive_dir, "epic-#{todolist_id}-#{Time.now.strftime('%Y%m%d')}.md")
+              FileUtils.mv(path, archive_path)
+              LOG.info "[Basecamp:EpicMemory] Archived epic memory to #{archive_path}" if defined?(LOG)
+            else
+              FileUtils.rm(path)
+              LOG.info "[Basecamp:EpicMemory] Deleted epic memory for #{todolist_id}" if defined?(LOG)
+            end
+          rescue StandardError => e
+            LOG.warn "[Basecamp:EpicMemory] Cleanup failed: #{e.message}" if defined?(LOG)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -446,6 +446,23 @@ module Brainiac
                 ""
               ]
 
+              # Inject epic memory if it exists (shared knowledge across the epic)
+              epic_memory = EpicMemory.read(epic["basecamp_todolist_id"])
+              if epic_memory
+                context_lines << "### Epic Memory (Shared Knowledge)"
+                context_lines << ""
+                context_lines << "The following is shared knowledge accumulated from previous tasks in this epic."
+                context_lines << "Reference this when making implementation decisions."
+                context_lines << ""
+                context_lines << "```markdown"
+                context_lines << epic_memory.lines.first(50).join # Limit to first 50 lines to avoid context overflow
+                if epic_memory.lines.size > 50
+                  context_lines << "... (truncated — full file at ~/.brainiac/brain/memory/epics/epic-#{epic['basecamp_todolist_id']}.md)"
+                end
+                context_lines << "```"
+                context_lines << ""
+              end
+
               # List completed tasks with their memory files for reference
               completed_tasks = tasks.select { |t| t["status"] == "complete" }
               if completed_tasks.any?

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

@@ -49,6 +49,9 @@ module Brainiac
             LOG.info "[Basecamp:Orchestrator] Started epic '#{title}' (todolist #{todolist_id}) " \
                      "with agent #{agent}, review_gate: #{review_gate}" if defined?(LOG)
 
+            # Initialize epic memory for cross-task shared knowledge
+            EpicMemory.initialize_for(epic)
+
             # FIRST: Populate tasks with project info from Fizzy card tags
             # This must happen BEFORE creating epic branches so we know which repos are involved
             populate_tasks(epic)
@@ -642,6 +645,18 @@ module Brainiac
               "- ##{t['fizzy_card']}: #{t['title']}#{dep_str}"
             end.join("\n")
 
+            # Include existing epic memory if any
+            epic_memory_path = EpicMemory.path_for(epic["basecamp_todolist_id"])
+            epic_memory_section = if EpicMemory.exists?(epic["basecamp_todolist_id"])
+                                    <<~MEM
+
+                                      ### Epic Memory (shared knowledge so far)
+                                      Read the epic memory file at `#{epic_memory_path}` for decisions and patterns established in previous tasks.
+                                    MEM
+                                  else
+                                    ""
+                                  end
+
             prompt = <<~PROMPT
               ## Epic Review: #{epic['title']}
 
@@ -652,7 +667,7 @@ module Brainiac
 
               ### Remaining tasks (with current dependencies):
               #{remaining_summary}
-
+              #{epic_memory_section}
               ### Your job:
               1. Read the memory files for completed tasks to understand what was implemented
               2. Check if remaining tasks still make sense given the implementation decisions
@@ -665,10 +680,20 @@ module Brainiac
 
               Memory files are at: `~/.brainiac/brain/memory/#{agent_name&.downcase}/card-<number>.md`
 
-              After reviewing, post a brief summary comment on the Basecamp todolist:
+              ### Update Epic Memory (IMPORTANT)
+              After your review, update the epic memory file at `#{epic_memory_path}` with:
+              - **Architectural decisions** made during task ##{completed_card_number}
+              - **Patterns established** that should be followed in remaining tasks
+              - **Gotchas** discovered that future tasks should know about
+              - **Cross-task notes** about relationships or dependencies
+
+              This is shared knowledge — other agents will read it. Be concise but thorough.
+              Append a new section, don't replace the existing content.
+
+              Then post a brief summary comment on the Basecamp todolist:
               `basecamp comments create #{epic['basecamp_todolist_id']} "Epic review after ##{completed_card_number}: <your summary>" --in #{epic['basecamp_project_id']}`
 
-              Keep it concise — this is a checkpoint, not a full analysis.
+              Keep the basecamp comment concise — this is a checkpoint, not a full analysis.
             PROMPT
 
             # Get project config for the agent
@@ -759,6 +784,9 @@ module Brainiac
 
             LOG.info "[Basecamp:Orchestrator] Epic '#{epic['title']}' completed!" if defined?(LOG)
 
+            # Archive epic memory (preserves it for future reference)
+            EpicMemory.cleanup(epic["basecamp_todolist_id"], archive: true)
+
             # If epic_branch mode, open final PRs to main
             if epic["review_gate"] == "epic_branch" && epic["epic_branches"]&.any?
               open_final_prs(epic)

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

@@ -166,15 +166,23 @@ module Brainiac
           # @param pr_number [Integer, String] PR number
           # @param repo_name [String] e.g. "stowzilla/brainiac-basecamp"
           # @param repo_path [String] Local repo path
+          # @param is_rereview [Boolean] True if this is a re-review after changes
           # @return [Array<String>] Agent names dispatched
-          def dispatch_gates(epic:, task:, pr_number:, repo_name:, repo_path:)
+          def dispatch_gates(epic:, task:, pr_number:, repo_name:, repo_path:, is_rereview: false)
             dispatched = []
 
+            # Get current HEAD SHA for tracking incremental reviews
+            current_sha = get_pr_head_sha(pr_number: pr_number, repo_path: repo_path)
+
+            # Determine if this is a re-review and what SHA to diff from
+            last_reviewed_sha = task["last_reviewed_sha"]
+            diff_from_sha = is_rereview && last_reviewed_sha ? last_reviewed_sha : nil
+
             gates.each do |gate|
               agent_name = gate["agent"]
               role = gate["role"] || "review"
 
-              LOG.info "[Basecamp:ReviewGate] Dispatching #{agent_name} (#{role}) to review PR ##{pr_number}" if defined?(LOG)
+              LOG.info "[Basecamp:ReviewGate] Dispatching #{agent_name} (#{role}) to review PR ##{pr_number}#{" (incremental from #{diff_from_sha[0..7]})" if diff_from_sha}" if defined?(LOG)
 
               # Dispatch the gate agent via brainiac-github's PR review mechanism.
               # The agent gets the PR diff and reviews it using their bot identity.
@@ -186,7 +194,8 @@ module Brainiac
                   repo_name: repo_name,
                   repo_path: repo_path,
                   card_number: task["fizzy_card"],
-                  epic: epic
+                  epic: epic,
+                  diff_from_sha: diff_from_sha
                 )
               rescue StandardError => e
                 LOG.error "[Basecamp:ReviewGate] Failed to dispatch #{agent_name}: #{e.message}" if defined?(LOG)
@@ -200,6 +209,9 @@ module Brainiac
             task["gates_dispatched_at"] = Time.now.iso8601
             task["gate_approvals"] ||= []
 
+            # Track the SHA we're reviewing for incremental diff on next round
+            task["last_reviewed_sha"] = current_sha if current_sha
+
             dispatched
           end
 
@@ -218,8 +230,9 @@ module Brainiac
           # @param pr_number [Integer, String] PR number
           # @param repo_name [String] e.g. "stowzilla/brainiac-basecamp"
           # @param repo_path [String] Local repo path
+          # @param is_rereview [Boolean] True if this is a re-review after implementation fixes
           # @return [Array<String>] Agent names dispatched
-          def dispatch_missing_gates(epic:, task:, pr_number:, repo_name:, repo_path:)
+          def dispatch_missing_gates(epic:, task:, pr_number:, repo_name:, repo_path:, is_rereview: false)
             responded_agents = Set.new
             (task["gate_approvals"] || []).each { |a| responded_agents << a["agent"].downcase }
             (task["changes_requested_by"] || []).each { |a| responded_agents << a.downcase }
@@ -230,6 +243,10 @@ module Brainiac
             # Track per-gate re-dispatch counts to prevent infinite loops
             task["gate_redispatch_counts"] ||= {}
 
+            # For re-reviews, determine incremental diff range
+            diff_from_sha = is_rereview && task["last_reviewed_sha"] ? task["last_reviewed_sha"] : nil
+            current_sha = get_pr_head_sha(pr_number: pr_number, repo_path: repo_path)
+
             dispatched = []
 
             missing_gates.each do |gate|
@@ -243,7 +260,7 @@ module Brainiac
                 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)
+              LOG.info "[Basecamp:ReviewGate] Re-dispatching missing gate #{agent_name} (#{role}) to review PR ##{pr_number} (retry #{retries + 1}/#{MAX_GATE_REDISPATCH_RETRIES})#{' (incremental)' if diff_from_sha}" if defined?(LOG)
 
               task["gate_redispatch_counts"][agent_name.downcase] = retries + 1
 
@@ -255,7 +272,8 @@ module Brainiac
                   repo_name: repo_name,
                   repo_path: repo_path,
                   card_number: task["fizzy_card"],
-                  epic: epic
+                  epic: epic,
+                  diff_from_sha: diff_from_sha
                 )
               rescue StandardError => e
                 LOG.error "[Basecamp:ReviewGate] Failed to dispatch #{agent_name}: #{e.message}" if defined?(LOG)
@@ -268,6 +286,9 @@ module Brainiac
             # but do NOT overwrite gates_dispatched_at — that's the original timestamp
             task["last_redispatch_at"] = Time.now.iso8601
 
+            # Update last_reviewed_sha for next round
+            task["last_reviewed_sha"] = current_sha if current_sha
+
             dispatched
           end
 
@@ -300,9 +321,33 @@ module Brainiac
 
           private
 
+          # Get the HEAD SHA of a PR (for tracking incremental reviews).
+          #
+          # @param pr_number [Integer, String] PR number
+          # @param repo_path [String] Local repo path
+          # @return [String, nil] Commit SHA or nil if failed
+          def get_pr_head_sha(pr_number:, repo_path:)
+            stdout, _, status = Open3.capture3(
+              "gh", "pr", "view", pr_number.to_s,
+              "--json", "headRefOid",
+              "--jq", ".headRefOid",
+              chdir: repo_path
+            )
+            return nil unless status.success?
+
+            sha = stdout.strip
+            sha.empty? ? nil : sha
+          rescue StandardError => e
+            LOG.warn "[Basecamp:ReviewGate] Failed to get PR head SHA: #{e.message}" if defined?(LOG)
+            nil
+          end
+
           # Dispatch a single gate agent to review a PR.
           # This creates a review prompt and runs the agent in the repo directory.
-          def dispatch_agent_for_review(agent_name:, role:, pr_number:, repo_name:, repo_path:, card_number:, epic:)
+          #
+          # @param diff_from_sha [String, nil] If present, this is a re-review and agent should
+          #   focus on changes since this SHA (incremental review)
+          def dispatch_agent_for_review(agent_name:, role:, pr_number:, repo_name:, repo_path:, card_number:, epic:, diff_from_sha: nil)
             # Build a review-specific prompt for the gate agent
             prompt = build_gate_review_prompt(
               agent_name: agent_name,
@@ -310,7 +355,8 @@ module Brainiac
               pr_number: pr_number,
               repo_name: repo_name,
               card_number: card_number,
-              epic_title: epic["title"]
+              epic_title: epic["title"],
+              diff_from_sha: diff_from_sha
             )
 
             # Resolve the agent's GitHub token for their bot identity
@@ -359,29 +405,80 @@ module Brainiac
           end
 
           # Build the prompt for a gate review agent.
-          def build_gate_review_prompt(agent_name:, role:, pr_number:, repo_name:, card_number:, epic_title:)
-            <<~PROMPT
-              You are reviewing PR ##{pr_number} on #{repo_name} as part of epic: "#{epic_title}".
-              Your role: **#{role}**
+          #
+          # @param diff_from_sha [String, nil] If present, this is an incremental re-review
+          def build_gate_review_prompt(agent_name:, role:, pr_number:, repo_name:, card_number:, epic_title:, diff_from_sha: nil)
+            if diff_from_sha
+              # Incremental re-review prompt — focus only on new changes
+              <<~PROMPT
+                You are RE-REVIEWING PR ##{pr_number} on #{repo_name} as part of epic: "#{epic_title}".
+                Your role: **#{role}**
+
+                This is an INCREMENTAL REVIEW — you already reviewed this PR and requested changes.
+                The implementation agent has pushed fixes. Focus on what changed.
+
+                **Step 1: Read the context to understand WHY changes were made:**
+                ```
+                gh pr view #{pr_number}
+                gh pr view #{pr_number} --comments
+                git log #{diff_from_sha}..HEAD --oneline
+                ```
+
+                - `gh pr view` shows the PR description (implementation rationale)
+                - `--comments` shows discussion and review responses
+                - `git log` shows commit messages explaining each fix
+
+                Read these BEFORE looking at the code changes.
+
+                **Step 2: View the NEW changes since your last review:**
+                ```
+                git fetch origin && git diff #{diff_from_sha}..HEAD
+                ```
+
+                Or compare in GitHub: `#{repo_name}/compare/#{diff_from_sha[0..7]}...HEAD`
+
+                If you need the full context, you can still use `gh pr diff #{pr_number}`, but prioritize
+                reviewing the incremental changes first.
+
+                Based on your role (#{role}):
+                #{role_instructions(role)}
+
+                After your review:
+                - If the fixes address your concerns: `gh pr review #{pr_number} --approve --body "your summary"`
+                - If more changes are needed: `gh pr review #{pr_number} --request-changes --body "what still needs fixing"`
+
+                Be thorough but pragmatic. This is Fizzy card ##{card_number}.
+
+                IMPORTANT RESTRICTIONS:
+                - Do NOT open new PRs or modify code — you are a reviewer only
+                - Do NOT comment on the Fizzy card — your review goes on GitHub only
+                - Do NOT use the fizzy CLI at all
+              PROMPT
+            else
+              # Initial full review prompt
+              <<~PROMPT
+                You are reviewing PR ##{pr_number} on #{repo_name} as part of epic: "#{epic_title}".
+                Your role: **#{role}**
 
-              This is a review gate — the epic cannot proceed until you approve.
+                This is a review gate — the epic cannot proceed until you approve.
 
-              Review the PR changes with `gh pr diff #{pr_number}` and `gh pr view #{pr_number}`.
+                Review the PR changes with `gh pr diff #{pr_number}` and `gh pr view #{pr_number}`.
 
-              Based on your role (#{role}):
-              #{role_instructions(role)}
+                Based on your role (#{role}):
+                #{role_instructions(role)}
 
-              After your review:
-              - If the code meets your standards: `gh pr review #{pr_number} --approve --body "your summary"`
-              - If changes are needed: `gh pr review #{pr_number} --request-changes --body "what needs fixing"`
+                After your review:
+                - If the code meets your standards: `gh pr review #{pr_number} --approve --body "your summary"`
+                - If changes are needed: `gh pr review #{pr_number} --request-changes --body "what needs fixing"`
 
-              Be thorough but pragmatic. This is Fizzy card ##{card_number}.
+                Be thorough but pragmatic. This is Fizzy card ##{card_number}.
 
-              IMPORTANT RESTRICTIONS:
-              - Do NOT open new PRs or modify code — you are a reviewer only
-              - Do NOT comment on the Fizzy card — your review goes on GitHub only
-              - Do NOT use the fizzy CLI at all
-            PROMPT
+                IMPORTANT RESTRICTIONS:
+                - Do NOT open new PRs or modify code — you are a reviewer only
+                - Do NOT comment on the Fizzy card — your review goes on GitHub only
+                - Do NOT use the fizzy CLI at all
+              PROMPT
+            end
           end
 
           # Role-specific review instructions.

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

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

data/lib/brainiac/plugins/basecamp.rb

@@ -7,6 +7,7 @@ require_relative "basecamp/config"
 require_relative "basecamp/client"
 require_relative "basecamp/epic"
 require_relative "basecamp/epic_branch"
+require_relative "basecamp/epic_memory"
 require_relative "basecamp/review_gate"
 require_relative "basecamp/orchestrator"
 require_relative "basecamp/webhook"
@@ -206,7 +207,8 @@ module Brainiac
                         task: task,
                         pr_number: effective_pr,
                         repo_name: github_repo,
-                        repo_path: repo_path
+                        repo_path: repo_path,
+                        is_rereview: true
                       )
                     rescue StandardError => e
                       LOG.error "[Basecamp:HealthCheck] Gate re-dispatch failed for ##{card_number}: #{e.message}" if defined?(LOG)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: brainiac-basecamp
 version: !ruby/object:Gem::Version
-  version: 0.0.15
+  version: 0.0.17
 platform: ruby
 authors:
 - Andy Davis
@@ -93,6 +93,7 @@ files:
 - lib/brainiac/plugins/basecamp/config.rb
 - lib/brainiac/plugins/basecamp/epic.rb
 - lib/brainiac/plugins/basecamp/epic_branch.rb
+- lib/brainiac/plugins/basecamp/epic_memory.rb
 - lib/brainiac/plugins/basecamp/hooks.rb
 - lib/brainiac/plugins/basecamp/metadata.rb
 - lib/brainiac/plugins/basecamp/orchestrator.rb