lex-cognitive-tectonics 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 6beef28cd3264b3978f5e982e00fca770a6b80b5d63a29d8155b5208ae8d399a
+  data.tar.gz: 9a9c401d00654e2473066da9be054972920e2f257cda552d18f1a1c51fef03bb
+SHA512:
+  metadata.gz: 10e34cf80558cac6f3a5fe4e06c05bc7153b68d2501145451f592964d8902d84e1c383fcbe894fd05daea10093da39cf9fe4ce015dc1191b4d901a282a221de2
+  data.tar.gz: 4afbe3e1eb7bcc4360f8e5609de40fc58bd597347189a4d6945a299b298f58dfd93bcca364aad017e416dbe533dc10b38b3d0b362af822fa7d77cd43e82b24af

data/.github/workflows/ci.yml

@@ -0,0 +1,16 @@
+name: CI
+on:
+  push:
+    branches: [main]
+  pull_request:
+
+jobs:
+  ci:
+    uses: LegionIO/.github/.github/workflows/ci.yml@main
+
+  release:
+    needs: ci
+    if: github.event_name == 'push' && github.ref == 'refs/heads/main'
+    uses: LegionIO/.github/.github/workflows/release.yml@main
+    secrets:
+      rubygems-api-key: ${{ secrets.RUBYGEMS_API_KEY }}

data/.gitignore

@@ -0,0 +1,11 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.gem
+Gemfile.lock
+.rspec_status

data/.rspec

@@ -0,0 +1,2 @@
+--require spec_helper
+--format documentation

data/.rubocop.yml

@@ -0,0 +1,64 @@
+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: 25
+
+Metrics/ClassLength:
+  Max: 150
+
+Metrics/ModuleLength:
+  Max: 150
+
+Metrics/BlockLength:
+  Max: 40
+  Exclude:
+    - 'spec/**/*'
+
+Metrics/AbcSize:
+  Max: 25
+
+Metrics/ParameterLists:
+  Max: 8
+  MaxOptionalParameters: 8
+
+Metrics/CyclomaticComplexity:
+  Max: 15
+
+Metrics/PerceivedComplexity:
+  Max: 17
+
+Style/Documentation:
+  Enabled: false
+
+Style/SymbolArray:
+  Enabled: true
+
+Style/FrozenStringLiteralComment:
+  Enabled: true
+  EnforcedStyle: always
+
+Style/OneClassPerFile:
+  Exclude:
+    - 'spec/spec_helper.rb'
+
+Naming/FileName:
+  Enabled: false
+
+Naming/PredicateMethod:
+  Enabled: false
+
+Naming/PredicatePrefix:
+  Enabled: false

data/CLAUDE.md

