rubocop-legion 0.1.3 → 0.1.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b8cc626a680f38939c6212bd03e40249c354e24e8d4d8415aee6aa00c449e67e
-  data.tar.gz: 3eaed689593c5ec2ec4e24c89104c856ff0bff298302c278f1ca296d7278161f
+  metadata.gz: f841ecd6e5821651ad020bd243791971cf7ab5dca138178d90d216e8a58a48ba
+  data.tar.gz: acd221dbf9f924e6f81b21569262ea6a8aebbe42d4753356f9750cd3cc0c13a0
 SHA512:
-  metadata.gz: 8ac7d705d82418617f8d9ff3e67524911ff1c947a381c1ab61fcbdc35a1fa5c7537e9dc017f7118ca0037eebe27ab52d352e08a7433fde06cf641b48e8e13006
-  data.tar.gz: ea1138ce50b98a013ea6b4de431eebb336a087ef3204b6be1c20061786d3e8c43f589958bc03050f1ed4d3f5bb9e9808b8da50eafbeeff323455a494be76e7bd
+  metadata.gz: 5933d7f5010bc89b49a95e3d4c0080d752d583fab9a4c11e5fc3a244a0e45938be35eeb6f6851386452d72eca5c135434b6fe1d7dc6cb2a5be163bf7a0213576
+  data.tar.gz: 62b31e59d175e345383a02764b3c1c32a7599e70af80e31d8f0685730579c5396d9cdd783e19fb16ca18809e43b33cead79b6ad03f444acc77045fe4c2dd6399

data/CHANGELOG.md

@@ -1,5 +1,33 @@
 # Changelog
 
+## [0.1.6] - 2026-03-29
+
+### Added
+- Bundled `rubocop-performance` (52 cops) — Ruby performance anti-pattern detection, all enabled by default
+- Bundled `rubocop-thread_safety` (6 cops) — thread safety analysis for concurrent code
+- Tuned ThreadSafety defaults: `NewThread` excludes service/connection files, `ClassInstanceVariable` excludes singletons, `RackMiddlewareInstanceVariable` disabled, `DirChdir` allows block form
+
+## [0.1.5] - 2026-03-29
+
+### Added
+- New cop `Legion/Framework/MutexNestedSync`: detect nested `synchronize` blocks (deadlock risk)
+- New cop `Legion/Extension/ActorEnabledSideEffects`: flag `enabled?` in actor classes that runs during boot (keep side-effect-free)
+
+## [0.1.4] - 2026-03-29
+
+### Added
+- New cop `Legion/HelperMigration/DirectData`: use `data_connection`/`local_data_*` helpers instead of `Legion::Data::Connection`/`Legion::Data::Local` (auto-fix)
+- New cop `Legion/HelperMigration/DirectLlmEmbed`: use `llm_embed` helper instead of `Legion::LLM.embed` (auto-fix)
+- New cop `Legion/HelperMigration/RequireDefinedGuard`: remove `if defined?(Legion::...)` from require statements (auto-fix)
+- New cop `Legion/HelperMigration/DefinedTransportGuard`: use `transport_connected?` instead of `defined?(Legion::Transport)`
+- New cop `Legion/Extension/RunnerPluralModule`: enforce `module Runners` (plural), auto-correctable
+- New cop `Legion/Extension/ActorInheritance`: actor must inherit from Every, Once, Poll, Subscription, Loop, or Nothing
+- New cop `Legion/Extension/EveryActorRequiresTime`: Every/Poll actors must call `time` DSL
+- New cop `Legion/Extension/HookMissingRunnerClass`: hook classes must override `runner_class`
+- New cop `Legion/Extension/AbsorberMissingPattern`: absorber classes must call `pattern` DSL
+- New cop `Legion/Extension/AbsorberMissingAbsorbMethod`: absorber classes must define `absorb` method
+- New cop `Legion/Extension/DefinitionCallMismatched`: `definition :name` must have matching `def name`
+
 ## [0.1.3] - 2026-03-29
 
 ### Added

data/CLAUDE.md

@@ -4,27 +4,45 @@
 
 ## What is This?
 
