lex-cognitive-triage 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: bf115104e45fd4f342847472fb98867351280610072bb62c78b1ef4bb4e756bd
+  data.tar.gz: d474d79895e4100c895667618175e79c7a0588ed73b8b7ccbef3c6a331b26791
+SHA512:
+  metadata.gz: 487a5574ef1b037ae3c10aaf6e38430177033e7f4875d8ccc86a10784fefd245632ae206a6b0e0d01bc7509d6679a2414f2effee11f1b58d7b7ddbd23f86b5c8
+  data.tar.gz: dce224d41e81c12b73a93363c8ddc6a1e99aad237515ff2384fb639c30cb8eb3bd549101a1049fa2c4525dc35bd8de82c2ca9a83349cf918557488b92ea3a6e7

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,41 @@
+AllCops:
+  NewCops: enable
+  TargetRubyVersion: 3.4
+  SuggestExtensions: false
+
+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:
+  EnforcedHashRocketStyle: table
+  EnforcedColonStyle: table
+
+Metrics/BlockLength:
+  Exclude:
+    - 'spec/**/*'
+
+Style/FrozenStringLiteralComment:
+  Enabled: true
+
+Style/OneClassPerFile:
+  Exclude:
+    - 'spec/spec_helper.rb'

data/CLAUDE.md