@@ -0,0 +1,137 @@
+# lex-cognitive-tectonics
+
+**Level 3 Leaf Documentation**
+- **Parent**: `/Users/miverso2/rubymine/legion/extensions-agentic/CLAUDE.md`
+- **Gem**: `lex-cognitive-tectonics`
+- **Version**: 0.1.0
+- **Namespace**: `Legion::Extensions::CognitiveTectonics`
+
+## Purpose
+
+Models belief revision as plate tectonics. Cognitive beliefs are represented as plates with mass, position, and drift vectors in a 2D space. Plates drift over time, collide, and interact via three boundary types: convergent (beliefs merge), divergent (beliefs split and drift apart), or transform (friction accumulates stress that eventually triggers earthquakes). Seismic events model sudden, cascading belief shifts. A periodic `DriftTick` actor moves all plates each tick.
+
+## Gem Info
+
+- **Gemspec**: `lex-cognitive-tectonics.gemspec`
+- **Require**: `lex-cognitive-tectonics`
+- **Ruby**: >= 3.4
+- **License**: MIT
+- **Homepage**: https://github.com/LegionIO/lex-cognitive-tectonics
+
+## File Structure
+
+```
+lib/legion/extensions/cognitive_tectonics/
+  version.rb
+  helpers/
+    constants.rb         # Boundary types, magnitude labels, stress/collision thresholds
+    belief_plate.rb      # BeliefPlate class — one belief with position, mass, stress
+    seismic_event.rb     # SeismicEvent class — earthquake/tremor/aftershock record
+    tectonic_engine.rb   # TectonicBoundaries module + TectonicEngine class
+  runners/
+    cognitive_tectonics.rb  # Runner module — public API (extend self)
+  actors/
+    drift_tick.rb        # Actor::DriftTick — fires drift_tick every 60s
+  client.rb
+```
+
+## Key Constants
+
+| Constant | Value | Meaning |
+|---|---|---|
+| `MAX_PLATES` | 50 | Hard cap on belief plates (raises if exceeded) |
+| `MAX_QUAKES` | 200 | Seismic history ring size |
+| `COLLISION_THRESHOLD` | 0.2 | Distance below which two plates collide |
+| `SUBDUCTION_RATIO` | 0.7 | Mass below which a plate is subductable |
+| `AFTERSHOCK_DECAY` | 0.3 | Magnitude multiplier reduction for aftershocks |
+| `STRESS_QUAKE_TRIGGER` | 1.0 | Stress accumulation that auto-triggers earthquake |
+| `MIN_DRIFT_RATE` | 0.001 | Minimum allowed drift component (reference) |
+| `MAX_DRIFT_RATE` | 0.05 | Maximum allowed drift component (reference) |
+
+`BOUNDARY_TYPES`: `[:convergent, :divergent, :transform]`
+
+`PLATE_STATES`: `[:active, :subducted, :dormant]`
+
+Magnitude labels: `[0,1)` = `:micro`, `[1,2)` = `:minor`, `[2,3)` = `:light`, `[3,4)` = `:moderate`, `[4,5)` = `:strong`, `5+` = `:great`
+
+## Key Classes
+
+### `Helpers::BeliefPlate`
+
+One cognitive belief with spatial position, mass, drift, and stress.
+
+- `drift!(delta_t)` — advances position by `drift_vector * delta_t`; only active plates drift
+- `accumulate_stress!(amount)` — adds to `@stress_accumulation`
+- `release_stress!` — resets stress to 0.0; returns the released amount
+- `subducted?` — mass < `SUBDUCTION_RATIO`
+- `subduct!` / `dormant!` — transitions state
+- `active?` — `state == :active`
+- `distance_to(other_plate)` — Euclidean distance between positions
+- Position is initialized with random `x,y` in `[-10.0, 10.0]` if not provided
+
+### `Helpers::SeismicEvent`
+
+A seismic event record for the history log.
+
+- `EVENT_TYPES`: `[:earthquake, :tremor, :aftershock]`
+- `label` — magnitude label from `Constants#label_for`
+- `aftershock?` — type == `:aftershock`
+- Fields: `id`, `type`, `magnitude`, `epicenter_plate_id`, `affected_plate_ids`, `parent_event_id`, `timestamp`
+
+### `Helpers::TectonicBoundaries` (module)
+
+Private collision resolution methods mixed into `TectonicEngine`.
+
+- `resolve_convergent` — averages mass and drift vectors; outcome `:merged`
+- `resolve_divergent` — halves mass; reverses x-drift for A, y-drift for B; outcome `:split`
+- `resolve_transform` — adds `mass_a * mass_b * 0.5` stress to both; calls `check_stress_quake`; outcome `:friction`
+- `check_stress_quake` — auto-triggers earthquake if plate stress >= `STRESS_QUAKE_TRIGGER`
+
+### `Helpers::TectonicEngine`
+
+Registry and event processing.
+
+- `create_plate(domain:, content:, mass:, drift_vector:, position:)` — raises if at `MAX_PLATES`
+- `drift_tick!(delta_t)` — drifts all active plates; detects collisions afterward
+- `detect_collisions` — all active plate pairs with distance < `COLLISION_THRESHOLD`
+- `resolve_collision(plate_a_id:, plate_b_id:, boundary_type:)` — dispatches to `TectonicBoundaries`; updates fault registry
+- `subduct(weaker_plate_id:, stronger_plate_id:)` — absorbs 50% of weaker plate's mass into stronger; marks weaker as subducted
+- `trigger_earthquake(plate_id:, magnitude:)` — releases stress; propagates 30% magnitude to nearby plates (< 5.0 distance)
+- `aftershock_cascade(event_id:)` — creates aftershock at `magnitude * (1 - AFTERSHOCK_DECAY)`
+- `tectonic_report` — aggregate with plate counts, high-stress count, recent quakes
+
+## Runners
+
+Module: `Legion::Extensions::CognitiveTectonics::Runners::CognitiveTectonics` (uses `extend self`)
+
+| Runner | Key Args | Returns |
+|---|---|---|
+| `create_plate` | `domain:`, `content:`, `mass:`, `drift_vector:`, `position:` | `{ success:, plate_id:, plate: }` |
+| `drift_tick` | `delta_t:` | `{ success:, plates_moved:, collisions_detected:, collisions: }` |
+| `resolve_collision` | `plate_a_id:`, `plate_b_id:`, `boundary_type:` | boundary-specific result hash |
+| `trigger_earthquake` | `plate_id:`, `magnitude:` | `{ success:, event_id:, event: }` |
+| `tectonic_status` | — | `{ success:, total_plates:, active_plates:, high_stress_count:, recent_quakes:, ... }` |
+
+## Actors
+
+`Actor::DriftTick` — extends `Legion::Extensions::Actors::Every`
+
+- Fires `drift_tick` every **60 seconds**
+- `run_now?: false`, `use_runner?: false`, `check_subtask?: false`, `generate_task?: false`
+- Advances all plate positions and surfaces new collisions each minute
+
+## Integration Points
+
+- `drift_tick` is called automatically every 60s by `Actor::DriftTick`
+- Can be triggered manually via runner for faster simulation
+- Collision detection returns plate ID pairs — caller decides the boundary type for `resolve_collision`
+- Transform boundary is the only type that accumulates stress; high-stress states can be read via `tectonic_report`
+- All state is in-memory per `TectonicEngine` instance; reset is not built in (replace `@tectonic_engine`)
+
+## Development Notes
+
+- `MIN_DRIFT_RATE` and `MAX_DRIFT_RATE` are defined but not enforced; drift components in `drift_vector` are caller-specified
+- `nearby_plates` uses a fixed radius of 5.0 (hardcoded in `TectonicBoundaries`)
+- The runner raises `ArgumentError` directly for missing required args, then rescues it into `{ success: false, error: }`
+- Fault registry (`@active_faults`) is a plain array of hashes, not indexed — O(n) for lookup
+- Seismic history is a ring buffer capped at `MAX_QUAKES`: `@seismic_history.shift if size > MAX_QUAKES`