-Custom RuboCop plugin gem for the LegionIO ecosystem. Provides 32 AST-based cops across 6 departments. Uses the new RuboCop Plugin API (1.72+, lint_roller-based) with auto-discovery via gemspec metadata.
+Custom RuboCop plugin gem for the LegionIO ecosystem. Provides 45 AST-based cops across 6 departments. Uses the new RuboCop Plugin API (1.72+, lint_roller-based) with auto-discovery via gemspec metadata.
 
 **GitHub**: https://github.com/LegionIO/rubocop-legion
 **RubyGems**: https://rubygems.org/gems/rubocop-legion
 **License**: MIT
 
+## Shared Config Profiles
+
+The gem ships shared `.rubocop.yml` profiles so repos don't duplicate config:
+
+- `config/base.yml` — all shared settings (AllCops, Layout, Metrics, Style, Naming, Performance, ThreadSafety)
+- `config/lex.yml` — inherits base, adds plugins (rubocop-legion + performance + thread_safety) + `ParameterLists Max: 8`
+- `config/core.yml` — inherits base, adds plugins (rubocop-legion + performance + thread_safety) + `ParameterLists Max: 10, CountKeywordArgs: false`
+
+### Bundled Plugins
+
+Both profiles load `rubocop-performance` (52 cops) and `rubocop-thread_safety` (6 cops) as runtime dependencies. ThreadSafety defaults tuned for LegionIO: `NewThread` excludes service/connection files, `ClassInstanceVariable` excludes singletons, `RackMiddlewareInstanceVariable` disabled, `DirChdir` allows block form.
+
+**LEX repos**: `inherit_gem: { rubocop-legion: config/lex.yml }`
+**Core repos**: `inherit_gem: { rubocop-legion: config/core.yml }`
+
+Repo-specific overrides go below the `inherit_gem` directive. Version-locked with the gem — bump gem version = all repos get updated config.
+
 ## Cop Scoping
 
 Cops are scoped by gem type — no per-repo configuration needed:
 
 - **Universal** (9 cops): Fire on all LegionIO gems
 - **Library-specific** (6 cops): Fire on all gems but only trigger when using Sequel, Sinatra, Thor, Faraday, or cache
-- **LEX-only** (17 cops): Scoped to `lib/legion/extensions/**/*.rb` via Include directive — never fire on core `legion-*` libraries
+- **LEX-only** (28 cops): Scoped to `lib/legion/extensions/**/*.rb` via Include directive — never fire on core `legion-*` libraries
 
 ## Departments and Cops
 
-### Universal — 9 cops
+### Universal — 10 cops
 
 - **ConstantSafety** (4): `BareDataDefine`, `BareProcess`, `BareJson` (all error, auto-fix) — prefix with `::` inside `module Legion`. `InheritParam` (convention, auto-fix) — pass `false` to `const_defined?`/`const_get`.
 - **RescueLogging** (3): `BareRescue` (warning, auto-fix) — capture with `=> e`. `NoCapture` (convention, no auto-fix) — exception class without capture. `SilentCapture` (warning, no auto-fix) — captured but never logged/re-raised. Skips `_`-prefixed vars. All skip inline rescue modifiers.
 - **Singleton** (1): `UseInstance` (error, auto-fix) — `.instance` not `.new` for configurable singleton classes.
+- **Framework/MutexNestedSync** (1): Nested `synchronize` blocks risk deadlock.
 - **Framework/ModuleFunctionPrivate** (1): `private` after `module_function` resets visibility.
 
 ### Library-Specific — 6 cops
@@ -36,10 +54,10 @@ Cops are scoped by gem type — no per-repo configuration needed:
 - `CacheTimeCoercion` — Time→String after cache round-trip
 - `ApiStringKeys` — `Legion::JSON.load` returns symbol keys (scoped to `lib/legion/extensions/**/*.rb`)
 
-### LEX-Only — 17 cops
+### LEX-Only — 29 cops
 
