lex-attention-switching 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: ba17254c5d16fcc1f2d51382f1e19329a63a59aa3a0efe4ca92020399c92cce3
+  data.tar.gz: 754942a7882a83c4fdaf587ed0cb51e064976959df5bb5b7872c3a2d6a80e766
+SHA512:
+  metadata.gz: 8694f9c9d584430f5a067236d00ce44de7c68a03cac09ae213596bb4ee45a5cbfb3b0d2ed1629a4dcbed66c727bfcc69e279137e6594c7b8d63efecf7622b4a2
+  data.tar.gz: 95268bed20891af1165812d9c4a7fd09867c3071d4ed5beb3eb7f0961874dac587e7122b0f745741008a93a8b2aa6d10d3d6903467ac63c51c2bcccb35e19ae4

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,3 @@
+--require spec_helper
+--format documentation
+--color

data/.rubocop.yml

@@ -0,0 +1,37 @@
+AllCops:
+  NewCops: enable
+  TargetRubyVersion: 3.4
+
+Style/Documentation:
+  Enabled: false
+
+Naming/PredicateMethod:
+  Enabled: false
+
+Naming/PredicatePrefix:
+  Enabled: false
+
+Metrics/ClassLength:
+  Max: 150
+
+Metrics/MethodLength:
+  Max: 25
+
+Metrics/AbcSize:
+  Max: 25
+
+Metrics/ParameterLists:
+  Max: 8
+  MaxOptionalParameters: 8
+
+Layout/HashAlignment:
+  EnforcedColonStyle: table
+  EnforcedHashRocketStyle: table
+
+Metrics/BlockLength:
+  Exclude:
+    - 'spec/**/*'
+
+Style/OneClassPerFile:
+  Exclude:
+    - 'spec/spec_helper.rb'

data/CLAUDE.md