@@ -0,0 +1,122 @@
+# lex-cognitive-triage
+
+**Level 3 Leaf Documentation**
+- **Parent**: `/Users/miverso2/rubymine/legion/extensions-agentic/CLAUDE.md`
+- **Gem**: `lex-cognitive-triage`
+- **Version**: 0.1.0
+- **Namespace**: `Legion::Extensions::CognitiveTriage`
+
+## Purpose
+
+Models cognitive demand management as a triage system. Demands are incoming cognitive tasks or stimuli with severity and urgency levels. A priority score is computed and demands are color-coded (red/orange/yellow/green/white). Adding demands drains cognitive capacity; completing or dropping them restores it. When capacity falls below the overload threshold, the system is flagged as overloaded.
+
+## Gem Info
+
+- **Gemspec**: `lex-cognitive-triage.gemspec`
+- **Require**: `lex-cognitive-triage`
+- **Ruby**: >= 3.4
+- **License**: MIT
+- **Homepage**: https://github.com/LegionIO/lex-cognitive-triage
+
+## File Structure
+
+```
+lib/legion/extensions/cognitive_triage/
+  version.rb
+  helpers/
+    constants.rb      # Severity/urgency levels and weights, triage/capacity/queue label tables
+    demand.rb         # Demand class — one cognitive demand with triage score and lifecycle
+    triage_engine.rb  # TriageEngine — demand registry with capacity management
+  runners/
+    cognitive_triage.rb  # Runner module — public API
+  client.rb
+```
+
+## Key Constants
+
+| Constant | Value | Meaning |
+|---|---|---|
+| `MAX_DEMANDS` | 500 | Hard cap; oldest completed (or lowest score) pruned |
+| `MAX_QUEUE_SIZE` | 100 | Reference for queue pressure calculation |
+| `CAPACITY_DEFAULT` | 1.0 | Starting cognitive capacity |
+| `CAPACITY_DRAIN` | 0.05 | Max capacity drain per demand add (multiplied by triage score) |
+| `CAPACITY_RESTORE` | 0.03 | Capacity restored per complete or drop |
+| `OVERLOAD_THRESHOLD` | 0.2 | Capacity <= this = overloaded |
+
+Triage score formula: `severity_weight * 0.6 + urgency_weight * 0.4`
+
+`SEVERITY_LEVELS`: `[:critical, :major, :moderate, :minor, :trivial]` with weights `[1.0, 0.8, 0.5, 0.3, 0.1]`
+
+`URGENCY_LEVELS`: `[:immediate, :urgent, :soon, :deferred, :indefinite]` with weights `[1.0, 0.8, 0.5, 0.3, 0.1]`
+
+Triage color labels: `0.8+` = `:red`, `0.6..0.8` = `:orange`, `0.4..0.6` = `:yellow`, `0.2..0.4` = `:green`, `<0.2` = `:white`
+
+Capacity labels: `0.8+` = `:fresh`, `0.6..0.8` = `:engaged`, `0.4..0.6` = `:strained`, `0.2..0.4` = `:depleted`, `<0.2` = `:overloaded`
+
+Queue labels (by `active / MAX_QUEUE_SIZE`): `0.8+` = `:overwhelmed`, `0.6..0.8` = `:heavy`, `0.4..0.6` = `:moderate`, `0.2..0.4` = `:light`, `<0.2` = `:empty`
+
+## Key Classes
+
+### `Helpers::Demand`
+
+One cognitive demand with a lifecycle.
+
+- `triage!` / `defer!` / `process!` / `complete!` / `drop!` — state transitions
+- `active?` — status in `[:pending, :triaged, :processing]`
+- `red?` — triage_score >= 0.8
+- `triage_label` — color label for triage score
+- `triage_score` — computed at init: `severity_weight * 0.6 + urgency_weight * 0.4`; immutable
+- Invalid severity/urgency silently defaults to `:moderate`/`:soon`
+
+### `Helpers::TriageEngine`
+
+Demand registry with capacity tracking.
+
+- `add_demand(description:, domain:, severity:, urgency:)` — prunes if at `MAX_DEMANDS`; drains capacity by `triage_score * CAPACITY_DRAIN`; auto-calls `triage!`
+- `process_demand(demand_id:)` — sets to `:processing`; fails if not active
+- `complete_demand(demand_id:)` — sets to `:completed`; restores `CAPACITY_RESTORE`
+- `defer_demand(demand_id:)` — sets to `:deferred`; restores `CAPACITY_RESTORE * 0.5`
+- `drop_demand(demand_id:)` — sets to `:dropped`; restores `CAPACITY_RESTORE`
+- `next_demand` — active demand with highest triage score
+- `red_demands` — all demands with score >= 0.8
+- `overloaded?` — capacity <= `OVERLOAD_THRESHOLD`
+- `queue_pressure` — `active_count / MAX_QUEUE_SIZE`
+- `triage_report` — full status hash
+- `prune_if_needed` (private) — removes oldest completed demand; if none, removes lowest-score demand
+
+## Runners
+
+Module: `Legion::Extensions::CognitiveTriage::Runners::CognitiveTriage`
+
+| Runner | Key Args | Returns |
+|---|---|---|
+| `add_demand` | `description:`, `domain:`, `severity:`, `urgency:` | `{ success:, demand:, capacity: }` |
+| `process_demand` | `demand_id:` | `{ success:, demand: }` or error |
+| `complete_demand` | `demand_id:` | `{ success:, demand:, capacity: }` or error |
+| `defer_demand` | `demand_id:` | `{ success:, demand:, capacity: }` or error |
+| `drop_demand` | `demand_id:` | `{ success:, demand:, capacity: }` or error |
+| `next_demand` | — | `{ success:, found:, demand: }` |
+| `active_demands` | — | `{ success:, demands:, count: }` |
+| `red_demands` | — | `{ success:, demands:, count: }` |
+| `demands_by_severity` | `severity:` | `{ success:, demands:, count: }` |
+| `demands_by_domain` | `domain:` | `{ success:, demands:, count: }` |
+| `capacity_status` | — | `{ success:, capacity:, capacity_label:, overloaded:, queue_pressure:, queue_label: }` |
+| `triage_report` | — | `{ success:, report: }` |
+
+All runners accept optional `engine:` keyword for test injection.
+
+## Integration Points
+
+- No actors defined; driven by external task events or `lex-tick` phases
+- `add_demand` is the entry point for all incoming cognitive demands
+- `next_demand` feeds into `lex-tick`'s `action_selection` phase — selects highest-priority demand
+- `overloaded?` can gate new commitments or trigger `lex-consent` escalation
+- All state is in-memory per `TriageEngine` instance
+
+## Development Notes
+
+- Capacity drain per demand is `triage_score * CAPACITY_DRAIN`, not a flat `CAPACITY_DRAIN` — critical/immediate demands drain 5x more than trivial/indefinite
+- `add_demand` automatically calls `triage!` after creation — demand moves from `:pending` to `:triaged` immediately
+- `prune_if_needed` prefers to evict completed demands; only evicts active if no completed exist
+- Demand IDs are UUID strings, not sequential symbols
+- `demands_by_severity` and `demands_by_domain` return ALL demands (including completed/dropped), not only active ones

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,74 @@
+# lex-cognitive-triage
+
+A LegionIO cognitive architecture extension that models cognitive demand management as a triage system. Incoming demands are scored by severity and urgency, color-coded by priority, and managed through a lifecycle as capacity allows.
+
+## What It Does
+
+Tracks **demands** — cognitive tasks or stimuli requiring attention. Each demand has:
+
+- A severity (`:critical`, `:major`, `:moderate`, `:minor`, `:trivial`)
+- An urgency (`:immediate`, `:urgent`, `:soon`, `:deferred`, `:indefinite`)
+- A triage score: `severity * 0.6 + urgency * 0.4`
+- A color label: `:red` (0.8+), `:orange`, `:yellow`, `:green`, `:white`
+
+Adding a demand drains cognitive capacity. Completing or dropping demands restores it. When capacity drops below 0.2, the system is overloaded.
+
+## Usage
+
+```ruby
+require 'lex-cognitive-triage'
+
+client = Legion::Extensions::CognitiveTriage::Client.new
+
+# Register an incoming demand
+result = client.add_demand(
+  description: 'Ethical conflict detected in action plan',
+  domain: :safety,
+  severity: :critical,
+  urgency: :immediate
+)
+# => { success: true, demand: { triage_score: 1.0, triage_label: :red, status: :triaged, ... }, capacity: 0.95 }
+
+demand_id = result[:demand][:id]
+
+# What should be worked on next?
+client.next_demand
+# => { success: true, found: true, demand: { triage_score: 1.0, triage_label: :red, ... } }
+
+# All red-priority demands
+client.red_demands
+# => { success: true, demands: [...], count: 1 }
+
+# Begin processing
+client.process_demand(demand_id: demand_id)
+# => { success: true, demand: { status: :processing, ... } }
+
+# Mark complete — restores capacity
+client.complete_demand(demand_id: demand_id)
+# => { success: true, demand: { status: :completed, ... }, capacity: 0.98 }
+
+# Defer a lower-priority demand
+d2 = client.add_demand(description: 'Schedule review', severity: :minor, urgency: :deferred)
+client.defer_demand(demand_id: d2[:demand][:id])
+# => { success: true, demand: { status: :deferred, ... }, capacity: 0.965 }
+
+# Check capacity state
+client.capacity_status
+# => { success: true, capacity: 0.965, capacity_label: :fresh, overloaded: false, queue_pressure: 0.0, queue_label: :empty }
+
+# Full report
+client.triage_report
+# => { success: true, report: { total_demands: 2, active_count: 0, red_count: 0, capacity: 0.965, overloaded: false, ... } }
+```
+
+## Development
+
+```bash
+bundle install
+bundle exec rspec
+bundle exec rubocop
+```
+
+## License
+
+MIT