-- **HelperMigration** (7): `DirectLogging`, `OldLoggingMethods`, `DirectJson`, `DirectCache`, `DirectLocalCache`, `DirectCrypt` (all auto-fix) — use per-extension helpers, not global singletons. `LoggingGuard` (no auto-fix) — remove unnecessary `respond_to?(:log_warn)` / `defined?(Legion::Logging)` guards.
-- **Extension** (10): `ActorSingularModule` (auto-fix), `CoreExtendGuard` (auto-fix), `RunnerMustBeModule`, `RunnerIncludeHelpers`, `SelfContainedActorRunnerClass`, `RunnerReturnHash`, `SettingsKeyMethod` (auto-fix), `SettingsBracketMultiArg` (auto-fix), `LlmAskKwargs`, `DataRequiredWithoutMigrations`.
+- **HelperMigration** (11): `DirectLogging`, `OldLoggingMethods`, `DirectJson`, `DirectCache`, `DirectLocalCache`, `DirectCrypt`, `DirectData`, `DirectLlmEmbed`, `RequireDefinedGuard` (all auto-fix) — use per-extension helpers, not global singletons. `LoggingGuard` (no auto-fix) — remove unnecessary `respond_to?(:log_warn)` / `defined?(Legion::Logging)` guards. `DefinedTransportGuard` (no auto-fix) — use `transport_connected?` instead of `defined?(Legion::Transport)`.
+- **Extension** (18): `ActorSingularModule` (auto-fix), `RunnerPluralModule` (auto-fix), `CoreExtendGuard` (auto-fix), `RunnerMustBeModule`, `RunnerIncludeHelpers`, `ActorInheritance`, `EveryActorRequiresTime`, `SelfContainedActorRunnerClass`, `HookMissingRunnerClass`, `AbsorberMissingPattern`, `AbsorberMissingAbsorbMethod`, `DefinitionCallMismatched`, `RunnerReturnHash`, `SettingsKeyMethod` (auto-fix), `SettingsBracketMultiArg` (auto-fix), `LlmAskKwargs`, `ActorEnabledSideEffects`, `DataRequiredWithoutMigrations`.
 
 ## Architecture
 
@@ -58,10 +76,10 @@ rubocop-legion/
 │           ├── singleton/             # 1 cop  (universal)
 │           ├── rescue_logging/        # 3 cops (universal)
 │           ├── framework/             # 7 cops (universal + library-specific)
-│           └── extension/             # 10 cops (lex-only)
+│           └── extension/             # 17 cops (lex-only)
 ├── config/
 │   └── default.yml                    # All cop defaults, Include/Exclude scoping
-└── spec/                              # 233 specs, mirrors lib/ structure
+└── spec/                              # mirrors lib/ structure
 ```
 
 ## Key Implementation Details
@@ -79,7 +97,7 @@ rubocop-legion/
 
 ```bash
 bundle install
-bundle exec rspec      # 233 specs
+bundle exec rspec      # 322 specs
 bundle exec rubocop    # Self-linting
 ```
 

data/README.md

@@ -14,15 +14,39 @@ gem 'rubocop-legion', '~> 0.1', require: false, group: :development
 
 ## Usage
 
-Add to your `.rubocop.yml`:
+Use a shared config profile that includes the plugin, all standard settings, and cop defaults:
+
+**For `lex-*` extension gems:**
 
 ```yaml