@@ -0,0 +1,94 @@
+# lex-attention-switching
+
+**Level 3 Documentation**
+- **Parent**: `/Users/miverso2/rubymine/legion/extensions-agentic/CLAUDE.md`
+- **Grandparent**: `/Users/miverso2/rubymine/legion/CLAUDE.md`
+
+## Purpose
+
+Models the cognitive cost of switching between tasks including residual activation, warmup time, context restoration, and practice effects. Based on task-switching research showing that switching tasks incurs a real performance cost — residual activation from the previous task persists and interferes with the new one.
+
+## Gem Info
+
+- **Gem name**: `lex-attention-switching`
+- **Version**: `0.1.0`
+- **Module**: `Legion::Extensions::AttentionSwitching`
+- **Ruby**: `>= 3.4`
+- **License**: MIT
+
+## File Structure
+
+```
+lib/legion/extensions/attention_switching/
+  attention_switching.rb          # Main extension module
+  version.rb                      # VERSION = '0.1.0'
+  client.rb                       # Client wrapper
+  helpers/
+    constants.rb                  # Switch costs, residual decay, warmup rate, task types, labels
+    task_set.rb                   # TaskSet value object (readiness, residual, practice count)
+    switch_event.rb               # SwitchEvent value object
+    switching_engine.rb           # SwitchingEngine — manages tasks, switch history, cost modeling
+  runners/
+    attention_switching.rb        # Runner module with 10 public methods
+spec/
+  (spec files)
+```
+
+## Key Constants
+
+```ruby
+MAX_TASK_SETS        = 100
+MAX_SWITCH_EVENTS    = 500
+DEFAULT_SWITCH_COST  = 0.3
+RESIDUAL_DECAY_RATE  = 0.1     # residual activation decays per tick
+WARMUP_RATE          = 0.15    # readiness increases per warmup call
+CONTEXT_RESTORATION_COST = 0.2  # penalty when returning to a previous task
+PRACTICE_REDUCTION   = 0.01    # switch cost reduces with practice
+HIGH_COST_THRESHOLD  = 0.6
+LOW_COST_THRESHOLD   = 0.2
+READY_THRESHOLD      = 0.8
+TASK_SET_TYPES = %i[analytical creative social procedural perceptual linguistic spatial emotional]
+COST_LABELS    = { (0.8..) => :prohibitive, ... (..0.2) => :negligible }
+READINESS_LABELS = { (0.8..) => :fully_ready, ... (..0.2) => :unprepared }
+RESIDUAL_LABELS  = { (0.8..) => :overwhelming, ... (..0.2) => :negligible }
+```
+
+## Runners
+
+### `Runners::AttentionSwitching`
+
+Methods accept optional `engine:` parameter (defaults to `@default_engine`), allowing test injection.
+
+- `register_task(name:, task_type: :analytical, complexity: 0.5, engine: nil)` — register a task set with type and complexity
+- `switch_to(task_id:, engine: nil)` — switch to a task; computes switch cost including residual and context restoration; records SwitchEvent
+- `warmup(engine: nil)` — warm up the active task (increases readiness)
+- `decay_residuals(engine: nil)` — decay residual activation for all tasks with residual
+- `active_task(engine: nil)` — returns the currently active task
+- `residual_tasks(engine: nil)` — tasks with non-negligible residual activation
+- `recent_switches(limit: 10, engine: nil)` — recent switch events
+- `average_switch_cost(engine: nil)` — average cost across all recorded switches
+- `switch_cost_between(from_id:, to_id:, engine: nil)` — historical average cost for a specific pair
+- `switching_report(engine: nil)` — comprehensive report
+- `status(engine: nil)` — full state hash
+
+## Helpers
+
+### `Helpers::SwitchingEngine`
+Core engine. `switch_to` computes cost as: `base_cost - (practice_count * PRACTICE_REDUCTION) + context_restoration_penalty`. Records SwitchEvent. Sets residual on the departed task. `decay_all_residuals!` reduces all tasks' residual by `RESIDUAL_DECAY_RATE`.
+
+### `Helpers::TaskSet`
+Value object: name, task_type, complexity, readiness (0–1), residual_activation (0–1), practice_count, is_active.
+
+### `Helpers::SwitchEvent`
+Value object: from_task, to_task, cost, timestamp.
+
+## Integration Points
+
+No actor defined — callers must invoke `decay_residuals` periodically. Integrates with lex-tick mode switching: when lex-cortex changes cognitive modes (dormant → full_active), the switching cost models how long it takes to reach full cognitive readiness. `warmup` models the ramp-up time for new task contexts. `switch_cost_between` informs scheduling decisions about task sequencing.
+
+## Development Notes
+
+- `engine:` parameter pattern allows passing a test double without monkey-patching
+- Context restoration cost applies when switching to a task previously active in the same session (residual > 0)
+- Practice reduces cost over repeated switches between the same pair — models procedural learning
+- `RESIDUAL_DECAY_RATE = 0.1` means full decay requires ~10 calls to `decay_residuals`

data/Gemfile

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

data/README.md

@@ -0,0 +1,58 @@
+# lex-attention-switching
+
+Attention task-switching cost modeling for LegionIO — residual activation, warmup time, context restoration, and practice effects.
+
+## What It Does
+
+Models the real cognitive cost of switching between tasks. When an agent switches from one task type to another, residual activation from the previous task persists and interferes with the new one. Readiness for the new task must build up through warmup. Repeated switching between the same pair reduces the cost through practice. Returning to a previously active task incurs an additional context restoration cost.
+
+## Core Concept: Switch Cost
+
+```ruby
+switch_cost = base_cost - (practice_count * 0.01) + context_restoration_if_returning
+# e.g., first switch: 0.30, tenth switch between same pair: 0.20
+```
+
+## Usage
+
+```ruby
+client = Legion::Extensions::AttentionSwitching::Client.new
+
+# Register task types
+analytical = client.register_task(name: :code_review, task_type: :analytical, complexity: 0.7)
+social     = client.register_task(name: :team_meeting, task_type: :social, complexity: 0.4)
+
+# Switch tasks
+result = client.switch_to(task_id: social[:task][:id])
+# => { cost: 0.3, cost_label: :moderate, residual: 0.3, readiness: 0.1 }
+
+# Warm up for the new task
+client.warmup
+client.warmup  # readiness increases
+
+# Check for lingering residual from the previous task
+client.residual_tasks
+# => { tasks: [{ name: :code_review, residual_activation: 0.2 }] }
+
+# Decay residuals between ticks
+client.decay_residuals
+
+# Historical cost between specific tasks
+client.switch_cost_between(from_id: analytical[:task][:id], to_id: social[:task][:id])
+```
+
+## Integration
+
+Wire into lex-tick mode transitions to model cognitive warmup time when switching between dormant and full_active modes. Use `average_switch_cost` to inform task scheduling: avoid frequent task-type switches when processing budget is limited.
+
+## Development
+
+```bash
+bundle install
+bundle exec rspec
+bundle exec rubocop
+```
+
+## License
+
+MIT