data/Gemfile

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+source 'https://rubygems.org'
+
+gemspec
+
+group :test do
+  gem 'rspec', '~> 3.13'
+  gem 'rubocop', '~> 1.75', require: false
+  gem 'rubocop-rspec', require: false
+end
+
+gem 'legion-gaia', path: '../../legion-gaia'

data/README.md

@@ -0,0 +1,62 @@
+# lex-cognitive-tectonics
+
+A LegionIO cognitive architecture extension that models belief revision as plate tectonics. Beliefs drift through conceptual space, collide, and interact via convergent, divergent, or transform boundaries. Stress accumulates and releases as earthquakes — sudden, cascading belief shifts.
+
+## What It Does
+
+Manages **belief plates** — cognitive beliefs with position, mass, and drift velocity in a 2D space. A background actor moves all plates every 60 seconds. When plates collide, the caller resolves the interaction by choosing a boundary type:
+
+- **Convergent**: beliefs merge; masses and drifts average together
+- **Divergent**: beliefs split and drift apart; mass halves
+- **Transform**: friction builds stress; at threshold stress triggers an earthquake
+
+Earthquakes release stress and propagate to nearby plates.
+
+## Usage
+
+```ruby
+require 'lex-cognitive-tectonics'
+
+client = Legion::Extensions::CognitiveTectonics::Client.new
+
+# Create belief plates
+r1 = client.create_plate(domain: :ethics, content: 'harm prevention is primary', mass: 0.8,
+                          drift_vector: { x: 0.01, y: 0.0 })
+# => { success: true, plate_id: "uuid...", plate: { mass: 0.8, state: :active, position: {...}, ... } }
+
+r2 = client.create_plate(domain: :ethics, content: 'autonomy is primary', mass: 0.7,
+                          drift_vector: { x: -0.01, y: 0.0 })
+
+# Advance one tick (also fires automatically every 60s via Actor::DriftTick)
+client.drift_tick(delta_t: 1.0)
+# => { success: true, plates_moved: 2, collisions_detected: 0, collisions: [] }
+
+# If plates collide, resolve the interaction
+# (plates with distance < 0.2 are flagged as collisions)
+client.resolve_collision(
+  plate_a_id: r1[:plate_id],
+  plate_b_id: r2[:plate_id],
+  boundary_type: :transform
+)
+# => { success: true, boundary_type: :transform, outcome: :friction, stress_added: 0.28 }
+
+# Manually trigger an earthquake at a plate
+client.trigger_earthquake(plate_id: r1[:plate_id], magnitude: 2.5)
+# => { success: true, event_id: "uuid...", event: { type: :earthquake, magnitude: 2.5, label: :light, ... } }
+
+# System report
+client.tectonic_status
+# => { success: true, total_plates: 2, active_plates: 2, high_stress_count: 0, seismic_events: 1, ... }
+```
+
+## Development
+
+```bash
+bundle install
+bundle exec rspec
+bundle exec rubocop
+```
+
+## License
+
+MIT