data/lex-cognitive-triage.gemspec

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require_relative 'lib/legion/extensions/cognitive_triage/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'lex-cognitive-triage'
+  spec.version       = Legion::Extensions::CognitiveTriage::VERSION
+  spec.authors       = ['Esity']
+  spec.email         = ['matthewdiverson@gmail.com']
+
+  spec.summary       = 'Emergency cognitive prioritization for LegionIO'
+  spec.description   = 'Triage system for cognitive overload. Classifies incoming demands by severity ' \
+                       'and urgency, routes to appropriate processing queues, and manages cognitive ' \
+                       'capacity under pressure.'
+  spec.homepage      = 'https://github.com/LegionIO/lex-cognitive-triage'
+  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-triage'
+  spec.metadata['documentation_uri']     = 'https://github.com/LegionIO/lex-cognitive-triage/blob/master/README.md'
+  spec.metadata['changelog_uri']         = 'https://github.com/LegionIO/lex-cognitive-triage/blob/master/CHANGELOG.md'
+  spec.metadata['bug_tracker_uri']       = 'https://github.com/LegionIO/lex-cognitive-triage/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/cognitive_triage/client.rb

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

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

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module CognitiveTriage
+      module Helpers
+        module Constants
+          MAX_DEMANDS      = 500
+          MAX_QUEUE_SIZE   = 100
+          CAPACITY_DEFAULT = 1.0
+          CAPACITY_DRAIN   = 0.05
+          CAPACITY_RESTORE = 0.03
+          OVERLOAD_THRESHOLD = 0.2
+
+          SEVERITY_LEVELS = %i[critical major moderate minor trivial].freeze
+          URGENCY_LEVELS  = %i[immediate urgent soon deferred indefinite].freeze
+
+          SEVERITY_WEIGHTS = {
+            critical: 1.0,
+            major:    0.8,
+            moderate: 0.5,
+            minor:    0.3,
+            trivial:  0.1
+          }.freeze
+
+          URGENCY_WEIGHTS = {
+            immediate:  1.0,
+            urgent:     0.8,
+            soon:       0.5,
+            deferred:   0.3,
+            indefinite: 0.1
+          }.freeze
+
+          TRIAGE_LABELS = {
+            (0.8..)     => :red,
+            (0.6...0.8) => :orange,
+            (0.4...0.6) => :yellow,
+            (0.2...0.4) => :green,
+            (..0.2)     => :white
+          }.freeze
+
+          CAPACITY_LABELS = {
+            (0.8..)     => :fresh,
+            (0.6...0.8) => :engaged,
+            (0.4...0.6) => :strained,
+            (0.2...0.4) => :depleted,
+            (..0.2)     => :overloaded
+          }.freeze
+
+          QUEUE_LABELS = {
+            (0.8..)     => :overwhelmed,
+            (0.6...0.8) => :heavy,
+            (0.4...0.6) => :moderate,
+            (0.2...0.4) => :light,
+            (..0.2)     => :empty
+          }.freeze
+
+          def self.label_for(labels, value)
+            match = labels.find { |range, _| range.cover?(value) }
+            match&.last
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/cognitive_triage/helpers/demand.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+
+module Legion
+  module Extensions
+    module CognitiveTriage
+      module Helpers
+        class Demand
+          include Constants
+
+          attr_reader :id, :description, :domain, :severity, :urgency,
+                      :triage_score, :status, :created_at, :triaged_at
+
+          def initialize(description:, domain: :general, severity: :moderate, urgency: :soon)
+            @id           = SecureRandom.uuid
+            @description  = description
+            @domain       = domain.to_sym
+            @severity     = validate_level(severity, SEVERITY_LEVELS, :moderate)
+            @urgency      = validate_level(urgency, URGENCY_LEVELS, :soon)
+            @triage_score = compute_triage_score
+            @status       = :pending
+            @created_at   = Time.now.utc
+            @triaged_at   = nil
+          end
+
+          def triage!
+            @status = :triaged
+            @triaged_at = Time.now.utc
+            self
+          end
+
+          def defer!
+            @status = :deferred
+            self
+          end
+
+          def process!
+            @status = :processing
+            self
+          end
+
+          def complete!
+            @status = :completed
+            self
+          end
+
+          def drop!
+            @status = :dropped
+            self
+          end
+
+          def active?
+            %i[pending triaged processing].include?(@status)
+          end
+
+          def triage_label
+            Constants.label_for(TRIAGE_LABELS, @triage_score)
+          end
+
+          def red?
+            @triage_score >= 0.8
+          end
+
+          def to_h
+            {
+              id:           @id,
+              description:  @description,
+              domain:       @domain,
+              severity:     @severity,
+              urgency:      @urgency,
+              triage_score: @triage_score,
+              triage_label: triage_label,
+              status:       @status,
+              red:          red?,
+              created_at:   @created_at,
+              triaged_at:   @triaged_at
+            }
+          end
+
+          private
+
+          def validate_level(level, valid_levels, default)
+            sym = level.to_sym
+            valid_levels.include?(sym) ? sym : default
+          end
+
+          def compute_triage_score
+            sev = SEVERITY_WEIGHTS.fetch(@severity, 0.5)
+            urg = URGENCY_WEIGHTS.fetch(@urgency, 0.5)
+            ((sev * 0.6) + (urg * 0.4)).round(10)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/cognitive_triage/helpers/triage_engine.rb

