rubocop-legion 0.1.2 → 0.1.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1d2c3a1967dcc9bd66a2c806d2b471b59594d51ae9fec7c2c3eaad9946898932
-  data.tar.gz: cdd7fcb62b6b0ff1eb17d595aa6a7b76259fdefa7ae5ecd6d6b1306f98e817c1
+  metadata.gz: f841ecd6e5821651ad020bd243791971cf7ab5dca138178d90d216e8a58a48ba
+  data.tar.gz: acd221dbf9f924e6f81b21569262ea6a8aebbe42d4753356f9750cd3cc0c13a0
 SHA512:
-  metadata.gz: 0515bb7d5ea06e80069a937b9899e23bf281366660d718cd707460b0ed63a9955ed4ff531f6e592c9b203ea090bda1ba620d5d80fbb4b758dab3b91f9190dc71
-  data.tar.gz: 673910f539a627bd4697e1bfd86ee8c8b0f9644d257090fafcad43907bd080af80be71e961340e53be6077251dd8dd302b957fcb8d74a4418be228b3f6fd175c
+  metadata.gz: 5933d7f5010bc89b49a95e3d4c0080d752d583fab9a4c11e5fc3a244a0e45938be35eeb6f6851386452d72eca5c135434b6fe1d7dc6cb2a5be163bf7a0213576
+  data.tar.gz: 62b31e59d175e345383a02764b3c1c32a7599e70af80e31d8f0685730579c5396d9cdd783e19fb16ca18809e43b33cead79b6ad03f444acc77045fe4c2dd6399

data/CHANGELOG.md

@@ -1,5 +1,39 @@
 # 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
+- Shared config profiles: `config/lex.yml` for lex-* gems, `config/core.yml` for legion-* gems
+- Use `inherit_gem: { rubocop-legion: config/lex.yml }` to replace 60-line .rubocop.yml with 2 lines
+
 ## [0.1.2] - 2026-03-29
 
 ### Added

data/CLAUDE.md

@@ -0,0 +1,114 @@
+# rubocop-legion
+
+**Parent**: `/Users/miverso2/rubymine/legion/CLAUDE.md`
+
+## What is This?
+
+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** (28 cops): Scoped to `lib/legion/extensions/**/*.rb` via Include directive — never fire on core `legion-*` libraries
+
+## Departments and 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
+
+- `EagerSequelModel` — `Sequel::Model(:table)` at require time
+- `SinatraHostAuth` — Sinatra 4.0+ `set :host_authorization`
+- `ThorReservedRun` — Thor 1.5+ reserves `run`
+- `FaradayXmlMiddleware` — Faraday 2.0+ removed `:xml`
+- `CacheTimeCoercion` — Time→String after cache round-trip
+- `ApiStringKeys` — `Legion::JSON.load` returns symbol keys (scoped to `lib/legion/extensions/**/*.rb`)
+
+### LEX-Only — 29 cops
+
+- **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
+
+```
+rubocop-legion/
+├── lib/
+│   ├── rubocop-legion.rb              # Entry point, requires all cops
+│   └── rubocop/
+│       ├── legion.rb                  # Namespace declarations
+│       ├── legion/
+│       │   ├── version.rb
+│       │   └── plugin.rb             # LintRoller::Plugin (auto-discovery)
+│       └── cop/legion/
+│           ├── helper_migration/      # 7 cops (lex-only)
+│           ├── constant_safety/       # 4 cops (universal)
+│           ├── singleton/             # 1 cop  (universal)
+│           ├── rescue_logging/        # 3 cops (universal)
+│           ├── framework/             # 7 cops (universal + library-specific)
+│           └── extension/             # 17 cops (lex-only)
+├── config/
+│   └── default.yml                    # All cop defaults, Include/Exclude scoping
+└── spec/                              # mirrors lib/ structure
+```
+
+## Key Implementation Details
+
+- Plugin entry point: `RuboCop::Legion::Plugin` (LintRoller-based, registered via gemspec metadata `default_lint_roller_plugin`)
+- All cops inherit from `RuboCop::Cop::Base`
+- Auto-correctable cops use `extend AutoCorrector`
+- AST matching via `def_node_matcher` and `def_node_search`
+- Specs use `RuboCop::RSpec::Support` with `:config` shared context and `expect_offense`/`expect_correction`
+- `BareRescue` and `NoCapture` skip rescue modifiers (inline `rescue`) to avoid syntax corruption
+- `NoCapture` has no auto-correct to prevent correction loop with `Lint/UselessAssignment`
+- `SilentCapture` skips `_`-prefixed variables (Ruby unused convention)
+
+## Development
+
+```bash
+bundle install
+bundle exec rspec      # 322 specs
+bundle exec rubocop    # Self-linting
+```
+
+## Common Per-Repo Overrides
+
+```yaml
+# Repos using Faraday JSON middleware (string keys, not Legion::JSON symbol keys)
+Legion/Framework/ApiStringKeys:
+  Enabled: false
+```
+
+---
+
+**Maintained By**: Matthew Iverson (@Esity)