data/lex-attention-switching.gemspec

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require_relative 'lib/legion/extensions/attention_switching/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'lex-attention-switching'
+  spec.version       = Legion::Extensions::AttentionSwitching::VERSION
+  spec.authors       = ['Esity']
+  spec.email         = ['matthewdiverson@gmail.com']
+
+  spec.summary       = 'Attention task-switching cost modeling for LegionIO'
+  spec.description   = 'Models the cognitive cost of switching between tasks including residual activation, ' \
+                       'warmup time, context restoration, and practice effects.'
+  spec.homepage      = 'https://github.com/LegionIO/lex-attention-switching'
+  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-attention-switching'
+  spec.metadata['documentation_uri'] = 'https://github.com/LegionIO/lex-attention-switching/blob/master/README.md'
+  spec.metadata['changelog_uri']     = 'https://github.com/LegionIO/lex-attention-switching/blob/master/CHANGELOG.md'
+  spec.metadata['bug_tracker_uri']   = 'https://github.com/LegionIO/lex-attention-switching/issues'
+  spec.metadata['rubygems_mfa_required'] = 'true'
+
+  spec.files = Dir.chdir(__dir__) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{\A(?:test|spec|features)/}) }
+  end
+  spec.require_paths = ['lib']
+  spec.add_development_dependency 'legion-gaia'
+end

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

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module AttentionSwitching
+      class Client
+        include Runners::AttentionSwitching
+
+        def initialize(engine: nil)
+          @default_engine = engine || Helpers::SwitchingEngine.new
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module AttentionSwitching
+      module Helpers
+        module Constants
+          # Limits
+          MAX_TASK_SETS = 100
+          MAX_SWITCH_EVENTS = 500
+
+          # Switch dynamics
+          DEFAULT_SWITCH_COST = 0.3
+          RESIDUAL_DECAY_RATE = 0.1
+          WARMUP_RATE = 0.15
+          CONTEXT_RESTORATION_COST = 0.2
+          PRACTICE_REDUCTION = 0.01
+
+          # Thresholds
+          HIGH_COST_THRESHOLD = 0.6
+          LOW_COST_THRESHOLD = 0.2
+          READY_THRESHOLD = 0.8
+
+          # Task set types
+          TASK_SET_TYPES = %i[
+            analytical creative social procedural
+            perceptual linguistic spatial emotional
+          ].freeze
+
+          # Switch cost labels
+          COST_LABELS = {
+            (0.8..)     => :prohibitive,
+            (0.6...0.8) => :high,
+            (0.4...0.6) => :moderate,
+            (0.2...0.4) => :low,
+            (..0.2)     => :negligible
+          }.freeze
+
+          # Readiness labels
+          READINESS_LABELS = {
+            (0.8..)     => :fully_ready,
+            (0.6...0.8) => :mostly_ready,
+            (0.4...0.6) => :warming_up,
+            (0.2...0.4) => :loading,
+            (..0.2)     => :unprepared
+          }.freeze
+
+          # Residual activation labels
+          RESIDUAL_LABELS = {
+            (0.8..)     => :overwhelming,
+            (0.6...0.8) => :strong,
+            (0.4...0.6) => :moderate,
+            (0.2...0.4) => :fading,
+            (..0.2)     => :negligible
+          }.freeze
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/attention_switching/helpers/switch_event.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+
+module Legion
+  module Extensions
+    module AttentionSwitching
+      module Helpers
+        class SwitchEvent
+          include Constants
+
+          attr_reader :id, :from_task_id, :to_task_id, :switch_cost,
+                      :residual_interference, :warmup_needed, :created_at
+
+          def initialize(from_task_id:, to_task_id:, switch_cost:, residual_interference:, warmup_needed:)
+            @id                    = SecureRandom.uuid
+            @from_task_id          = from_task_id
+            @to_task_id            = to_task_id
+            @switch_cost           = switch_cost.to_f.clamp(0.0, 1.0).round(10)
+            @residual_interference = residual_interference.to_f.clamp(0.0, 1.0).round(10)
+            @warmup_needed         = warmup_needed.to_f.clamp(0.0, 1.0).round(10)
+            @created_at            = Time.now.utc
+          end
+
+          def costly?
+            @switch_cost >= HIGH_COST_THRESHOLD
+          end
+
+          def cheap?
+            @switch_cost <= LOW_COST_THRESHOLD
+          end
+
+          def cost_label
+            match = COST_LABELS.find { |range, _| range.cover?(@switch_cost) }
+            match ? match.last : :negligible
+          end
+
+          def to_h
+            {
+              id:                    @id,
+              from_task_id:          @from_task_id,
+              to_task_id:            @to_task_id,
+              switch_cost:           @switch_cost,
+              cost_label:            cost_label,
+              costly:                costly?,
+              cheap:                 cheap?,
+              residual_interference: @residual_interference,
+              warmup_needed:         @warmup_needed,
+              created_at:            @created_at
+            }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/attention_switching/helpers/switching_engine.rb