data/lex-cognitive-tectonics.gemspec

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require_relative 'lib/legion/extensions/cognitive_tectonics/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'lex-cognitive-tectonics'
+  spec.version       = Legion::Extensions::CognitiveTectonics::VERSION
+  spec.authors       = ['Esity']
+  spec.email         = ['matthewdiverson@gmail.com']
+
+  spec.summary       = 'LEX Cognitive Tectonics'
+  spec.description   = 'Tectonic belief-plate model for LegionIO — conviction as mass, drift vectors, ' \
+                       'convergent/divergent/transform boundaries, seismic belief shifts, and aftershock cascades'
+  spec.homepage      = 'https://github.com/LegionIO/lex-cognitive-tectonics'
+  spec.license       = 'MIT'
+  spec.required_ruby_version = '>= 3.4'
+
+  spec.metadata['homepage_uri']        = spec.homepage
+  spec.metadata['source_code_uri']     = 'https://github.com/LegionIO/lex-cognitive-tectonics'
+  spec.metadata['documentation_uri']   = 'https://github.com/LegionIO/lex-cognitive-tectonics'
+  spec.metadata['changelog_uri']       = 'https://github.com/LegionIO/lex-cognitive-tectonics'
+  spec.metadata['bug_tracker_uri']     = 'https://github.com/LegionIO/lex-cognitive-tectonics/issues'
+  spec.metadata['rubygems_mfa_required'] = 'true'
+
+  spec.files = Dir.chdir(File.expand_path(__dir__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+  spec.require_paths = ['lib']
+  spec.add_development_dependency 'legion-gaia'
+end

data/lib/legion/extensions/cognitive_tectonics/actors/drift_tick.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/actors/every'
+
+module Legion
+  module Extensions
+    module CognitiveTectonics
+      module Actor
+        class DriftTick < Legion::Extensions::Actors::Every
+          def runner_class
+            Legion::Extensions::CognitiveTectonics::Runners::CognitiveTectonics
+          end
+
+          def runner_function
+            'drift_tick'
+          end
+
+          def time
+            60
+          end
+
+          def run_now?
+            false
+          end
+
+          def use_runner?
+            false
+          end
+
+          def check_subtask?
+            false
+          end
+
+          def generate_task?
+            false
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/cognitive_tectonics/client.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module CognitiveTectonics
+      class Client
+        include Runners::CognitiveTectonics
+
+        attr_reader :engine
+
+        def initialize(engine: nil, **)
+          @engine          = engine || Helpers::TectonicEngine.new
+          @tectonic_engine = @engine
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/cognitive_tectonics/helpers/belief_plate.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+
+module Legion
+  module Extensions
+    module CognitiveTectonics
+      module Helpers
+        class BeliefPlate
+          include Constants
+
+          attr_reader :id, :domain, :content, :created_at, :state
+          attr_accessor :mass, :drift_vector, :position, :velocity, :stress_accumulation
+
+          def initialize(domain:, content:, mass: 0.5, drift_vector: nil, position: nil, **)
+            @id                  = SecureRandom.uuid
+            @domain              = domain
+            @content             = content
+            @mass                = mass.clamp(0.0, 1.0)
+            @drift_vector        = drift_vector || { x: 0.0, y: 0.0 }
+            @position            = position || { x: rand(-10.0..10.0).round(10), y: rand(-10.0..10.0).round(10) }
+            @velocity            = { x: 0.0, y: 0.0 }
+            @stress_accumulation = 0.0
+            @state               = :active
+            @created_at          = Time.now.utc
+          end
+
+          def drift!(delta_t = 1.0)
+            return if @state != :active
+
+            @position[:x] = (@position[:x] + (@drift_vector.fetch(:x, 0.0) * delta_t)).round(10)
+            @position[:y] = (@position[:y] + (@drift_vector.fetch(:y, 0.0) * delta_t)).round(10)
+          end
+
+          def accumulate_stress!(amount)
+            @stress_accumulation = (@stress_accumulation + amount.abs).round(10)
+          end
+
+          def release_stress!
+            released = @stress_accumulation
+            @stress_accumulation = 0.0
+            released
+          end
+
+          def subducted?
+            @mass < Constants::SUBDUCTION_RATIO
+          end
+
+          def subduct!
+            @state = :subducted
+          end
+
+          def dormant!
+            @state = :dormant
+          end
+
+          def active?
+            @state == :active
+          end
+
+          def distance_to(other_plate)
+            dx = @position[:x] - other_plate.position[:x]
+            dy = @position[:y] - other_plate.position[:y]
+            Math.sqrt((dx**2) + (dy**2)).round(10)
+          end
+
+          def to_h
+            {
+              id:                  @id,
+              domain:              @domain,
+              content:             @content,
+              mass:                @mass,
+              drift_vector:        @drift_vector,
+              position:            @position,
+              velocity:            @velocity,
+              stress_accumulation: @stress_accumulation,
+              state:               @state,
+              created_at:          @created_at
+            }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/cognitive_tectonics/helpers/constants.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module CognitiveTectonics
+      module Helpers
+        module Constants
+          MAX_PLATES            = 50
+          MAX_QUAKES            = 200
+          BOUNDARY_TYPES        = %i[convergent divergent transform].freeze
+          MIN_DRIFT_RATE        = 0.001
+          MAX_DRIFT_RATE        = 0.05
+          COLLISION_THRESHOLD   = 0.2
+          SUBDUCTION_RATIO      = 0.7
+          AFTERSHOCK_DECAY      = 0.3
+          STRESS_QUAKE_TRIGGER  = 1.0
+
+          PLATE_STATES = %i[active subducted dormant].freeze
+
+          MAGNITUDE_LABELS = {
+            (0.0...1.0)             => :micro,
+            (1.0...2.0)             => :minor,
+            (2.0...3.0)             => :light,
+            (3.0...4.0)             => :moderate,
+            (4.0...5.0)             => :strong,
+            (5.0...Float::INFINITY) => :great
+          }.freeze
+
+          def label_for(magnitude)
+            MAGNITUDE_LABELS.find { |range, _| range.cover?(magnitude) }&.last || :unknown
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/cognitive_tectonics/helpers/seismic_event.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+
+module Legion
+  module Extensions
+    module CognitiveTectonics
+      module Helpers
+        class SeismicEvent
+          include Constants
+
+          EVENT_TYPES = %i[earthquake tremor aftershock].freeze
+
+          attr_reader :id, :type, :magnitude, :epicenter_plate_id,
+                      :affected_plate_ids, :timestamp, :parent_event_id
+
+          def initialize(type:, magnitude:, epicenter_plate_id:, affected_plate_ids: [], parent_event_id: nil, **)
+            raise ArgumentError, "unknown event type: #{type.inspect}" unless EVENT_TYPES.include?(type)
+
+            @id                 = SecureRandom.uuid
+            @type               = type
+            @magnitude          = magnitude.clamp(0.0, Float::INFINITY)
+            @epicenter_plate_id = epicenter_plate_id
+            @affected_plate_ids = Array(affected_plate_ids)
+            @parent_event_id    = parent_event_id
+            @timestamp          = Time.now.utc
+          end
+
+          def aftershock?
+            @type == :aftershock
+          end
+
+          def label
+            label_for(@magnitude)
+          end
+
+          def to_h
+            {
+              id:                 @id,
+              type:               @type,
+              magnitude:          @magnitude,
+              label:              label,
+              epicenter_plate_id: @epicenter_plate_id,
+              affected_plate_ids: @affected_plate_ids,
+              parent_event_id:    @parent_event_id,
+              timestamp:          @timestamp
+            }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/cognitive_tectonics/helpers/tectonic_engine.rb

@@ -0,0 +1,214 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module CognitiveTectonics
+      module Helpers
+        module TectonicBoundaries
+          private
+
+          def resolve_convergent(plate_a, plate_b)
+            combined = ((plate_a.mass + plate_b.mass) / 2.0).clamp(0.0, 1.0)
+            plate_a.mass = combined
+            plate_b.mass = combined
+            avg_drift = {
+              x: ((plate_a.drift_vector[:x] + plate_b.drift_vector[:x]) / 2.0).round(10),
+              y: ((plate_a.drift_vector[:y] + plate_b.drift_vector[:y]) / 2.0).round(10)
+            }
+            plate_a.drift_vector = avg_drift
+            plate_b.drift_vector = avg_drift
+            { success: true, boundary_type: :convergent, outcome: :merged, new_mass: combined }
+          end
+
+          def resolve_divergent(plate_a, plate_b)
+            split_mass = (plate_a.mass * 0.5).round(10)
+            plate_a.mass = split_mass
+            plate_b.mass = split_mass
+            plate_a.drift_vector = { x: -plate_a.drift_vector.fetch(:x, 0.0), y: plate_a.drift_vector.fetch(:y, 0.0) }
+            plate_b.drift_vector = { x: plate_b.drift_vector.fetch(:x, 0.0), y: -plate_b.drift_vector.fetch(:y, 0.0) }
+            { success: true, boundary_type: :divergent, outcome: :split, new_mass: split_mass }
+          end
+
+          def resolve_transform(plate_a, plate_b)
+            stress = (plate_a.mass * plate_b.mass * 0.5).round(10)
+            plate_a.accumulate_stress!(stress)
+            plate_b.accumulate_stress!(stress)
+            check_stress_quake(plate_a)
+            check_stress_quake(plate_b)
+            { success: true, boundary_type: :transform, outcome: :friction, stress_added: stress }
+          end
+
+          def check_stress_quake(plate)
+            return unless plate.stress_accumulation >= Constants::STRESS_QUAKE_TRIGGER
+
+            trigger_earthquake(plate_id: plate.id, magnitude: plate.stress_accumulation)
+          end
+
+          def nearby_plates(plate, exclude_id:)
+            @plates.values.select do |p|
+              p.active? && p.id != exclude_id && plate.distance_to(p) < 5.0
+            end
+          end
+
+          def record_seismic_event(event)
+            @seismic_history << event
+            @seismic_history.shift if @seismic_history.size > Constants::MAX_QUAKES
+          end
+
+          def update_active_faults(plate_a_id, plate_b_id, boundary_type)
+            existing = @active_faults.find { |f| fault_matches?(f, plate_a_id, plate_b_id) }
+            if existing
+              existing[:boundary_type] = boundary_type
+              existing[:last_activity] = Time.now.utc
+            else
+              @active_faults << { plate_a_id: plate_a_id, plate_b_id: plate_b_id,
+                                  boundary_type: boundary_type, last_activity: Time.now.utc }
+            end
+          end
+
+          def fault_matches?(fault, id_a, id_b)
+            (fault[:plate_a_id] == id_a && fault[:plate_b_id] == id_b) ||
+              (fault[:plate_a_id] == id_b && fault[:plate_b_id] == id_a)
+          end
+
+          def remove_faults_for(plate_id)
+            @active_faults.reject! { |f| f[:plate_a_id] == plate_id || f[:plate_b_id] == plate_id }
+          end
+
+          def avg_mass(plates)
+            return 0.0 if plates.empty?
+
+            (plates.sum(&:mass) / plates.size.to_f).round(10)
+          end
+
+          def recent_earthquakes(count)
+            @seismic_history.last(count).map(&:to_h)
+          end
+        end
+
+        class TectonicEngine
+          include Constants
+          include TectonicBoundaries
+
+          attr_reader :plates, :seismic_history, :active_faults
+
+          def initialize
+            @plates          = {}
+            @seismic_history = []
+            @active_faults   = []
+          end
+
+          def create_plate(domain:, content:, mass: 0.5, drift_vector: nil, position: nil, **)
+            raise ArgumentError, 'plate limit reached' if @plates.size >= Constants::MAX_PLATES
+
+            plate = BeliefPlate.new(domain: domain, content: content,
+                                    mass: mass, drift_vector: drift_vector, position: position)
+            @plates[plate.id] = plate
+            { success: true, plate_id: plate.id, plate: plate.to_h }
+          rescue ArgumentError => e
+            { success: false, error: e.message }
+          end
+
+          def drift_tick!(delta_t = 1.0, **)
+            moved = 0
+            @plates.each_value do |plate|
+              next unless plate.active?
+
+              plate.drift!(delta_t)
+              moved += 1
+            end
+            collisions = detect_collisions
+            { success: true, plates_moved: moved, collisions_detected: collisions.size, collisions: collisions }
+          end
+
+          def detect_collisions
+            active = @plates.values.select(&:active?)
+            pairs  = active.combination(2).select { |a, b| a.distance_to(b) < Constants::COLLISION_THRESHOLD }
+            pairs.map { |a, b| { plate_a_id: a.id, plate_b_id: b.id, distance: a.distance_to(b) } }
+          end
+
+          def resolve_collision(plate_a_id:, plate_b_id:, boundary_type:, **)
+            raise ArgumentError, "unknown boundary type: #{boundary_type}" unless Constants::BOUNDARY_TYPES.include?(boundary_type)
+
+            plate_a = @plates[plate_a_id]
+            plate_b = @plates[plate_b_id]
+            raise ArgumentError, "plate not found: #{plate_a_id}" unless plate_a
+            raise ArgumentError, "plate not found: #{plate_b_id}" unless plate_b
+
+            result = send(:"resolve_#{boundary_type}", plate_a, plate_b)
+            update_active_faults(plate_a_id, plate_b_id, boundary_type)
+            result
+          rescue ArgumentError => e
+            { success: false, error: e.message }
+          end
+
+          def subduct(weaker_plate_id:, stronger_plate_id:, **)
+            weaker   = @plates[weaker_plate_id]
+            stronger = @plates[stronger_plate_id]
+            raise ArgumentError, "plate not found: #{weaker_plate_id}"   unless weaker
+            raise ArgumentError, "plate not found: #{stronger_plate_id}" unless stronger
+
+            mass_absorbed = weaker.mass * 0.5
+            stronger.mass = (stronger.mass + mass_absorbed).clamp(0.0, 1.0)
+            weaker.subduct!
+            remove_faults_for(weaker_plate_id)
+            { success: true, subducted_plate_id: weaker_plate_id, mass_absorbed: mass_absorbed.round(10) }
+          rescue ArgumentError => e
+            { success: false, error: e.message }
+          end
+
+          def trigger_earthquake(plate_id:, magnitude:, **)
+            plate = @plates[plate_id]
+            raise ArgumentError, "plate not found: #{plate_id}" unless plate
+
+            nearby = nearby_plates(plate, exclude_id: plate_id)
+            event  = SeismicEvent.new(type: :earthquake, magnitude: magnitude,
+                                      epicenter_plate_id: plate_id, affected_plate_ids: nearby.map(&:id))
+            record_seismic_event(event)
+            plate.release_stress!
+            nearby.each { |p| p.accumulate_stress!(magnitude * 0.3) }
+            { success: true, event_id: event.id, event: event.to_h }
+          rescue ArgumentError => e
+            { success: false, error: e.message }
+          end
+
+          def aftershock_cascade(event_id:, **)
+            parent = @seismic_history.find { |e| e.id == event_id }
+            raise ArgumentError, "event not found: #{event_id}" unless parent
+
+            decayed_magnitude = (parent.magnitude * (1.0 - Constants::AFTERSHOCK_DECAY)).round(10)
+            return { success: true, aftershocks: [], reason: :magnitude_too_low } if decayed_magnitude < 0.1
+
+            aftershock = SeismicEvent.new(type: :aftershock, magnitude: decayed_magnitude,
+                                          epicenter_plate_id: parent.epicenter_plate_id,
+                                          affected_plate_ids: parent.affected_plate_ids,
+                                          parent_event_id: event_id)
+            record_seismic_event(aftershock)
+            { success: true, aftershocks: [aftershock.to_h] }
+          rescue ArgumentError => e
+            { success: false, error: e.message }
+          end
+
+          def all_plates
+            @plates.values.map(&:to_h)
+          end
+
+          def tectonic_report
+            active_plates, subducted_plates = @plates.values.partition(&:active?)
+            high_stress = active_plates.select { |p| p.stress_accumulation > 0.5 }
+            {
+              total_plates:      @plates.size,
+              active_plates:     active_plates.size,
+              subducted_plates:  subducted_plates.size,
+              high_stress_count: high_stress.size,
+              seismic_events:    @seismic_history.size,
+              active_faults:     @active_faults.size,
+              avg_mass:          avg_mass(active_plates),
+              recent_quakes:     recent_earthquakes(5)
+            }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/cognitive_tectonics/runners/cognitive_tectonics.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module CognitiveTectonics
+      module Runners
+        module CognitiveTectonics
+          extend self
+
+          include Legion::Extensions::Helpers::Lex if defined?(Legion::Extensions::Helpers::Lex)
+
+          def create_plate(domain: nil, content: nil, mass: 0.5, drift_vector: nil, position: nil, engine: nil, **)
+            raise ArgumentError, 'domain is required'  if domain.nil?
+            raise ArgumentError, 'content is required' if content.nil?
+
+            tectonic_engine(engine).create_plate(
+              domain:       domain,
+              content:      content,
+              mass:         mass,
+              drift_vector: drift_vector,
+              position:     position
+            )
+          rescue ArgumentError => e
+            { success: false, error: e.message }
+          end
+
+          def drift_tick(delta_t: 1.0, engine: nil, **)
+            tectonic_engine(engine).drift_tick!(delta_t)
+          rescue ArgumentError => e
+            { success: false, error: e.message }
+          end
+
+          def resolve_collision(plate_a_id: nil, plate_b_id: nil, boundary_type: :convergent, engine: nil, **)
+            raise ArgumentError, 'plate_a_id is required' if plate_a_id.nil?
+            raise ArgumentError, 'plate_b_id is required' if plate_b_id.nil?
+
+            tectonic_engine(engine).resolve_collision(
+              plate_a_id:    plate_a_id,
+              plate_b_id:    plate_b_id,
+              boundary_type: boundary_type
+            )
+          rescue ArgumentError => e
+            { success: false, error: e.message }
+          end
+
+          def trigger_earthquake(plate_id: nil, magnitude: 1.0, engine: nil, **)
+            raise ArgumentError, 'plate_id is required' if plate_id.nil?
+
+            tectonic_engine(engine).trigger_earthquake(plate_id: plate_id, magnitude: magnitude)
+          rescue ArgumentError => e
+            { success: false, error: e.message }
+          end
+
+          def tectonic_status(engine: nil, **)
+            eng    = tectonic_engine(engine)
+            report = eng.tectonic_report
+            { success: true }.merge(report)
+          rescue ArgumentError => e
+            { success: false, error: e.message }
+          end
+
+          private
+
+          def tectonic_engine(engine)
+            engine || @tectonic_engine ||= Helpers::TectonicEngine.new
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module CognitiveTectonics
+      VERSION = '0.1.0'
+    end
+  end
+end

data/lib/legion/extensions/cognitive_tectonics.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+
+require 'legion/extensions/cognitive_tectonics/version'
+require 'legion/extensions/cognitive_tectonics/helpers/constants'
+require 'legion/extensions/cognitive_tectonics/helpers/belief_plate'
+require 'legion/extensions/cognitive_tectonics/helpers/seismic_event'
+require 'legion/extensions/cognitive_tectonics/helpers/tectonic_engine'
+require 'legion/extensions/cognitive_tectonics/runners/cognitive_tectonics'
+require 'legion/extensions/cognitive_tectonics/client'
+
+module Legion
+  module Extensions
+    module CognitiveTectonics
+      extend Legion::Extensions::Core if Legion::Extensions.const_defined? :Core
+    end
+  end
+end

metadata

@@ -0,0 +1,79 @@
+--- !ruby/object:Gem::Specification
+name: lex-cognitive-tectonics
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Esity
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: legion-gaia
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Tectonic belief-plate model for LegionIO — conviction as mass, drift
+  vectors, convergent/divergent/transform boundaries, seismic belief shifts, and aftershock
+  cascades
+email:
+- matthewdiverson@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".github/workflows/ci.yml"
+- ".gitignore"
+- ".rspec"
+- ".rubocop.yml"
+- CLAUDE.md
+- Gemfile
+- README.md
+- lex-cognitive-tectonics.gemspec
+- lib/legion/extensions/cognitive_tectonics.rb
+- lib/legion/extensions/cognitive_tectonics/actors/drift_tick.rb
+- lib/legion/extensions/cognitive_tectonics/client.rb
+- lib/legion/extensions/cognitive_tectonics/helpers/belief_plate.rb
+- lib/legion/extensions/cognitive_tectonics/helpers/constants.rb
+- lib/legion/extensions/cognitive_tectonics/helpers/seismic_event.rb
+- lib/legion/extensions/cognitive_tectonics/helpers/tectonic_engine.rb
+- lib/legion/extensions/cognitive_tectonics/runners/cognitive_tectonics.rb
+- lib/legion/extensions/cognitive_tectonics/version.rb
+homepage: https://github.com/LegionIO/lex-cognitive-tectonics
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/LegionIO/lex-cognitive-tectonics
+  source_code_uri: https://github.com/LegionIO/lex-cognitive-tectonics
+  documentation_uri: https://github.com/LegionIO/lex-cognitive-tectonics
+  changelog_uri: https://github.com/LegionIO/lex-cognitive-tectonics
+  bug_tracker_uri: https://github.com/LegionIO/lex-cognitive-tectonics/issues
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.4'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.9
+specification_version: 4
+summary: LEX Cognitive Tectonics
+test_files: []