lex-swarm-github 0.3.0 → 0.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a5b852399782262ebab25e020d689b147a55ce6f256134a9d53137b223e6ba8e
-  data.tar.gz: 8804deca49b8a4bd37a262d90e152ade0e2359fd065f40ea4d32604bb0f885bf
+  metadata.gz: a1c767cd01e97e707ce4079c0a3313c723e984143e1e29cfcd580bfd7b391735
+  data.tar.gz: abf61ad73ed7875421cef31b0ff713031f5fc99bc61ece84943fdba22cf34169
 SHA512:
-  metadata.gz: 798c161250c26ba51ca15c0696d7f97dcc794d78b34fc1696b466e0aba16196368b96f2e5fc9351c0b34244efdbf3fe0c35b0a7cca4bc09d684d1fd014cec361
-  data.tar.gz: 5ad660b2154048f0974ff1ac444ac0a96f282c9ffa789455bb901a29b3c737cfe103ea0bfb8c177862daec6b11efe2d4606a221edcedb8689005b6c8dea76d38
+  metadata.gz: 99ae16ec047585531e0c41eedb26e55d4a4e4b2940562078bbc1c36f4f9eb734c08c1df8aef46aa35032ea68c2199e90d39cef50b7535eb8c179f16f90a689c9
+  data.tar.gz: f61a356f212fa8f7b7b250fa6d4fd9ef10446233842cf65410ec3239e76bb689793ef3694978b2e6ee67c00ea09f137b9bcc36d7ec0ad438b626ec5da9fa3875

data/lib/legion/extensions/swarm_github/actors/lifecycle_subscriber.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+return unless defined?(Legion::Extensions::Actors::Subscription)
+
+module Legion
+  module Extensions
+    module SwarmGithub
+      module Actor
+        class LifecycleSubscriber < Legion::Extensions::Actors::Subscription
+          def runner_class    = self.class
+          def runner_function = 'action'
+          def check_subtask?  = false
+          def generate_task?  = false
+
+          def action(payload)
+            verdict = (payload[:verdict] || payload['verdict']).to_s
+
+            unless verdict == 'approve' && github_lifecycle_enabled?
+              return { skipped: true, reason: verdict == 'approve' ? :github_disabled : :not_approved }
+            end
+
+            generation = payload[:generation] || {}
+            review = payload.except(:generation)
+
+            Runners::ExtensionLifecycle.run_lifecycle(generation: generation, review: review)
+          rescue StandardError => e
+            log.warn("LifecycleSubscriber failed: #{e.message}")
+            { success: false, error: e.message }
+          end
+
+          private
+
+          def github_lifecycle_enabled?
+            return false unless defined?(Legion::Settings)
+
+            Legion::Settings.dig(:codegen, :self_generate, :github, :enabled) == true
+          rescue StandardError => e
+            log.warn(e.message)
+            false
+          end
+
+          def log
+            return Legion::Logging if defined?(Legion::Logging)
+
+            @log ||= Object.new.tap do |nl|
+              %i[debug info warn error fatal].each { |m| nl.define_singleton_method(m) { |*| nil } }
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/swarm_github/runners/extension_lifecycle.rb