@@ -0,0 +1,168 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module AttentionSwitching
+      module Helpers
+        class SwitchingEngine
+          include Constants
+
+          def initialize
+            @task_sets      = {}
+            @switch_events  = []
+            @active_task_id = nil
+          end
+
+          def register_task(name:, task_type: :analytical, complexity: 0.5)
+            prune_tasks_if_needed
+            task = TaskSet.new(name: name, task_type: task_type, complexity: complexity)
+            @task_sets[task.id] = task
+            task
+          end
+
+          def activate_task(task_id:)
+            task = @task_sets[task_id]
+            return nil unless task
+
+            task.activate!
+            @active_task_id = task_id
+            task
+          end
+
+          def switch_to(task_id:)
+            target = @task_sets[task_id]
+            return nil unless target
+
+            current = @task_sets[@active_task_id]
+            event = if current && @active_task_id != task_id
+                      perform_switch(current, target)
+                    else
+                      activate_task(task_id: task_id)
+                      nil
+                    end
+
+            @active_task_id = task_id
+            { task: target.to_h, switch_event: event&.to_h }
+          end
+
+          def warmup_active
+            task = @task_sets[@active_task_id]
+            return nil unless task
+
+            task.warmup!
+          end
+
+          def decay_all_residuals!
+            @task_sets.each_value(&:decay_residual!)
+            { tasks_decayed: @task_sets.size }
+          end
+
+          def active_task
+            @task_sets[@active_task_id]
+          end
+
+          def tasks_with_residual
+            @task_sets.values.select(&:has_residual?)
+          end
+
+          def recent_switches(limit: 10)
+            @switch_events.last(limit)
+          end
+
+          def average_switch_cost
+            return DEFAULT_SWITCH_COST if @switch_events.empty?
+
+            costs = @switch_events.map(&:switch_cost)
+            (costs.sum / costs.size).round(10)
+          end
+
+          def costly_switches
+            @switch_events.select(&:costly?)
+          end
+
+          def cheap_switches
+            @switch_events.select(&:cheap?)
+          end
+
+          def switch_cost_between(from_id:, to_id:)
+            relevant = @switch_events.select { |e| e.from_task_id == from_id && e.to_task_id == to_id }
+            return nil if relevant.empty?
+
+            costs = relevant.map(&:switch_cost)
+            (costs.sum / costs.size).round(10)
+          end
+
+          def most_costly_pair
+            return nil if @switch_events.empty?
+
+            @switch_events.max_by(&:switch_cost)
+          end
+
+          def switching_report
+            {
+              total_tasks:         @task_sets.size,
+              total_switches:      @switch_events.size,
+              active_task:         active_task&.to_h,
+              average_switch_cost: average_switch_cost,
+              costly_count:        costly_switches.size,
+              cheap_count:         cheap_switches.size,
+              residual_count:      tasks_with_residual.size,
+              recent_switches:     recent_switches(limit: 5).map(&:to_h)
+            }
+          end
+
+          def to_h
+            {
+              total_tasks:         @task_sets.size,
+              total_switches:      @switch_events.size,
+              active_task_id:      @active_task_id,
+              average_switch_cost: average_switch_cost,
+              residual_count:      tasks_with_residual.size
+            }
+          end
+
+          private
+
+          def perform_switch(current, target)
+            current.deactivate!
+            cost = compute_switch_cost(current, target)
+            warmup = ((1.0 - target.readiness) * target.complexity).round(10)
+            target.activate!
+
+            event = SwitchEvent.new(
+              from_task_id:          current.id,
+              to_task_id:            target.id,
+              switch_cost:           cost,
+              residual_interference: current.residual_activation,
+              warmup_needed:         warmup
+            )
+            prune_events_if_needed
+            @switch_events << event
+            event
+          end
+
+          def compute_switch_cost(current, target)
+            type_cost = current.task_type == target.task_type ? 0.0 : 0.15
+            complexity_cost = ((current.complexity - target.complexity).abs * 0.3).round(10)
+            context_cost = CONTEXT_RESTORATION_COST * target.complexity
+            practice_bonus = [target.activation_count * PRACTICE_REDUCTION, 0.2].min
+
+            (DEFAULT_SWITCH_COST + type_cost + complexity_cost +
+             (current.residual_activation * 0.2) + context_cost - practice_bonus).clamp(0.0, 1.0).round(10)
+          end
+
+          def prune_tasks_if_needed
+            return if @task_sets.size < MAX_TASK_SETS
+
+            least_used = @task_sets.values.min_by(&:activation_count)
+            @task_sets.delete(least_used.id) if least_used
+          end
+
+          def prune_events_if_needed
+            @switch_events.shift while @switch_events.size >= MAX_SWITCH_EVENTS
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/attention_switching/helpers/task_set.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+
+module Legion
+  module Extensions
+    module AttentionSwitching
+      module Helpers
+        class TaskSet
+          include Constants
+
+          attr_reader :id, :name, :task_type, :complexity, :readiness,
+                      :residual_activation, :activation_count, :created_at
+
+          def initialize(name:, task_type: :analytical, complexity: 0.5)
+            @id                  = SecureRandom.uuid
+            @name                = name.to_s
+            @task_type           = task_type.to_sym
+            @complexity          = complexity.to_f.clamp(0.0, 1.0).round(10)
+            @readiness           = 0.0
+            @residual_activation = 0.0
+            @activation_count    = 0
+            @created_at          = Time.now.utc
+          end
+
+          def activate!
+            @readiness = 1.0
+            @residual_activation = 0.0
+            @activation_count += 1
+            self
+          end
+
+          def deactivate!
+            @residual_activation = @readiness
+            @readiness = 0.0
+            self
+          end
+
+          def warmup!(amount: WARMUP_RATE)
+            @readiness = (@readiness + amount).clamp(0.0, 1.0).round(10)
+            self
+          end
+
+          def decay_residual!
+            @residual_activation = (@residual_activation - RESIDUAL_DECAY_RATE).clamp(0.0, 1.0).round(10)
+            self
+          end
+
+          def ready?
+            @readiness >= READY_THRESHOLD
+          end
+
+          def has_residual?
+            @residual_activation > 0.1
+          end
+
+          def readiness_label
+            match = READINESS_LABELS.find { |range, _| range.cover?(@readiness) }
+            match ? match.last : :unprepared
+          end
+
+          def residual_label
+            match = RESIDUAL_LABELS.find { |range, _| range.cover?(@residual_activation) }
+            match ? match.last : :negligible
+          end
+
+          def to_h
+            {
+              id:                  @id,
+              name:                @name,
+              task_type:           @task_type,
+              complexity:          @complexity,
+              readiness:           @readiness,
+              readiness_label:     readiness_label,
+              residual_activation: @residual_activation,
+              residual_label:      residual_label,
+              ready:               ready?,
+              has_residual:        has_residual?,
+              activation_count:    @activation_count,
+              created_at:          @created_at
+            }
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module AttentionSwitching
+      module Runners
+        module AttentionSwitching
+          include Legion::Extensions::Helpers::Lex if defined?(Legion::Extensions::Helpers::Lex)
+
+          def register_task(name:, task_type: :analytical, complexity: 0.5, engine: nil, **)
+            eng = engine || default_engine
+            task = eng.register_task(name: name, task_type: task_type, complexity: complexity)
+            { success: true, task: task.to_h }
+          end
+
+          def switch_to(task_id:, engine: nil, **)
+            eng = engine || default_engine
+            result = eng.switch_to(task_id: task_id)
+            return { success: false, error: 'task not found' } unless result
+
+            { success: true, **result }
+          end
+
+          def warmup(engine: nil, **)
+            eng = engine || default_engine
+            task = eng.warmup_active
+            return { success: false, error: 'no active task' } unless task
+
+            { success: true, task: task.to_h }
+          end
+
+          def decay_residuals(engine: nil, **)
+            eng = engine || default_engine
+            result = eng.decay_all_residuals!
+            { success: true, **result }
+          end
+
+          def active_task(engine: nil, **)
+            eng = engine || default_engine
+            task = eng.active_task
+            return { success: false, error: 'no active task' } unless task
+
+            { success: true, task: task.to_h }
+          end
+
+          def residual_tasks(engine: nil, **)
+            eng = engine || default_engine
+            { success: true, tasks: eng.tasks_with_residual.map(&:to_h) }
+          end
+
+          def recent_switches(limit: 10, engine: nil, **)
+            eng = engine || default_engine
+            { success: true, switches: eng.recent_switches(limit: limit).map(&:to_h) }
+          end
+
+          def average_switch_cost(engine: nil, **)
+            eng = engine || default_engine
+            { success: true, average_cost: eng.average_switch_cost }
+          end
+
+          def switch_cost_between(from_id:, to_id:, engine: nil, **)
+            eng = engine || default_engine
+            cost = eng.switch_cost_between(from_id: from_id, to_id: to_id)
+            return { success: false, error: 'no switches found for this pair' } unless cost
+
+            { success: true, cost: cost }
+          end
+
+          def switching_report(engine: nil, **)
+            eng = engine || default_engine
+            { success: true, report: eng.switching_report }
+          end
+
+          def status(engine: nil, **)
+            eng = engine || default_engine
+            { success: true, **eng.to_h }
+          end
+
+          private
+
+          def default_engine
+            @default_engine ||= Helpers::SwitchingEngine.new
+          end
+        end
+      end
+    end
+  end
+end

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

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