@@ -0,0 +1,146 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module CognitiveTriage
+      module Helpers
+        class TriageEngine
+          include Constants
+
+          attr_reader :capacity
+
+          def initialize
+            @demands  = {}
+            @capacity = CAPACITY_DEFAULT
+          end
+
+          def add_demand(description:, domain: :general, severity: :moderate, urgency: :soon)
+            prune_if_needed
+            demand = Demand.new(
+              description: description, domain: domain, severity: severity, urgency: urgency
+            )
+            @demands[demand.id] = demand
+            drain_capacity!(demand.triage_score * CAPACITY_DRAIN)
+            demand.triage!
+            demand
+          end
+
+          def process_demand(demand_id:)
+            demand = @demands[demand_id]
+            return nil unless demand&.active?
+
+            demand.process!
+            demand
+          end
+
+          def complete_demand(demand_id:)
+            demand = @demands[demand_id]
+            return nil unless demand
+
+            demand.complete!
+            restore_capacity!(CAPACITY_RESTORE)
+            demand
+          end
+
+          def defer_demand(demand_id:)
+            demand = @demands[demand_id]
+            return nil unless demand&.active?
+
+            demand.defer!
+            restore_capacity!(CAPACITY_RESTORE * 0.5)
+            demand
+          end
+
+          def drop_demand(demand_id:)
+            demand = @demands[demand_id]
+            return nil unless demand&.active?
+
+            demand.drop!
+            restore_capacity!(CAPACITY_RESTORE)
+            demand
+          end
+
+          def next_demand
+            active_demands.max_by(&:triage_score)
+          end
+
+          def active_demands = @demands.values.select(&:active?)
+          def red_demands = @demands.values.select(&:red?)
+          def completed_demands = @demands.values.select { |d| d.status == :completed }
+          def dropped_demands = @demands.values.select { |d| d.status == :dropped }
+          def deferred_demands = @demands.values.select { |d| d.status == :deferred }
+
+          def demands_by_severity(severity:)
+            @demands.values.select { |d| d.severity == severity.to_sym }
+          end
+
+          def demands_by_domain(domain:)
+            @demands.values.select { |d| d.domain == domain.to_sym }
+          end
+
+          def overloaded?
+            @capacity <= OVERLOAD_THRESHOLD
+          end
+
+          def queue_pressure
+            return 0.0 if @demands.empty?
+
+            (active_demands.size.to_f / MAX_QUEUE_SIZE).clamp(0.0, 1.0).round(10)
+          end
+
+          def capacity_label = Constants.label_for(CAPACITY_LABELS, @capacity)
+          def queue_label = Constants.label_for(QUEUE_LABELS, queue_pressure)
+
+          def restore_capacity!(amount = CAPACITY_RESTORE)
+            @capacity = (@capacity + amount).clamp(0.0, 1.0).round(10)
+            self
+          end
+
+          def triage_report
+            {
+              total_demands:  @demands.size,
+              active_count:   active_demands.size,
+              red_count:      red_demands.size,
+              completed:      completed_demands.size,
+              dropped:        dropped_demands.size,
+              deferred:       deferred_demands.size,
+              capacity:       @capacity,
+              capacity_label: capacity_label,
+              overloaded:     overloaded?,
+              queue_pressure: queue_pressure,
+              queue_label:    queue_label,
+              next_demand:    next_demand&.to_h
+            }
+          end
+
+          def to_h
+            {
+              total_demands: @demands.size,
+              active:        active_demands.size,
+              capacity:      @capacity,
+              overloaded:    overloaded?
+            }
+          end
+
+          private
+
+          def drain_capacity!(amount)
+            @capacity = (@capacity - amount).clamp(0.0, 1.0).round(10)
+          end
+
+          def prune_if_needed
+            return if @demands.size < MAX_DEMANDS
+
+            oldest_completed = completed_demands.min_by(&:created_at)
+            if oldest_completed
+              @demands.delete(oldest_completed.id)
+            else
+              lowest = @demands.values.min_by(&:triage_score)
+              @demands.delete(lowest.id) if lowest
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module CognitiveTriage
+      module Runners
+        module CognitiveTriage
+          include Legion::Extensions::Helpers::Lex if defined?(Legion::Extensions::Helpers::Lex)
+
+          def add_demand(description:, domain: :general, severity: :moderate, urgency: :soon, engine: nil, **)
+            eng = engine || default_engine
+            demand = eng.add_demand(
+              description: description, domain: domain, severity: severity, urgency: urgency
+            )
+            { success: true, demand: demand.to_h, capacity: eng.capacity }
+          end
+
+          def process_demand(demand_id:, engine: nil, **)
+            eng = engine || default_engine
+            demand = eng.process_demand(demand_id: demand_id)
+            return { success: false, error: 'demand not found or not active' } unless demand
+
+            { success: true, demand: demand.to_h }
+          end
+
+          def complete_demand(demand_id:, engine: nil, **)
+            eng = engine || default_engine
+            demand = eng.complete_demand(demand_id: demand_id)
+            return { success: false, error: 'demand not found' } unless demand
+
+            { success: true, demand: demand.to_h, capacity: eng.capacity }
+          end
+
+          def defer_demand(demand_id:, engine: nil, **)
+            eng = engine || default_engine
+            demand = eng.defer_demand(demand_id: demand_id)
+            return { success: false, error: 'demand not found or not active' } unless demand
+
+            { success: true, demand: demand.to_h, capacity: eng.capacity }
+          end
+
+          def drop_demand(demand_id:, engine: nil, **)
+            eng = engine || default_engine
+            demand = eng.drop_demand(demand_id: demand_id)
+            return { success: false, error: 'demand not found or not active' } unless demand
+
+            { success: true, demand: demand.to_h, capacity: eng.capacity }
+          end
+
+          def next_demand(engine: nil, **)
+            eng = engine || default_engine
+            demand = eng.next_demand
+            return { success: true, found: false } unless demand
+
+            { success: true, found: true, demand: demand.to_h }
+          end
+
+          def active_demands(engine: nil, **)
+            eng = engine || default_engine
+            { success: true, demands: eng.active_demands.map(&:to_h), count: eng.active_demands.size }
+          end
+
+          def red_demands(engine: nil, **)
+            eng = engine || default_engine
+            { success: true, demands: eng.red_demands.map(&:to_h), count: eng.red_demands.size }
+          end
+
+          def demands_by_severity(severity:, engine: nil, **)
+            eng = engine || default_engine
+            demands = eng.demands_by_severity(severity: severity)
+            { success: true, demands: demands.map(&:to_h), count: demands.size }
+          end
+
+          def demands_by_domain(domain:, engine: nil, **)
+            eng = engine || default_engine
+            demands = eng.demands_by_domain(domain: domain)
+            { success: true, demands: demands.map(&:to_h), count: demands.size }
+          end
+
+          def capacity_status(engine: nil, **)
+            eng = engine || default_engine
+            {
+              success:        true,
+              capacity:       eng.capacity,
+              capacity_label: eng.capacity_label,
+              overloaded:     eng.overloaded?,
+              queue_pressure: eng.queue_pressure,
+              queue_label:    eng.queue_label
+            }
+          end
+
+          def triage_report(engine: nil, **)
+            eng = engine || default_engine
+            { success: true, report: eng.triage_report }
+          end
+
+          private
+
+          def default_engine
+            @default_engine ||= Helpers::TriageEngine.new
+          end
+        end
+      end
+    end
+  end
+end

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

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