data/README.md

@@ -2,35 +2,141 @@
 
 LegionIO code quality cops for [RuboCop](https://rubocop.org/).
 
-Custom cops for the LegionIO async job engine ecosystem. Enforces helper usage, constant safety, rescue logging, framework conventions, and LEX extension structure.
+Custom cops for the LegionIO async job engine ecosystem. Enforces helper usage, constant safety, rescue logging, framework conventions, and LEX extension structure. Replaces the regex-based `lint-patterns.yml` CI workflow with precise AST-based analysis and auto-correction.
 
 ## Installation
 
 Add to your Gemfile:
 
 ```ruby
-gem 'rubocop-legion', require: false, group: :development
+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
+# .rubocop.yml
+inherit_gem:
+  rubocop-legion: config/lex.yml
+```
+
+**For `legion-*` core library gems:**
 
 ```yaml
-plugins:
-  - rubocop-legion
+# .rubocop.yml
+inherit_gem:
+  rubocop-legion: config/core.yml
 ```
 
-## Departments
+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:
+
+- **Universal cops** fire on all LegionIO gems (any code inside `module Legion`)
+- **Library-specific cops** fire on all gems but only trigger when using a specific library (Sequel, Sinatra, Thor, Faraday, etc.)
+- **LEX-only cops** fire only on `lib/legion/extensions/**/*.rb` — they don't apply to core `legion-*` libraries
+
+No per-repo configuration needed for scoping. If a cop doesn't apply to your gem type, it won't fire.
+
+## Cops
 
-| Department | Cops | Description |
-|---|---|---|
-| `Legion/HelperMigration` | 6 | Use per-extension helpers, not global singletons |
-| `Legion/ConstantSafety` | 4 | Prevent namespace resolution bugs inside `module Legion` |
-| `Legion/Singleton` | 1 | Enforce `.instance` on singleton classes |
-| `Legion/RescueLogging` | 3 | Every rescue must log or re-raise |
-| `Legion/Framework` | 7 | Sequel, Sinatra, Thor, Faraday, and API gotchas |
-| `Legion/Extension` | 10 | LEX structural convention enforcement |
+### Universal (all LegionIO gems) — 10 cops
+
+| Department | Cop | Severity | Auto-fix | Description |
+|---|---|---|---|---|
+| ConstantSafety | `BareDataDefine` | error | yes | Use `::Data.define` inside `module Legion` to avoid `Legion::Data` |
+| ConstantSafety | `BareProcess` | error | yes | Use `::Process` inside `module Legion` to avoid `Legion::Process` |
+| ConstantSafety | `BareJson` | error | yes | Use `::JSON` inside `module Legion` to avoid `Legion::JSON` |
+| ConstantSafety | `InheritParam` | convention | yes | Pass `false` to `const_defined?`/`const_get` on dynamic modules |
+| RescueLogging | `BareRescue` | warning | yes | Bare `rescue` swallows exceptions — capture with `rescue => e` |
+| 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
+
+| Department | Cop | Triggers on | Severity | Auto-fix | Description |
+|---|---|---|---|---|---|
+| Framework | `EagerSequelModel` | Sequel | warning | no | `Sequel::Model(:table)` introspects schema at require time |
+| Framework | `SinatraHostAuth` | Sinatra | convention | no | Sinatra 4.0+ requires `set :host_authorization` |
+| Framework | `ThorReservedRun` | Thor | warning | no | Thor 1.5+ reserves `run` — rename or use `map` |
+| Framework | `FaradayXmlMiddleware` | Faraday | error | no | Faraday 2.0+ removed built-in `:xml` middleware |
+| 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`) — 29 cops
+
+| Department | Cop | Severity | Auto-fix | Description |
+|---|---|---|---|---|
+| HelperMigration | `DirectLogging` | warning | yes | Use `log.method` instead of `Legion::Logging.method` |
+| HelperMigration | `OldLoggingMethods` | warning | yes | Use `log.method` instead of deprecated `log_method` helpers |
+| HelperMigration | `DirectJson` | convention | yes | Use `json_load`/`json_dump` instead of `Legion::JSON` |
+| HelperMigration | `DirectCache` | warning | yes | Use `cache_get`/`cache_set` instead of `Legion::Cache` |
+| 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: 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
+
+Most repos need no overrides. Common exceptions:
+
+```yaml
+# Repos using Faraday JSON middleware (string keys, not Legion::JSON symbol keys)
+Legion/Framework/ApiStringKeys:
+  Enabled: false
+```
 
 ## License
 

data/config/base.yml

@@ -0,0 +1,95 @@
+# Shared RuboCop configuration for all LegionIO gems.
+# Do not use directly — inherit via config/lex.yml or config/core.yml.
+
+AllCops:
+  TargetRubyVersion: 3.4
+  NewCops: enable
+  SuggestExtensions: false
+
+Layout/LineLength:
+  Max: 160
+
+Layout/SpaceAroundEqualsInParameterDefault:
+  EnforcedStyle: space
+
+Layout/HashAlignment:
+  EnforcedHashRocketStyle: table
+  EnforcedColonStyle: table
+
+Metrics/MethodLength:
+  Max: 50
+
+Metrics/ClassLength:
+  Max: 1500
+
+Metrics/ModuleLength:
+  Max: 1500
+
+Metrics/BlockLength:
+  Max: 40
+  Exclude:
+    - 'spec/**/*'
+    - '*.gemspec'
+
+Metrics/AbcSize:
+  Max: 60
+
+Metrics/CyclomaticComplexity:
+  Max: 15
+
+Metrics/PerceivedComplexity:
+  Max: 17
+
+Style/Documentation:
+  Enabled: false
+
+Style/SymbolArray:
+  Enabled: true
+
+Style/FrozenStringLiteralComment:
+  Enabled: true
+  EnforcedStyle: always
+
+Naming/FileName:
+  Enabled: false
+
+Naming/PredicateMethod:
+  Enabled: false
+
+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

@@ -0,0 +1,19 @@
+# Shared RuboCop configuration for legion-* core library gems.
+#
+# Usage in your .rubocop.yml:
+#
+#   inherit_gem:
+#     rubocop-legion: config/core.yml
+#
+#   # Repo-specific overrides below (if any)
+
+inherit_from: base.yml
+
+plugins:
+  - rubocop-legion
+  - rubocop-performance
+  - rubocop-thread_safety
+
+Metrics/ParameterLists:
+  Max: 10
+  CountKeywordArgs: false

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

@@ -0,0 +1,18 @@
+# Shared RuboCop configuration for lex-* extension gems.
+#
+# Usage in your .rubocop.yml:
+#
+#   inherit_gem:
+#     rubocop-legion: config/lex.yml
+#
+#   # Repo-specific overrides below (if any)
+
+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