data/lib/legion/extensions/attention_switching.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require_relative 'attention_switching/version'
+require_relative 'attention_switching/helpers/constants'
+require_relative 'attention_switching/helpers/task_set'
+require_relative 'attention_switching/helpers/switch_event'
+require_relative 'attention_switching/helpers/switching_engine'
+require_relative 'attention_switching/runners/attention_switching'
+require_relative 'attention_switching/client'
+
+module Legion
+  module Extensions
+    module AttentionSwitching
+      extend Legion::Extensions::Core if defined?(Legion::Extensions::Core)
+    end
+  end
+end

metadata

@@ -0,0 +1,77 @@
+--- !ruby/object:Gem::Specification
+name: lex-attention-switching
+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: Models the cognitive cost of switching between tasks including residual
+  activation, warmup time, context restoration, and practice effects.
+email:
+- matthewdiverson@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".github/workflows/ci.yml"
+- ".gitignore"
+- ".rspec"
+- ".rubocop.yml"
+- CLAUDE.md
+- Gemfile
+- README.md
+- lex-attention-switching.gemspec
+- lib/legion/extensions/attention_switching.rb
+- lib/legion/extensions/attention_switching/client.rb
+- lib/legion/extensions/attention_switching/helpers/constants.rb
+- lib/legion/extensions/attention_switching/helpers/switch_event.rb
+- lib/legion/extensions/attention_switching/helpers/switching_engine.rb
+- lib/legion/extensions/attention_switching/helpers/task_set.rb
+- lib/legion/extensions/attention_switching/runners/attention_switching.rb
+- lib/legion/extensions/attention_switching/version.rb
+homepage: https://github.com/LegionIO/lex-attention-switching
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/LegionIO/lex-attention-switching
+  source_code_uri: https://github.com/LegionIO/lex-attention-switching
+  documentation_uri: https://github.com/LegionIO/lex-attention-switching/blob/master/README.md
+  changelog_uri: https://github.com/LegionIO/lex-attention-switching/blob/master/CHANGELOG.md
+  bug_tracker_uri: https://github.com/LegionIO/lex-attention-switching/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: Attention task-switching cost modeling for LegionIO
+test_files: []