data/lib/legion/extensions/cognitive_triage.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require_relative 'cognitive_triage/version'
+require_relative 'cognitive_triage/helpers/constants'
+require_relative 'cognitive_triage/helpers/demand'
+require_relative 'cognitive_triage/helpers/triage_engine'
+require_relative 'cognitive_triage/runners/cognitive_triage'
+require_relative 'cognitive_triage/client'
+
+module Legion
+  module Extensions
+    module CognitiveTriage
+    end
+  end
+end

metadata

@@ -0,0 +1,77 @@
+--- !ruby/object:Gem::Specification
+name: lex-cognitive-triage
+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: Triage system for cognitive overload. Classifies incoming demands by
+  severity and urgency, routes to appropriate processing queues, and manages cognitive
+  capacity under pressure.
+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-triage.gemspec
+- lib/legion/extensions/cognitive_triage.rb
+- lib/legion/extensions/cognitive_triage/client.rb
+- lib/legion/extensions/cognitive_triage/helpers/constants.rb
+- lib/legion/extensions/cognitive_triage/helpers/demand.rb
+- lib/legion/extensions/cognitive_triage/helpers/triage_engine.rb
+- lib/legion/extensions/cognitive_triage/runners/cognitive_triage.rb
+- lib/legion/extensions/cognitive_triage/version.rb
+homepage: https://github.com/LegionIO/lex-cognitive-triage
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/LegionIO/lex-cognitive-triage
+  source_code_uri: https://github.com/LegionIO/lex-cognitive-triage
+  documentation_uri: https://github.com/LegionIO/lex-cognitive-triage/blob/master/README.md
+  changelog_uri: https://github.com/LegionIO/lex-cognitive-triage/blob/master/CHANGELOG.md
+  bug_tracker_uri: https://github.com/LegionIO/lex-cognitive-triage/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: Emergency cognitive prioritization for LegionIO
+test_files: []