@@ -0,0 +1,177 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module SwarmGithub
+      module Runners
+        module ExtensionLifecycle
+          extend self
+
+          def run_lifecycle(generation:, review:)
+            config = github_config
+            return { success: false, error: :github_not_enabled } unless config[:enabled]
+            return { success: false, error: :target_repo_missing } unless config[:target_repo]
+
+            owner, repo = config[:target_repo].split('/')
+            name = generation[:name] || generation[:generation_id]
+            branch_name = "#{config[:branch_prefix]}-#{name}-#{Time.now.strftime('%Y%m%d%H%M%S')}"
+
+            branch = create_lifecycle_branch(owner: owner, repo: repo,
+                                             branch: branch_name, from_ref: config[:target_branch])
+            return branch unless branch[:success]
+
+            commit = commit_generated_files(owner: owner, repo: repo, branch: branch_name,
+                                            generation: generation)
+            return commit unless commit[:success]
+
+            pr = open_pull_request(owner: owner, repo: repo, branch: branch_name,
+                                   base: config[:target_branch], generation: generation, review: review)
+            return pr unless pr[:success]
+
+            label_pull_request(owner: owner, repo: repo, pull_number: pr[:pull_number],
+                               labels: config[:pr_labels])
+
+            handle_auto_merge(owner: owner, repo: repo, pull_number: pr[:pull_number],
+                              config: config, review: review)
+
+            { success: true, pull_number: pr[:pull_number], html_url: pr[:html_url],
+              branch: branch_name, generation_id: generation[:generation_id] }
+          rescue StandardError => e
+            log.warn("ExtensionLifecycle failed: #{e.message}")
+            { success: false, error: e.message }
+          end
+
+          private
+
+          def create_lifecycle_branch(owner:, repo:, branch:, from_ref:)
+            return { success: false, error: :github_runner_unavailable } unless github_runner_available?
+
+            github_client.create_branch(owner: owner, repo: repo, branch: branch, from_ref: from_ref)
+          end
+
+          def commit_generated_files(owner:, repo:, branch:, generation:)
+            return { success: false, error: :github_runner_unavailable } unless github_runner_available?
+
+            files = build_file_list(generation)
+            message = "add auto-generated #{generation[:name]} from gap #{generation[:gap_id]}"
+
+            github_client.commit_files(owner: owner, repo: repo, branch: branch, files: files, message: message)
+          end
+
+          def open_pull_request(owner:, repo:, branch:, base:, generation:, review:) # rubocop:disable Metrics/ParameterLists
+            return { success: false, error: :github_runner_unavailable } unless github_runner_available?
+
+            body = build_pr_body(generation: generation, review: review)
+            result = github_client.create_pull_request(
+              owner: owner, repo: repo, title: "auto-generated: #{generation[:name]}",
+              head: branch, base: base, body: body
+            )
+
+            pr = result[:result] || {}
+            { success: true, pull_number: pr['number'], html_url: pr['html_url'] }
+          rescue StandardError => e
+            log.warn(e.message)
+            { success: false, error: e.message }
+          end
+
+          def label_pull_request(owner:, repo:, pull_number:, labels:)
+            return { success: true } unless pull_number && labels&.any?
+            return { success: false, error: :github_runner_unavailable } unless github_runner_available?
+
+            github_client.add_labels(owner: owner, repo: repo, issue_number: pull_number, labels: labels)
+          rescue StandardError => e
+            log.warn("Label failed: #{e.message}")
+            { success: false, error: e.message }
+          end
+
+          def handle_auto_merge(owner:, repo:, pull_number:, config:, review:)
+            return unless config[:auto_merge] && review[:verdict]&.to_sym == :approve
+
+            github_client.merge_pull_request(
+              owner: owner, repo: repo, pull_number: pull_number,
+              commit_title: 'auto-merge: generated extension'
+            )
+          rescue StandardError => e
+            log.warn("Auto-merge failed: #{e.message}")
+          end
+
+          def build_file_list(generation)
+            files = []
+            files << { path: generation[:file_path], content: generation[:code] } if generation[:code]
+            files << { path: generation[:spec_path], content: generation[:spec_code] } if generation[:spec_code]
+            files
+          end
+
+          def build_pr_body(generation:, review:)
+            stages = (review[:stages] || {}).map do |name, stage|
+              passed = stage.is_a?(Hash) && stage[:passed] ? 'pass' : 'fail'
+              "| #{name} | #{passed} | |"
+            end.join("\n")
+
+            <<~BODY
+              ## Auto-Generated Extension
+
+              **Gap**: #{generation[:gap_type]} - "#{generation[:name]}"
+              **Tier**: #{generation[:tier]}
+              **Generation ID**: #{generation[:generation_id]}
+
+              ### Validation Results
+
+              | Stage | Result | Details |
+              |-------|--------|---------|
+              #{stages}
+
+              ### Files
+
+              - `#{generation[:file_path]}` - Runner implementation
+              - `#{generation[:spec_path]}` - Specs
+            BODY
+          end
+
+          def github_config
+            return default_config unless defined?(Legion::Settings)
+
+            settings = Legion::Settings.dig(:codegen, :self_generate, :github) || {}
+            default_config.merge(settings)
+          rescue StandardError => e
+            log.warn(e.message)
+            default_config
+          end
+
+          def default_config
+            {
+              enabled: false, target_repo: nil, target_branch: 'main',
+              auto_merge: false, pr_labels: %w[auto-generated needs-review],
+              branch_prefix: 'feature/auto-generated'
+            }
+          end
+
+          def github_runner_available?
+            defined?(Legion::Extensions::Github::Client)
+          end
+
+          def github_client
+            @github_client ||= Legion::Extensions::Github::Client.new(**github_connection_opts)
+          end
+
+          def github_connection_opts
+            return {} unless defined?(Legion::Settings)
+
+            { token: Legion::Settings.dig(:github, :token) }
+          rescue StandardError => e
+            log.warn(e.message)
+            {}
+          end
+
+          def log
+            return Legion::Logging if defined?(Legion::Logging)
+
+            @log ||= Object.new.tap do |nl|
+              %i[debug info warn error fatal].each { |m| nl.define_singleton_method(m) { |*| nil } }
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/swarm_github/runners/pull_request_reviewer.rb