-plugins:
-  - rubocop-legion
+# .rubocop.yml
+inherit_gem:
+  rubocop-legion: config/lex.yml
 ```
 
+**For `legion-*` core library gems:**
+
+```yaml
+# .rubocop.yml
+inherit_gem:
+  rubocop-legion: config/core.yml
+```
+
+Add repo-specific overrides below the `inherit_gem` directive. For manual setup without shared config, use `plugins: [rubocop-legion]` directly.
+
 Requires RuboCop 1.72+ (Plugin API with lint_roller).
 
+### What the shared configs include
+
+Both profiles set: `TargetRubyVersion: 3.4`, `NewCops: enable`, `LineLength: 160`, `MethodLength: 50`, `ClassLength: 1500`, `ModuleLength: 1500`, `BlockLength: 40` (spec/gemspec excluded), `AbcSize: 60`, table-aligned hashes, frozen string literals, and disable `Style/Documentation`, `Naming/FileName`, `Naming/PredicateMethod`, and `Gemspec/DevelopmentDependencies`.
+
+Both profiles also load **rubocop-performance** (52 cops) and **rubocop-thread_safety** (6 cops) as plugins. Thread safety defaults are tuned for LegionIO's concurrent architecture: `NewThread` excludes service/connection files, `ClassInstanceVariable` excludes singletons, `RackMiddlewareInstanceVariable` is disabled, `DirChdir` allows block form.
+
+| Profile | `ParameterLists Max` | `CountKeywordArgs` |
+|---------|---------------------|--------------------|
+| `lex.yml` | 8 | default (true) |
+| `core.yml` | 10 | false |
+
 ## Cop Scoping
 
 Cops are automatically scoped based on where they should apply:
@@ -35,7 +59,7 @@ No per-repo configuration needed for scoping. If a cop doesn't apply to your gem
 
 ## Cops
 
-### Universal (all LegionIO gems) — 9 cops
+### Universal (all LegionIO gems) — 10 cops
 
 | Department | Cop | Severity | Auto-fix | Description |
 |---|---|---|---|---|
@@ -47,6 +71,7 @@ No per-repo configuration needed for scoping. If a cop doesn't apply to your gem
 | RescueLogging | `NoCapture` | convention | no | Exception class specified but not captured (`rescue Error` without `=> e`) |
 | RescueLogging | `SilentCapture` | warning | no | Captured exception never logged or re-raised |
 | Singleton | `UseInstance` | error | yes | Use `.instance` instead of `.new` for singleton classes |
+| Framework | `MutexNestedSync` | warning | no | Nested `synchronize` blocks risk deadlock |
 | Framework | `ModuleFunctionPrivate` | convention | no | `private` after `module_function` resets visibility |
 
 ### Library-Specific (all gems, triggers on library usage) — 6 cops
@@ -60,7 +85,7 @@ No per-repo configuration needed for scoping. If a cop doesn't apply to your gem
 | Framework | `CacheTimeCoercion` | cache_get | convention | no | Time objects become Strings after cache round-trip |
 | Framework | `ApiStringKeys` | Legion::JSON.load | warning | yes | `Legion::JSON.load` returns symbol keys — use `body[:key]` |
 
-### LEX Extensions Only (`lib/legion/extensions/**/*.rb`) — 17 cops
+### LEX Extensions Only (`lib/legion/extensions/**/*.rb`) — 29 cops
 
 | Department | Cop | Severity | Auto-fix | Description |
 |---|---|---|---|---|
@@ -71,18 +96,37 @@ No per-repo configuration needed for scoping. If a cop doesn't apply to your gem
 | HelperMigration | `DirectLocalCache` | warning | yes | Use `local_cache_get`/`local_cache_set` instead of `Legion::Cache::Local` |
 | HelperMigration | `DirectCrypt` | warning | yes | Use `vault_get`/`vault_exist?` instead of `Legion::Crypt` |
 | HelperMigration | `LoggingGuard` | convention | no | Remove unnecessary `respond_to?(:log_warn)` / `defined?(Legion::Logging)` guards |
+| HelperMigration | `DirectData` | convention | yes | Use `data_connection`/`local_data_*` instead of `Legion::Data::Connection`/`Local` |
+| HelperMigration | `DirectLlmEmbed` | convention | yes | Use `llm_embed` instead of `Legion::LLM.embed` |
+| HelperMigration | `RequireDefinedGuard` | convention | yes | Remove `if defined?(Legion::...)` guard from `require` statements |
+| HelperMigration | `DefinedTransportGuard` | convention | no | Use `transport_connected?` instead of `defined?(Legion::Transport)` |
 | Extension | `ActorSingularModule` | error | yes | Use `module Actor` (singular) — framework discovers `Actor`, not `Actors` |
+| Extension | `RunnerPluralModule` | error | yes | Use `module Runners` (plural) — framework discovers `Runners`, not `Runner` |
 | Extension | `CoreExtendGuard` | error | yes | Guard `extend Core` with `const_defined?` for standalone compatibility |
 | Extension | `RunnerMustBeModule` | warning | no | Runners must be modules, not classes |
 | Extension | `RunnerIncludeHelpers` | convention | no | Runner modules need `include Helpers::Lex` or `extend self` |
+| Extension | `ActorInheritance` | error | no | Actor must inherit from Every, Once, Poll, Subscription, Loop, or Nothing |
+| Extension | `EveryActorRequiresTime` | warning | no | Every/Poll actors must call `time` DSL to set the interval |
 | Extension | `SelfContainedActorRunnerClass` | warning | no | Self-contained actors must override `runner_class` |
+| Extension | `HookMissingRunnerClass` | error | no | Hook classes must override `runner_class` |
+| Extension | `AbsorberMissingPattern` | warning | no | Absorber classes must call `pattern` DSL to match events |
+| Extension | `AbsorberMissingAbsorbMethod` | warning | no | Absorber classes must define `absorb` method |
+| Extension | `DefinitionCallMismatched` | error | no | `definition :name` must have matching `def name` method |
 | Extension | `RunnerReturnHash` | convention | no | Runner methods must return a Hash |
 | Extension | `SettingsKeyMethod` | error | yes | `Legion::Settings` has no `key?` — use `!Settings[:key].nil?` |
 | Extension | `SettingsBracketMultiArg` | error | yes | `Settings#[]` takes 1 arg — use `Settings.dig(...)` for nested access |
 | Extension | `LlmAskKwargs` | error | no | `Legion::LLM.ask` only accepts `message:` — no extra kwargs |
