brainiac-basecamp 0.0.15 → 0.0.16

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e8e71f8f043a52cb54d83e974031b0bb83339f02452e701bf381e4e87b32274d
-  data.tar.gz: ac57b522a30cdb3cdf42c0aca069c52bb1ce27b2b93fdbdf4b63a2c9f57088b9
+  metadata.gz: 4d77f4d0787e023edeec79754c9958f4ee09f036250038ef7cc4ae1dc9961a20
+  data.tar.gz: 74d8aba9539c7526eed62e209b8a84cabe9ecf26482f8873f8c1581a2a70a86a
 SHA512:
-  metadata.gz: 955cfcffe81b1856b0ee90e8c2124b48d13b3de28db1e258054069442b8a67096deeb95cda1b5ce0e21b20cd2b78e3bd7c73fd107c5753c3de82ef0ead916d01
-  data.tar.gz: 7b6e92a54b136065013d178d3422bc7583958f83b161184c9905b2d950898907ee1eebdffa6d2cf07bc7394836b98aef52acd8bb50583231b2b6b8f2f9ca3247
+  metadata.gz: 198ee07060302e70cf71612ede20b9232efda88f91090273dcee7606264364f381ad7646443a8965319a2437cb5a7f46d6e1e1b92e2683aa87fb176028fd97d2
+  data.tar.gz: 9194582cc89b6a9cb05721c0369f80762b656776b29e5ad5f97662a6ae460364d486c7d0d15b20bd36e131b9e41c74b9e66d71910155e30b206d0865bd03c967

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.16"
     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.16
 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