@@ -28,7 +28,8 @@ module Legion
             Legion::Extensions::Github::Client.new.list_pull_request_files(
               owner: owner, repo: repo, pull_number: pull_number
             )[:result] || []
-          rescue StandardError
+          rescue StandardError => e
+            log.warn(e.message) if respond_to?(:log, true)
             []
           end
 
@@ -42,7 +43,7 @@ module Legion
             end
             merge_chunk_reviews(reviews)
           rescue StandardError => e
-            Legion::Logging::Logger.warn "Review generation failed: #{e.message}"
+            log.warn("Review generation failed: #{e.message}") if respond_to?(:log, true)
             { summary: 'Review generation failed', comments: [] }
           end
 
@@ -56,8 +57,9 @@ module Legion
           end
 
           def parse_review_response(response)
-            Legion::JSON.load(response)
-          rescue StandardError
+            Legion::JSON.parse(response)
+          rescue StandardError => e
+            log.warn(e.message) if respond_to?(:log, true)
             { summary: response.to_s, comments: [] }
           end
 

data/lib/legion/extensions/swarm_github/runners/review_notifier.rb

@@ -17,6 +17,7 @@ module Legion
 
             { notified: result[:ok] == true, channel: channel, ts: result[:ts] }
           rescue StandardError => e
+            log.warn(e.message) if respond_to?(:log, true)
             { notified: false, reason: "slack error: #{e.message}" }
           end
 

data/lib/legion/extensions/swarm_github/runners/review_poster.rb

@@ -22,6 +22,7 @@ module Legion
             review_id = result.dig(:result, 'id') || result.dig(:result, :id)
             { posted: true, review_id: review_id, comments_count: inline_comments.size }
           rescue StandardError => e
+            log.warn(e.message) if respond_to?(:log, true)
             { posted: false, reason: "post failed: #{e.message}" }
           end
 

data/lib/legion/extensions/swarm_github/version.rb

@@ -3,7 +3,7 @@
 module Legion
   module Extensions
     module SwarmGithub
-      VERSION = '0.3.0'
+      VERSION = '0.3.1'
     end
   end
 end

data/lib/legion/extensions/swarm_github.rb

@@ -10,6 +10,8 @@ require 'legion/extensions/swarm_github/helpers/diff_chunker'
 require 'legion/extensions/swarm_github/runners/review_poster'
 require 'legion/extensions/swarm_github/runners/review_notifier'
 require 'legion/extensions/swarm_github/runners/pr_pipeline'
+require 'legion/extensions/swarm_github/runners/extension_lifecycle'
+require 'legion/extensions/swarm_github/actors/lifecycle_subscriber' if defined?(Legion::Extensions::Actors::Subscription)
 
 module Legion
   module Extensions