+| Extension | `ActorEnabledSideEffects` | convention | no | `enabled?` runs during boot — keep side-effect-free |
 | Extension | `DataRequiredWithoutMigrations` | warning | no | `data_required?` returns true but migrations may be missing |
 
-**Total: 32 cops** across 6 departments, 15 auto-correctable.
+**Total: 45 custom cops** across 6 departments, 19 auto-correctable.
+
+### Bundled Plugins
+
+Both shared config profiles also load:
+
+- **[rubocop-performance](https://github.com/rubocop/rubocop-performance)** — 52 cops for Ruby performance anti-patterns (all enabled)
+- **[rubocop-thread_safety](https://github.com/rubocop/rubocop-thread_safety)** — 6 cops for thread safety analysis (tuned for LegionIO)
 
 ## Per-Repo Overrides
 

data/config/base.yml

@@ -58,3 +58,38 @@ Naming/PredicateMethod:
 
 Gemspec/DevelopmentDependencies:
   Enabled: false
+
+# --- Performance ---
+# All Performance cops enabled by default (rubocop-performance).
+# Override per-repo only if needed.
+
+Performance:
+  Enabled: true
+
+# --- Thread Safety ---
+# LegionIO is a concurrent async engine. These cops catch real bugs.
+
+ThreadSafety:
+  Enabled: true
+
+ThreadSafety/NewThread:
+  Enabled: true
+  Exclude:
+    - 'lib/**/service.rb'
+    - 'lib/**/service/**/*.rb'
+    - 'lib/**/connection.rb'
+    - 'lib/**/connection/**/*.rb'
+    - 'spec/**/*'
+
+ThreadSafety/ClassInstanceVariable:
+  Enabled: true
+  Exclude:
+    - 'lib/**/singleton/**/*.rb'
+    - 'spec/**/*'
+
+ThreadSafety/RackMiddlewareInstanceVariable:
+  Enabled: false
+
+ThreadSafety/DirChdir:
+  Enabled: true
+  AllowCallWithBlock: true

data/config/core.yml

@@ -11,6 +11,8 @@ inherit_from: base.yml
 
 plugins:
   - rubocop-legion
+  - rubocop-performance
+  - rubocop-thread_safety
 
 Metrics/ParameterLists:
   Max: 10

data/config/default.yml

@@ -49,6 +49,30 @@ Legion/HelperMigration/LoggingGuard:
   Severity: convention
   VersionAdded: '0.1.2'
 
+Legion/HelperMigration/DirectData:
+  Description: 'Use `data_connection`/`local_data_*` helpers instead of `Legion::Data::Connection`/`Legion::Data::Local` methods.'
+  Enabled: true
+  Severity: convention
+  VersionAdded: '0.1.4'
+
+Legion/HelperMigration/DirectLlmEmbed:
+  Description: 'Use `llm_embed` helper instead of `Legion::LLM.embed`.'
+  Enabled: true
+  Severity: convention
+  VersionAdded: '0.1.4'
+
+Legion/HelperMigration/RequireDefinedGuard:
+  Description: 'Remove `if defined?(Legion::...)` guard from `require`/`require_relative` statements.'
+  Enabled: true
+  Severity: convention
+  VersionAdded: '0.1.4'
+
+Legion/HelperMigration/DefinedTransportGuard:
+  Description: 'Use `transport_connected?` instead of `defined?(Legion::Transport)`.'
+  Enabled: true
+  Severity: convention
+  VersionAdded: '0.1.4'
+
 # Legion/ConstantSafety — prevent namespace resolution bugs inside module Legion
 
 Legion/ConstantSafety:
@@ -163,6 +187,12 @@ Legion/Framework/CacheTimeCoercion:
   Severity: convention
   VersionAdded: '0.1'
 
+Legion/Framework/MutexNestedSync:
+  Description: 'Nested `synchronize` blocks risk deadlock if the same mutex is re-acquired.'
+  Enabled: true
+  Severity: warning
+  VersionAdded: '0.1.5'
+
 Legion/Framework/ApiStringKeys:
   Description: '`Legion::JSON.load` returns symbol keys. Use `body[:key]` not `body["key"]`.'
   Enabled: true
@@ -241,3 +271,51 @@ Legion/Extension/DataRequiredWithoutMigrations:
   Enabled: true
   Severity: warning
   VersionAdded: '0.1'
+
+Legion/Extension/RunnerPluralModule:
+  Description: 'Use `module Runners` (plural). Framework discovers runners in `Runners`, not `Runner`.'
+  Enabled: true
+  Severity: error
+  VersionAdded: '0.1.4'
+
+Legion/Extension/ActorInheritance:
+  Description: 'Actor must inherit from Every, Once, Poll, Subscription, Loop, or Nothing.'
+  Enabled: true
+  Severity: error
+  VersionAdded: '0.1.4'
+
+Legion/Extension/EveryActorRequiresTime:
+  Description: 'Every/Poll actors must call the `time` DSL method to set the interval.'
+  Enabled: true
+  Severity: warning
+  VersionAdded: '0.1.4'
+
+Legion/Extension/HookMissingRunnerClass:
+  Description: 'Hook classes must override `runner_class` or the framework dispatches to nil.'
+  Enabled: true
+  Severity: error
+  VersionAdded: '0.1.4'
+
+Legion/Extension/AbsorberMissingPattern:
+  Description: 'Absorber classes must call the `pattern` DSL method to match events.'
+  Enabled: true
+  Severity: warning
+  VersionAdded: '0.1.4'
+
+Legion/Extension/AbsorberMissingAbsorbMethod:
+  Description: 'Absorber classes must define an `absorb` method to handle matched events.'
+  Enabled: true
+  Severity: warning
+  VersionAdded: '0.1.4'
+
+Legion/Extension/ActorEnabledSideEffects:
+  Description: '`enabled?` runs during extension loading. Keep it cheap and side-effect-free.'
+  Enabled: true
+  Severity: convention
+  VersionAdded: '0.1.5'
+
+Legion/Extension/DefinitionCallMismatched:
+  Description: '`definition :name` must have a matching `def name` method in the same module.'
+  Enabled: true
+  Severity: error
+  VersionAdded: '0.1.4'

data/config/lex.yml

@@ -11,6 +11,8 @@ inherit_from: base.yml
 
 plugins:
   - rubocop-legion
+  - rubocop-performance
+  - rubocop-thread_safety
 
 Metrics/ParameterLists:
   Max: 8

data/lib/rubocop/cop/legion/extension/absorber_missing_absorb_method.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Legion
+      module Extension
+        # Detects absorber classes inside an `Absorbers` namespace that do not define
+        # the `absorb` instance method. The framework calls `absorb` when a matching
+        # event arrives — without it, the absorber silently drops events.
+        #
+        # @example
+        #   # bad
+        #   module Absorbers
+        #     class Foo
+        #       pattern 'some.event.*'
+        #     end
+        #   end
+        #
+        #   # good
+        #   module Absorbers
+        #     class Foo
+        #       pattern 'some.event.*'
+        #
+        #       def absorb(event)
+        #         process(event)
+        #       end
+        #     end
+        #   end
+        class AbsorberMissingAbsorbMethod < RuboCop::Cop::Base
+          MSG = 'Absorber classes must define an `absorb` method to handle matched events.'
+
+          def on_class(node)
+            return unless inside_absorbers_namespace?(node)
+            return if defines_absorb?(node)
+
+            add_offense(node.identifier)
+          end
+
+          private
+
+          def inside_absorbers_namespace?(node)
+            current = node.parent
+            while current
+              return true if current.module_type? && current.identifier.short_name == :Absorbers
+
+              current = current.parent
+            end
+            false
+          end
+
+          def defines_absorb?(node)
+            return false unless node.body
+
+            node.body.each_node(:def).any? do |def_node|
+              def_node.method_name == :absorb
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/legion/extension/absorber_missing_pattern.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Legion
+      module Extension
+        # Detects absorber classes inside an `Absorbers` namespace that do not call
+        # the `pattern` DSL method. Without `pattern`, the absorber will not match
+        # any events and will be silently inactive.
+        #
+        # @example
+        #   # bad
+        #   module Absorbers
+        #     class Foo
+        #       def absorb(event)
+        #         process(event)
+        #       end
+        #     end
+        #   end
+        #
+        #   # good
+        #   module Absorbers
+        #     class Foo
+        #       pattern 'some.event.*'
+        #
+        #       def absorb(event)
+        #         process(event)
+        #       end
+        #     end
+        #   end
+        class AbsorberMissingPattern < RuboCop::Cop::Base
+          MSG = 'Absorber classes must call the `pattern` DSL method to match events.'
+
+          def on_class(node)
+            return unless inside_absorbers_namespace?(node)
+            return if calls_pattern?(node)
+
+            add_offense(node.identifier)
+          end
+
+          private
+
+          def inside_absorbers_namespace?(node)
+            current = node.parent
+            while current
+              return true if current.module_type? && current.identifier.short_name == :Absorbers
+
+              current = current.parent
+            end
+            false
+          end
+
+          def calls_pattern?(node)
+            return false unless node.body
+
+            node.body.each_node(:send).any? do |send_node|
+              send_node.method_name == :pattern && send_node.receiver.nil?
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/legion/extension/actor_enabled_side_effects.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Legion
+      module Extension
+        # Detects `def enabled?` methods inside actor classes. The `enabled?`
+        # method runs during extension loading before `delay` is honoured,
+        # so it must be cheap and side-effect-free (no network calls, mutex
+        # locks, or I/O).
+        #
+        # @example
+        #   # bad — network call during boot
+        #   module Actor
+        #     class Check < Every
+        #       def enabled?
+        #         Legion::Transport.connected?
+        #       end
+        #     end
+        #   end
+        #
+        #   # good — cheap Settings lookup
+        #   module Actor
+        #     class Check < Every
+        #       def enabled?
+        #         !Legion::Settings[:check].nil?
+        #       end
+        #     end
+        #   end
+        class ActorEnabledSideEffects < RuboCop::Cop::Base
+          MSG = '`enabled?` runs during extension loading, before `delay`. ' \
+                'Keep it cheap and side-effect-free (no network calls, mutex locks, or I/O).'
+
+          def on_def(node)
+            return unless node.method_name == :enabled?
+            return unless inside_actor_namespace?(node)
+
+            add_offense(node)
+          end
+
+          private
+
+          def inside_actor_namespace?(node)
+            current = node.parent
+            while current
+              return true if current.module_type? && current.identifier.short_name == :Actor
+
+              current = current.parent
+            end
+            false
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/legion/extension/actor_inheritance.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Legion
+      module Extension
+        # Detects actor classes inside an `Actor` namespace that do not inherit from
+        # a recognized LEX actor base class. Every actor must inherit from one of:
+        # `Every`, `Once`, `Poll`, `Subscription`, `Loop`, or `Nothing`.
+        #
+        # @example
+        #   # bad
+        #   module Actor
+        #     class Foo
+        #     end
+        #   end
+        #
+        #   # bad
+        #   module Actor
+        #     class Foo < SomeOtherBase
+        #     end
+        #   end
+        #
+        #   # good
+        #   module Actor
+        #     class Foo < Legion::Extensions::Actors::Every
+        #     end
+        #   end
+        class ActorInheritance < RuboCop::Cop::Base
+          MSG = 'Actor must inherit from a recognized base: Every, Once, Poll, Subscription, Loop, or Nothing.'
+
+          RECOGNIZED_BASES = %i[Every Once Poll Subscription Loop Nothing].to_set.freeze
+
+          def on_class(node)
+            return unless inside_actor_namespace?(node)
+
+            superclass = node.parent_class
+            return if superclass && recognized_base?(superclass)
+
+            add_offense(node.identifier)
+          end
+
+          private
+
+          def inside_actor_namespace?(node)
+            current = node.parent
+            while current
+              return true if current.module_type? && current.identifier.short_name == :Actor
+
+              current = current.parent
+            end
+            false
+          end
+
+          def recognized_base?(superclass_node)
+            # Handle both `< Every` and `< Legion::Extensions::Actors::Every`
+            leaf = superclass_node
+            leaf = leaf.children.last while leaf.const_type? && leaf.children.last.is_a?(Symbol) == false
+            RECOGNIZED_BASES.include?(leaf.children.last)
+          end
+        end
+      end
+    end
+  end
+end