data/spec/legion/extensions/swarm_github/actors/lifecycle_subscriber_spec.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Actors
+      class Subscription # rubocop:disable Lint/EmptyClass
+      end
+    end
+  end
+end
+
+$LOADED_FEATURES << 'legion/extensions/actors/subscription'
+
+require_relative '../../../../../lib/legion/extensions/swarm_github/runners/extension_lifecycle'
+require_relative '../../../../../lib/legion/extensions/swarm_github/actors/lifecycle_subscriber'
+
+RSpec.describe Legion::Extensions::SwarmGithub::Actor::LifecycleSubscriber do
+  subject(:actor) { described_class.new }
+
+  describe '#runner_function' do
+    it { expect(actor.runner_function).to eq('action') }
+  end
+
+  describe '#check_subtask?' do
+    it { expect(actor.check_subtask?).to be false }
+  end
+
+  describe '#generate_task?' do
+    it { expect(actor.generate_task?).to be false }
+  end
+
+  describe '#action' do
+    let(:generation) do
+      { name: 'lex-foo', generation_id: 'gen-1', file_path: 'lib/foo.rb', spec_path: 'spec/foo_spec.rb' }
+    end
+
+    context 'when verdict is not approve' do
+      it 'skips with :not_approved reason' do
+        result = actor.action({ verdict: 'reject', generation: generation })
+        expect(result[:skipped]).to be true
+        expect(result[:reason]).to eq(:not_approved)
+      end
+
+      it 'handles string verdict' do
+        result = actor.action({ 'verdict' => 'pending', 'generation' => {} })
+        expect(result[:skipped]).to be true
+        expect(result[:reason]).to eq(:not_approved)
+      end
+    end
+
+    context 'when verdict is approve but github lifecycle is disabled' do
+      before do
+        allow(actor).to receive(:github_lifecycle_enabled?).and_return(false)
+      end
+
+      it 'skips with :github_disabled reason' do
+        result = actor.action({ verdict: 'approve', generation: generation })
+        expect(result[:skipped]).to be true
+        expect(result[:reason]).to eq(:github_disabled)
+      end
+    end
+
+    context 'when verdict is approve and github lifecycle is enabled' do
+      let(:lifecycle_result) { { success: true, pull_number: 99, html_url: 'https://github.com/org/repo/pull/99' } }
+
+      before do
+        allow(actor).to receive(:github_lifecycle_enabled?).and_return(true)
+        allow(Legion::Extensions::SwarmGithub::Runners::ExtensionLifecycle)
+          .to receive(:run_lifecycle).and_return(lifecycle_result)
+      end
+
+      it 'calls ExtensionLifecycle.run_lifecycle' do
+        actor.action({ verdict: 'approve', generation: generation })
+        expect(Legion::Extensions::SwarmGithub::Runners::ExtensionLifecycle)
+          .to have_received(:run_lifecycle)
+      end
+
+      it 'passes generation and review payload correctly' do
+        payload = { verdict: 'approve', generation: generation, extra_key: 'value' }
+        actor.action(payload)
+        expect(Legion::Extensions::SwarmGithub::Runners::ExtensionLifecycle)
+          .to have_received(:run_lifecycle).with(
+            generation: generation,
+            review:     hash_including(verdict: 'approve')
+          )
+      end
+
+      it 'returns the lifecycle result' do
+        result = actor.action({ verdict: 'approve', generation: generation })
+        expect(result).to eq(lifecycle_result)
+      end
+    end
+
+    context 'when a StandardError is raised' do
+      before do
+        allow(actor).to receive(:github_lifecycle_enabled?).and_return(true)
+        allow(Legion::Extensions::SwarmGithub::Runners::ExtensionLifecycle)
+          .to receive(:run_lifecycle).and_raise(RuntimeError, 'boom')
+      end
+
+      it 'returns success false with error message' do
+        result = actor.action({ verdict: 'approve', generation: {} })
+        expect(result[:success]).to be false
+        expect(result[:error]).to eq('boom')
+      end
+    end
+  end
+end

data/spec/legion/extensions/swarm_github/runners/extension_lifecycle_spec.rb

@@ -0,0 +1,179 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'legion/extensions/swarm_github/runners/extension_lifecycle'
+
+RSpec.describe Legion::Extensions::SwarmGithub::Runners::ExtensionLifecycle do
+  subject(:runner) { described_class }
+
+  after { described_class.instance_variable_set(:@github_client, nil) }
+
+  let(:generation) do
+    {
+      name:          'lex-foo',
+      generation_id: 'gen-abc123',
+      gap_id:        'gap-001',
+      gap_type:      'missing_runner',
+      tier:          'utility',
+      file_path:     'lib/legion/extensions/foo.rb',
+      spec_path:     'spec/legion/extensions/foo_spec.rb',
+      code:          '# runner code',
+      spec_code:     '# spec code'
+    }
+  end
+
+  let(:review) { { verdict: 'approve', stages: { syntax: { passed: true }, quality: { passed: true } } } }
+
+  describe '#run_lifecycle' do
+    context 'when github is not enabled' do
+      it 'returns github_not_enabled error' do
+        result = runner.run_lifecycle(generation: generation, review: review)
+        expect(result).to eq({ success: false, error: :github_not_enabled })
+      end
+    end
+
+    context 'when github is enabled but target_repo is missing' do
+      before do
+        allow(runner).to receive(:github_config).and_return(
+          { enabled: true, target_repo: nil, target_branch: 'main',
+            auto_merge: false, pr_labels: [], branch_prefix: 'feature/auto-generated' }
+        )
+      end
+
+      it 'returns target_repo_missing error' do
+        result = runner.run_lifecycle(generation: generation, review: review)
+        expect(result).to eq({ success: false, error: :target_repo_missing })
+      end
+    end
+
+    context 'when github runner is unavailable' do
+      before do
+        allow(runner).to receive(:github_config).and_return(
+          { enabled: true, target_repo: 'org/repo', target_branch: 'main',
+            auto_merge: false, pr_labels: [], branch_prefix: 'feature/auto-generated' }
+        )
+        allow(runner).to receive(:github_runner_available?).and_return(false)
+      end
+
+      it 'returns github_runner_unavailable on branch creation' do
+        result = runner.run_lifecycle(generation: generation, review: review)
+        expect(result).to eq({ success: false, error: :github_runner_unavailable })
+      end
+    end
+
+    context 'when all pipeline steps succeed' do
+      let(:github_client) { double('Github::Client') }
+
+      before do
+        runner.instance_variable_set(:@github_client, nil)
+        allow(runner).to receive(:github_config).and_return(
+          { enabled: true, target_repo: 'org/repo', target_branch: 'main',
+            auto_merge: false, pr_labels: %w[auto-generated needs-review],
+            branch_prefix: 'feature/auto-generated' }
+        )
+        stub_const('Legion::Extensions::Github::Client', Class.new)
+        allow(Legion::Extensions::Github::Client).to receive(:new).and_return(github_client)
+        allow(github_client).to receive(:create_branch).and_return({ success: true })
+        allow(github_client).to receive(:commit_files).and_return({ success: true })
+        allow(github_client).to receive(:create_pull_request).and_return(
+          { result: { 'number' => 42, 'html_url' => 'https://github.com/org/repo/pull/42' } }
+        )
+        allow(github_client).to receive(:add_labels).and_return({ success: true })
+      end
+
+      it 'returns success with PR details' do
+        result = runner.run_lifecycle(generation: generation, review: review)
+        expect(result[:success]).to be true
+        expect(result[:pull_number]).to eq(42)
+        expect(result[:html_url]).to eq('https://github.com/org/repo/pull/42')
+        expect(result[:generation_id]).to eq('gen-abc123')
+      end
+
+      it 'calls create_branch' do
+        runner.run_lifecycle(generation: generation, review: review)
+        expect(github_client).to have_received(:create_branch)
+      end
+
+      it 'calls commit_files with file list' do
+        runner.run_lifecycle(generation: generation, review: review)
+        expect(github_client).to have_received(:commit_files).with(
+          hash_including(files: array_including(hash_including(path: 'lib/legion/extensions/foo.rb')))
+        )
+      end
+
+      it 'calls create_pull_request' do
+        runner.run_lifecycle(generation: generation, review: review)
+        expect(github_client).to have_received(:create_pull_request).with(
+          hash_including(title: 'auto-generated: lex-foo')
+        )
+      end
+
+      it 'calls add_labels' do
+        runner.run_lifecycle(generation: generation, review: review)
+        expect(github_client).to have_received(:add_labels).with(
+          hash_including(labels: %w[auto-generated needs-review])
+        )
+      end
+    end
+
+    context 'when branch creation fails' do
+      before do
+        runner.instance_variable_set(:@github_client, nil)
+        allow(runner).to receive(:github_config).and_return(
+          { enabled: true, target_repo: 'org/repo', target_branch: 'main',
+            auto_merge: false, pr_labels: [], branch_prefix: 'feature/auto-generated' }
+        )
+        stub_const('Legion::Extensions::Github::Client', Class.new)
+        allow(Legion::Extensions::Github::Client).to receive(:new).and_return(double(
+                                                                                create_branch: { success: false, error: 'branch exists' }
+                                                                              ))
+      end
+
+      it 'propagates the branch error' do
+        result = runner.run_lifecycle(generation: generation, review: review)
+        expect(result[:success]).to be false
+        expect(result[:error]).to eq('branch exists')
+      end
+    end
+
+    context 'when auto_merge is enabled and verdict is approve' do
+      let(:github_client) { double('Github::Client') }
+      let(:review_approve) { { verdict: 'approve', stages: {} } }
+
+      before do
+        runner.instance_variable_set(:@github_client, nil)
+        allow(runner).to receive(:github_config).and_return(
+          { enabled: true, target_repo: 'org/repo', target_branch: 'main',
+            auto_merge: true, pr_labels: [], branch_prefix: 'feature/auto-generated' }
+        )
+        stub_const('Legion::Extensions::Github::Client', Class.new)
+        allow(Legion::Extensions::Github::Client).to receive(:new).and_return(github_client)
+        allow(github_client).to receive(:create_branch).and_return({ success: true })
+        allow(github_client).to receive(:commit_files).and_return({ success: true })
+        allow(github_client).to receive(:create_pull_request).and_return(
+          { result: { 'number' => 7, 'html_url' => 'https://github.com/org/repo/pull/7' } }
+        )
+        allow(github_client).to receive(:merge_pull_request).and_return({ success: true })
+      end
+
+      it 'calls merge_pull_request' do
+        runner.run_lifecycle(generation: generation, review: review_approve)
+        expect(github_client).to have_received(:merge_pull_request).with(
+          hash_including(pull_number: 7)
+        )
+      end
+    end
+
+    context 'when a StandardError is raised' do
+      before do
+        allow(runner).to receive(:github_config).and_raise(RuntimeError, 'unexpected failure')
+      end
+
+      it 'returns success false with error message' do
+        result = runner.run_lifecycle(generation: generation, review: review)
+        expect(result[:success]).to be false
+        expect(result[:error]).to eq('unexpected failure')
+      end
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lex-swarm-github
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.3.1
 platform: ruby
 authors:
 - Esity
@@ -118,6 +118,7 @@ files:
 - Gemfile
 - lex-swarm-github.gemspec
 - lib/legion/extensions/swarm_github.rb
+- lib/legion/extensions/swarm_github/actors/lifecycle_subscriber.rb
 - lib/legion/extensions/swarm_github/actors/pr_webhook.rb
 - lib/legion/extensions/swarm_github/actors/stale_issues.rb
 - lib/legion/extensions/swarm_github/client.rb
@@ -125,12 +126,14 @@ files:
 - lib/legion/extensions/swarm_github/helpers/issue_tracker.rb
 - lib/legion/extensions/swarm_github/helpers/mesh_integration.rb
 - lib/legion/extensions/swarm_github/helpers/pipeline.rb
+- lib/legion/extensions/swarm_github/runners/extension_lifecycle.rb
 - lib/legion/extensions/swarm_github/runners/github_swarm.rb
 - lib/legion/extensions/swarm_github/runners/pr_pipeline.rb
 - lib/legion/extensions/swarm_github/runners/pull_request_reviewer.rb
 - lib/legion/extensions/swarm_github/runners/review_notifier.rb
 - lib/legion/extensions/swarm_github/runners/review_poster.rb
 - lib/legion/extensions/swarm_github/version.rb
+- spec/legion/extensions/swarm_github/actors/lifecycle_subscriber_spec.rb
 - spec/legion/extensions/swarm_github/actors/pr_webhook_spec.rb
 - spec/legion/extensions/swarm_github/actors/stale_issues_spec.rb
 - spec/legion/extensions/swarm_github/client_spec.rb
@@ -138,6 +141,7 @@ files:
 - spec/legion/extensions/swarm_github/helpers/issue_tracker_spec.rb
 - spec/legion/extensions/swarm_github/helpers/mesh_integration_spec.rb
 - spec/legion/extensions/swarm_github/helpers/pipeline_spec.rb
+- spec/legion/extensions/swarm_github/runners/extension_lifecycle_spec.rb
 - spec/legion/extensions/swarm_github/runners/github_swarm_spec.rb
 - spec/legion/extensions/swarm_github/runners/pr_pipeline_spec.rb
 - spec/legion/extensions/swarm_github/runners/pull_request_reviewer_spec.rb