lex-cognitive-genesis 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 51c3c248b9445d32001938679a1f261a013b248e3cfc00d6622a695ac78911ed
+  data.tar.gz: 8a2d4dd89cbf10fdd33cc35c61df22e384f1c5de3fd96c1c754bab5c42b098df
+SHA512:
+  metadata.gz: bc41eb3e37f5d57373c4c4e3369033d22b1daaa95de9e3f324db16eefbe94b2e590c3d1161470ba4cbecc92703f25216f2b4f6d3d731de1ef2fa111d88b2ef6f
+  data.tar.gz: b1aa1db38cc13a7d2373b7b0144fc6bd834de39217a4acbbe6b35bad135f4b1cd203588a859649b547fb05df625ad94ff5ad74516dd5a7fabe1a9c654b7eeb31

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
+.rspec_status
+Gemfile.lock

data/.rspec

@@ -0,0 +1,3 @@
+--require spec_helper
+--color
+--format documentation

data/.rubocop.yml

@@ -0,0 +1,68 @@
+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: 200
+
+Metrics/ModuleLength:
+  Max: 200
+
+Metrics/BlockLength:
+  Max: 40
+  Exclude:
+    - 'spec/**/*'
+
+Metrics/AbcSize:
+  Max: 30
+
+Metrics/CyclomaticComplexity:
+  Max: 15
+
+Metrics/PerceivedComplexity:
+  Max: 17
+
+Metrics/ParameterLists:
+  Max: 8
+  MaxOptionalParameters: 8
+
+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
+
+Naming/MethodParameterName:
+  Exclude:
+    - 'spec/**/*'

data/CLAUDE.md

@@ -0,0 +1,129 @@
+# lex-cognitive-genesis
+
+**Level 3 Leaf Documentation**
+- **Parent**: `/Users/miverso2/rubymine/legion/extensions-agentic/CLAUDE.md`
+- **Gem**: `lex-cognitive-genesis`
+
+## Purpose
+
+Models the emergence of new cognitive concepts from seeds. Seeds are planted with a germination potential; once potential exceeds the germination threshold they can be germinated. Germinated seeds become concepts only when they meet three simultaneous criteria: viability (fitness >= VIABILITY_THRESHOLD), novelty (novelty >= NOVELTY_THRESHOLD), and readiness (maturity stage). Concepts can be nurtured to increase fitness, pruned if stale, cross-pollinated to produce hybrid seeds, or adopted from external sources. Tracks genesis rate and novelty landscape across domains.
+
+## Gem Info
+
+| Field | Value |
+|---|---|
+| Gem name | `lex-cognitive-genesis` |
+| Version | `0.1.0` |
+| Namespace | `Legion::Extensions::CognitiveGenesis` |
+| Ruby | `>= 3.4` |
+| License | MIT |
+| GitHub | https://github.com/LegionIO/lex-cognitive-genesis |
+
+## File Structure
+
+```
+lib/legion/extensions/cognitive_genesis/
+  cognitive_genesis.rb              # Top-level require
+  version.rb                        # VERSION = '0.1.0'
+  client.rb                         # Client class
+  helpers/
+    constants.rb                    # Concept types, domains, stages, thresholds, 6 label hashes
+    seed.rb                         # Seed value object
+    concept.rb                      # Concept value object
+    genesis_engine.rb               # Engine: seeds, concepts, germination, fitness, novelty
+  runners/
+    genesis.rb                      # Runner module
+```
+
+## Key Constants
+
+| Constant | Value | Meaning |
+|---|---|---|
+| `CONCEPT_TYPES` | array | `[:idea, :theory, :hypothesis, :belief, :intention, :memory, :insight, :fantasy, :archetype, :symbol]` |
+| `SOURCE_DOMAINS` | array | `[:experience, :observation, :inference, :intuition, :analogy, :synthesis, :dream, :external]` |
+| `MATURITY_STAGES` | array | `[:nascent, :developing, :mature, :crystallized, :transcendent]` |
+| `SEED_DOMAINS` | array | Various cognitive domains |
+| `GERMINATION_THRESHOLD` | 0.7 | Minimum potential to attempt germination |
+| `NOVELTY_THRESHOLD` | 0.5 | Minimum novelty for concept birth |
+| `VIABILITY_THRESHOLD` | 0.4 | Minimum fitness for concept birth |
+| `GENESIS_RATE_WINDOW` | last N | Rolling window for genesis rate calculation |
+
+Label hashes: `MATURITY_LABELS`, `FITNESS_LABELS`, `NOVELTY_LABELS`, `POTENTIAL_LABELS`, `GENESIS_LABELS`, `ADOPTION_LABELS`.
+
+## Helpers
+
+### `Seed`
+
+Pre-concept cognitive material awaiting germination.
+
+- `initialize(domain:, source:, content:, potential: 0.5, seed_id: nil)`
+- `potential`, `germinated?`, `germinate!` — marks as germinated
+- `boost!(amount)` — increases potential, capped at 1.0
+- `to_h`
+
+### `Concept`
+
+A birthed cognitive entity with fitness, novelty, and maturity tracking.
+
+- `initialize(concept_type:, domain:, content:, fitness: 0.5, novelty: 0.5, seed_id: nil, concept_id: nil)`
+- `nurture!(amount)` — increases fitness
+- `viable?` — fitness >= `VIABILITY_THRESHOLD`
+- `novel?` — novelty >= `NOVELTY_THRESHOLD`
+- `maturity_label`, `fitness_label`, `novelty_label`
+- `to_h`
+
+### `GenesisEngine`
+
+- `plant(domain:, source:, content:, potential: 0.5)` — creates Seed; returns `{ planted:, seed_id:, seed: }`
+- `germinate(seed_id:)` — requires potential >= GERMINATION_THRESHOLD; returns Concept candidate or `{ germinated: false, reason: }`
+- `birth(seed_id:)` — requires viable + novel + ready (germinated); stores in concept map; returns `{ born:, concept_id:, concept: }` or rejection
+- `nurture(concept_id:, amount: 0.1)` — increases concept fitness
+- `prune(seed_id:)` — removes seed from store
+- `cross_pollinate(seed_a_id:, seed_b_id:)` — creates new seed combining domains and averaging potential
+- `adopt_concept(concept_type:, domain:, content:, fitness: 0.5, novelty: 0.5)` — imports concept from external source
+- `concept_fitness(concept_id:)` — returns fitness + label
+- `novelty_landscape` — domain -> mean novelty map
+- `genesis_rate` — concepts born per time window
+- `most_adopted(limit: 10)`, `orphan_concepts(limit: 10)`
+- `genesis_report` — full stats
+
+## Runners
+
+**Module**: `Legion::Extensions::CognitiveGenesis::Runners::Genesis`
+
+| Method | Key Args | Returns |
+|---|---|---|
+| `plant_seed` | `domain:`, `source:`, `content:`, `potential: 0.5` | `{ success:, seed_id:, seed: }` |
+| `germinate_seed` | `seed_id:` | `{ success:, concept: }` or `{ success: false, reason: }` |
+| `birth_concept` | `seed_id:` | `{ success:, concept_id:, concept: }` |
+| `nurture_concept` | `concept_id:`, `amount: 0.1` | `{ success:, concept: }` |
+| `prune_seed` | `seed_id:` | `{ success:, pruned: }` |
+| `cross_pollinate` | `seed_a_id:`, `seed_b_id:` | `{ success:, seed_id:, seed: }` |
+| `adopt_concept` | `concept_type:`, `domain:`, `content:` | `{ success:, concept_id:, concept: }` |
+| `concept_fitness` | `concept_id:` | `{ success:, fitness:, label: }` |
+| `novelty_landscape` | — | `{ success:, landscape: }` |
+| `genesis_rate` | — | `{ success:, rate: }` |
+| `most_adopted` | `limit: 10` | `{ success:, concepts: }` |
+| `orphan_concepts` | `limit: 10` | `{ success:, concepts: }` |
+| `genesis_report` | — | Full report hash |
+
+Private: `genesis_engine` — memoized `GenesisEngine`. Logs via `log_debug` helper.
+
+## Integration Points
+
+- **`lex-cognitive-furnace`**: Smelted alloys (insight, wisdom, synthesis) feed genesis as seeds or direct concept inputs. The furnace produces refined material; genesis turns that material into new concepts.
+- **`lex-cognitive-garden`**: Mature, flowering garden plants are candidates for genesis seed planting or cross-pollination.
+- **`lex-memory`**: Born concepts should be stored as semantic traces in lex-memory. `adopt_concept` is the primary path for ingesting concepts from external sources or other agents.
+- **`lex-dream`**: Dream cycle outputs (agenda items, resolved contradictions) can be adopted as concepts via `adopt_concept`.
+
+## Development Notes
+
+- `birth` is the gating step: a germinated seed's concept candidate must independently pass both viability (`fitness >= 0.4`) and novelty (`novelty >= 0.5`) checks. Germination alone is not sufficient.
+- `cross_pollinate` does not consume source seeds; both remain in the store after producing a child seed.
+- `orphan_concepts` returns concepts whose originating seed has been pruned.
+- `genesis_rate` uses a rolling window; a cold engine with no births returns 0.0.
+- In-memory only.
+
+---
+
+**Maintained By**: Matthew Iverson (@Esity)

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,50 @@
+# lex-cognitive-genesis
+
+Cognitive concept emergence engine for brain-modeled agentic AI in the LegionIO ecosystem.
+
+## What It Does
+
+Models how new cognitive concepts emerge from raw seeds. Seeds are planted with a germination potential; once potential exceeds the threshold (0.7), germination produces a concept candidate. That candidate only achieves full birth if it simultaneously passes viability (fitness >= 0.4) and novelty (>= 0.5) checks. Born concepts can be nurtured to increase fitness, cross-pollinated to produce hybrid seeds, or pruned. External concepts can be adopted directly. The engine tracks novelty distribution across domains and genesis rate over time.
+
+## Usage
+
+```ruby
+require 'legion/extensions/cognitive_genesis'
+
+client = Legion::Extensions::CognitiveGenesis::Client.new
+
+# Plant a seed
+result = client.plant_seed(domain: :engineering, source: :experience, content: 'fault-tolerant retry pattern', potential: 0.8)
+seed_id = result[:seed_id]
+
+# Germinate when potential is sufficient
+germination = client.germinate_seed(seed_id: seed_id)
+# => { success: true, concept: { fitness: 0.5, novelty: 0.6, ... } }
+
+# Birth the concept if viable and novel
+concept = client.birth_concept(seed_id: seed_id)
+# => { success: true, concept_id: "...", concept: { ... } }
+
+# Nurture to increase fitness
+client.nurture_concept(concept_id: concept[:concept_id], amount: 0.15)
+
+# Check novelty across domains
+client.novelty_landscape
+# => { success: true, landscape: { engineering: 0.6, ... } }
+
+# Full genesis report
+client.genesis_report
+# => { success: true, report: { seed_count: 0, concept_count: 1, genesis_rate: 0.1, ... } }
+```
+
+## Development
+
+```bash
+bundle install
+bundle exec rspec
+bundle exec rubocop
+```
+
+## License
+
+MIT

data/lex-cognitive-genesis.gemspec

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require_relative 'lib/legion/extensions/cognitive_genesis/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'lex-cognitive-genesis'
+  spec.version       = Legion::Extensions::CognitiveGenesis::VERSION
+  spec.authors       = ['Esity']
+  spec.email         = ['matthewdiverson@gmail.com']
+
+  spec.summary       = 'LEX Cognitive Genesis'
+  spec.description   = 'De novo concept creation for brain-modeled agentic AI — the 200th LegionIO cognitive extension. ' \
+                       'Seeds proto-concepts, germinates them into novel cognitive categories, and tracks their adoption.'
+  spec.homepage      = 'https://github.com/LegionIO/lex-cognitive-genesis'
+  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-genesis'
+  spec.metadata['documentation_uri']     = 'https://github.com/LegionIO/lex-cognitive-genesis'
+  spec.metadata['changelog_uri']         = 'https://github.com/LegionIO/lex-cognitive-genesis'
+  spec.metadata['bug_tracker_uri']       = 'https://github.com/LegionIO/lex-cognitive-genesis/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_genesis/client.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module CognitiveGenesis
+      class Client
+        include Runners::Genesis
+
+        attr_reader :engine
+
+        def initialize(engine: nil, **)
+          @engine = engine || Helpers::GenesisEngine.new
+        end
+
+        private
+
+        def default_engine
+          @engine
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/cognitive_genesis/helpers/concept.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+
+module Legion
+  module Extensions
+    module CognitiveGenesis
+      module Helpers
+        class Concept
+          attr_reader   :concept_id, :name, :definition, :parent_seed_id, :domain, :born_at
+          attr_accessor :maturity, :connections, :utility_score, :adoption_count
+
+          def initialize(name:, definition:, parent_seed_id:, domain:,
+                         maturity: 0.0, connections: [], utility_score: 0.0, adoption_count: 0)
+            unless Constants::SEED_DOMAINS.include?(domain.to_sym)
+              raise ArgumentError, "invalid domain: #{domain.inspect}; must be one of #{Constants::SEED_DOMAINS.inspect}"
+            end
+
+            @concept_id     = SecureRandom.uuid
+            @name           = name.to_s.freeze
+            @definition     = definition.to_s.freeze
+            @parent_seed_id = parent_seed_id.to_s.freeze
+            @domain         = domain.to_sym
+            @maturity       = maturity.clamp(0.0, 1.0).round(10)
+            @connections    = Array(connections).dup
+            @utility_score  = utility_score.clamp(0.0, 1.0).round(10)
+            @adoption_count = adoption_count.to_i
+            @born_at        = Time.now.utc
+          end
+
+          def maturity_label
+            Constants.label_for(Constants::MATURITY_LABELS, maturity)
+          end
+
+          def fitness_label
+            Constants.label_for(Constants::FITNESS_LABELS, utility_score)
+          end
+
+          def adopt!
+            @adoption_count += 1
+            @utility_score   = (@utility_score + Constants::ADOPTION_BONUS).clamp(0.0, 1.0).round(10)
+            @maturity        = (@maturity + Constants::MATURITY_BOOST).clamp(0.0, 1.0).round(10)
+          end
+
+          def nurture!(boost: Constants::MATURITY_BOOST)
+            @maturity = (@maturity + boost).clamp(0.0, 1.0).round(10)
+          end
+
+          def decay!(rate: Constants::MATURITY_DECAY)
+            @maturity = (@maturity - rate).clamp(0.0, 1.0).round(10)
+          end
+
+          def connect_to(concept_id)
+            @connections << concept_id unless @connections.include?(concept_id)
+          end
+
+          def orphan?
+            adoption_count.zero?
+          end
+
+          def to_h
+            {
+              concept_id:     concept_id,
+              name:           name,
+              definition:     definition,
+              parent_seed_id: parent_seed_id,
+              domain:         domain,
+              maturity:       maturity,
+              maturity_label: maturity_label,
+              connections:    connections,
+              utility_score:  utility_score,
+              fitness_label:  fitness_label,
+              adoption_count: adoption_count,
+              orphan:         orphan?,
+              born_at:        born_at
+            }
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module CognitiveGenesis
+      module Helpers
+        module Constants
+          MAX_SEEDS    = 200
+          MAX_CONCEPTS = 100
+
+          DEFAULT_GERMINATION   = 0.3
+          GERMINATION_BOOST     = 0.1
+          GERMINATION_THRESHOLD = 0.7
+
+          DEFAULT_NOVELTY     = 0.5
+          NOVELTY_THRESHOLD   = 0.5
+          VIABILITY_THRESHOLD = 0.4
+
+          MATURATION_RATE = 0.08
+          NOVELTY_DECAY   = 0.02
+          SYNTHESIS_BONUS = 0.15
+          MATURITY_BOOST  = 0.08
+          MATURITY_DECAY  = 0.02
+          ADOPTION_BONUS  = 0.05
+
+          CONCEPT_TYPES = %i[
+            fusion
+            abstraction
+            analogy
+            inversion
+            extrapolation
+            mutation
+            emergence
+            transcendence
+          ].freeze
+
+          SOURCE_DOMAINS = %i[
+            perception
+            memory
+            language
+            reasoning
+            emotion
+            social
+            embodiment
+            imagination
+          ].freeze
+
+          MATURITY_STAGES = %i[
+            germinal
+            embryonic
+            nascent
+            developing
+            viable
+            mature
+            crystallized
+          ].freeze
+
+          SEED_DOMAINS = %i[
+            linguistic
+            spatial
+            logical
+            interpersonal
+            aesthetic
+            procedural
+            abstract
+            emergent
+          ].freeze
+
+          GERMINATION_LABELS = {
+            (0.0...0.2) => :dormant,
+            (0.2...0.4) => :stirring,
+            (0.4...0.6) => :awakening,
+            (0.6...0.8) => :developing,
+            (0.8..1.0)  => :ready
+          }.freeze
+
+          NOVELTY_LABELS = {
+            (0.0...0.2) => :derivative,
+            (0.2...0.4) => :recombinant,
+            (0.4..0.6)  => :emergent,
+            (0.6...0.8) => :novel,
+            (0.8..1.0)  => :unprecedented
+          }.freeze
+
+          MATURITY_LABELS = {
+            (0.0...0.2) => :nascent,
+            (0.2...0.4) => :fragile,
+            (0.4...0.6) => :establishing,
+            (0.6...0.8) => :stable,
+            (0.8..1.0)  => :foundational
+          }.freeze
+
+          FITNESS_LABELS = {
+            (0.0...0.2) => :untested,
+            (0.2...0.4) => :experimental,
+            (0.4...0.6) => :promising,
+            (0.6...0.8) => :proven,
+            (0.8..1.0)  => :essential
+          }.freeze
+
+          VIABILITY_LABELS = {
+            (0.8..1.0)  => :strongly_viable,
+            (0.6...0.8) => :viable,
+            (0.4...0.6) => :marginal,
+            (0.2...0.4) => :tenuous,
+            (0.0...0.2) => :non_viable
+          }.freeze
+
+          FERTILITY_LABELS = {
+            (0.8..1.0)  => :prolific,
+            (0.6...0.8) => :fertile,
+            (0.4...0.6) => :moderate,
+            (0.2...0.4) => :sparse,
+            (0.0...0.2) => :barren
+          }.freeze
+
+          def self.label_for(labels_hash, value)
+            clamped = value.clamp(0.0, 1.0)
+            labels_hash.each do |range, label|
+              return label if range.cover?(clamped)
+            end
+            labels_hash.values.last
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/cognitive_genesis/helpers/genesis_engine.rb

@@ -0,0 +1,247 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module CognitiveGenesis
+      module Helpers
+        class GenesisEngine
+          include Constants
+
+          attr_reader :seeds, :concepts, :genesis_events
+
+          def initialize
+            @seeds          = {}
+            @concepts       = {}
+            @genesis_events = []
+          end
+
+          def plant(raw_material:, domain:, germination_potential: DEFAULT_GERMINATION,
+                    novelty_score: 0.0, viability: 0.0, **)
+            return { planted: false, reason: :capacity_exceeded } if @seeds.size >= MAX_SEEDS
+
+            seed = Seed.new(
+              raw_material:          raw_material,
+              domain:                domain,
+              germination_potential: germination_potential,
+              novelty_score:         novelty_score,
+              viability:             viability
+            )
+            @seeds[seed.seed_id] = seed
+            Legion::Logging.debug "[cognitive_genesis] planted seed #{seed.seed_id[0..7]} " \
+                                  "domain=#{domain} novelty=#{novelty_score.round(3)}"
+            { planted: true, seed_id: seed.seed_id, seed: seed.to_h }
+          end
+
+          def germinate(seed_id:, boost: GERMINATION_BOOST, **)
+            seed = @seeds[seed_id]
+            return { germinated: false, reason: :not_found } unless seed
+
+            seed.germination_potential = (seed.germination_potential + boost).clamp(0.0, 1.0).round(10)
+            seed.viability             = compute_viability(seed)
+
+            Legion::Logging.debug "[cognitive_genesis] germinated #{seed_id[0..7]} " \
+                                  "potential=#{seed.germination_potential.round(3)}"
+            { germinated: true, seed_id: seed_id,
+              germination_potential: seed.germination_potential,
+              viability:             seed.viability,
+              label:                 seed.germination_label }
+          end
+
+          def birth(seed_id:, name:, definition:, **)
+            seed = @seeds[seed_id]
+            return { birthed: false, reason: :not_found } unless seed
+            return { birthed: false, reason: :not_viable }  unless seed.viable?
+            return { birthed: false, reason: :not_novel }   unless seed.novel?
+            return { birthed: false, reason: :not_ready }   unless seed.ready_to_birth?
+            return { birthed: false, reason: :concept_capacity_exceeded } if @concepts.size >= MAX_CONCEPTS
+
+            concept = Concept.new(
+              name:           name,
+              definition:     definition,
+              parent_seed_id: seed_id,
+              domain:         seed.domain
+            )
+            @concepts[concept.concept_id] = concept
+            @seeds.delete(seed_id)
+            record_genesis_event(concept: concept, seed: seed)
+
+            Legion::Logging.info "[cognitive_genesis] concept born: \"#{name}\" " \
+                                 "(#{concept.concept_id[0..7]}) domain=#{seed.domain}"
+            { birthed: true, concept_id: concept.concept_id, concept: concept.to_h }
+          end
+
+          def nurture(concept_id:, boost: MATURITY_BOOST, **)
+            concept = @concepts[concept_id]
+            return { nurtured: false, reason: :not_found } unless concept
+
+            concept.nurture!(boost: boost)
+            Legion::Logging.debug "[cognitive_genesis] nurtured #{concept_id[0..7]} " \
+                                  "maturity=#{concept.maturity.round(3)}"
+            { nurtured: true, concept_id: concept_id,
+              maturity: concept.maturity, label: concept.maturity_label }
+          end
+
+          def prune(seed_id:, **)
+            seed = @seeds.delete(seed_id)
+            return { pruned: false, reason: :not_found } unless seed
+
+            Legion::Logging.debug "[cognitive_genesis] pruned seed #{seed_id[0..7]}"
+            { pruned: true, seed_id: seed_id }
+          end
+
+          def cross_pollinate(seed_id_a:, seed_id_b:, **)
+            guard = cross_pollinate_guard(seed_id_a, seed_id_b)
+            return guard if guard
+
+            seed_a         = @seeds[seed_id_a]
+            seed_b         = @seeds[seed_id_b]
+            child_novelty  = cross_novelty(seed_a.novelty_score, seed_b.novelty_score)
+            result         = plant_cross_child(seed_a, seed_b, child_novelty)
+
+            Legion::Logging.debug '[cognitive_genesis] cross_pollinated ' \
+                                  "#{seed_id_a[0..7]}+#{seed_id_b[0..7]} -> #{result[:seed_id]&.slice(0, 8)}"
+            result.merge(cross_pollinated: true, parent_seed_ids: [seed_id_a, seed_id_b])
+          end
+
+          def adopt_concept(concept_id:, **)
+            concept = @concepts[concept_id]
+            return { adopted: false, reason: :not_found } unless concept
+
+            concept.adopt!
+            Legion::Logging.debug "[cognitive_genesis] adopted #{concept_id[0..7]} " \
+                                  "count=#{concept.adoption_count}"
+            { adopted: true, concept_id: concept_id,
+              adoption_count: concept.adoption_count,
+              utility_score:  concept.utility_score,
+              maturity:       concept.maturity }
+          end
+
+          def concept_fitness(concept_id:, **)
+            concept = @concepts[concept_id]
+            return { found: false } unless concept
+
+            { found:          true,
+              concept_id:     concept_id,
+              utility_score:  concept.utility_score,
+              fitness_label:  concept.fitness_label,
+              adoption_count: concept.adoption_count,
+              maturity:       concept.maturity }
+          end
+
+          def novelty_landscape(**)
+            seeds_map = @seeds.values.map do |s|
+              { id: s.seed_id, type: :seed, score: s.novelty_score,
+                label: s.novelty_label, domain: s.domain }
+            end
+            concepts_map = @concepts.values.map do |c|
+              { id: c.concept_id, type: :concept, score: 0.0, label: :n_a, domain: c.domain }
+            end
+            {
+              seeds:              seeds_map,
+              concepts:           concepts_map,
+              avg_seed_novelty:   avg_values(@seeds.values.map(&:novelty_score)),
+              high_novelty_seeds: @seeds.values.count(&:novel?)
+            }
+          end
+
+          def genesis_rate(**)
+            return { rate: 0.0, total_events: 0 } if @genesis_events.empty?
+
+            oldest        = @genesis_events.min_by { |e| e[:born_at] }[:born_at]
+            elapsed_hours = [(Time.now.utc - oldest) / 3600.0, 1.0].max
+            rate          = @genesis_events.size / elapsed_hours
+            { rate:          rate.round(10),
+              total_events:  @genesis_events.size,
+              elapsed_hours: elapsed_hours.round(4) }
+          end
+
+          def most_adopted(**)
+            return nil if @concepts.empty?
+
+            @concepts.values.max_by(&:adoption_count)&.to_h
+          end
+
+          def orphan_concepts(**)
+            @concepts.values.select(&:orphan?).map(&:to_h)
+          end
+
+          def genesis_report(**)
+            {
+              seeds:                @seeds.size,
+              concepts:             @concepts.size,
+              genesis_events:       @genesis_events.size,
+              genesis_rate:         genesis_rate,
+              orphan_count:         orphan_concepts.size,
+              most_adopted:         most_adopted,
+              avg_seed_novelty:     avg_values(@seeds.values.map(&:novelty_score)),
+              avg_concept_maturity: avg_values(@concepts.values.map(&:maturity)),
+              domains_active:       active_domains
+            }
+          end
+
+          private
+
+          def cross_pollinate_guard(seed_id_a, seed_id_b)
+            return { cross_pollinated: false, reason: :seed_a_not_found } unless @seeds[seed_id_a]
+            return { cross_pollinated: false, reason: :seed_b_not_found } unless @seeds[seed_id_b]
+            return { cross_pollinated: false, reason: :capacity_exceeded } if @seeds.size >= MAX_SEEDS
+
+            nil
+          end
+
+          def plant_cross_child(seed_a, seed_b, child_novelty)
+            combined_viability = ((seed_a.viability + seed_b.viability) / 2.0).round(10)
+            plant(
+              raw_material:          (seed_a.raw_material + seed_b.raw_material).uniq,
+              domain:                pick_domain(seed_a.domain, seed_b.domain, child_novelty),
+              germination_potential: DEFAULT_GERMINATION + GERMINATION_BOOST,
+              novelty_score:         child_novelty,
+              viability:             combined_viability
+            )
+          end
+
+          def compute_viability(seed)
+            material_factor  = [seed.raw_material.size / 5.0, 1.0].min
+            novelty_factor   = seed.novelty_score
+            potential_factor = seed.germination_potential
+            ((material_factor * 0.3) + (novelty_factor * 0.4) + (potential_factor * 0.3)).clamp(0.0, 1.0).round(10)
+          end
+
+          def cross_novelty(score_a, score_b)
+            base    = [score_a, score_b].max
+            synergy = (score_a - score_b).abs * 0.5
+            (base + synergy + GERMINATION_BOOST).clamp(0.0, 1.0).round(10)
+          end
+
+          def pick_domain(domain_a, domain_b, novelty)
+            return :emergent if novelty >= 0.8
+            return domain_a  if domain_a == domain_b
+
+            novelty >= 0.6 ? :abstract : domain_a
+          end
+
+          def avg_values(values)
+            return 0.0 if values.empty?
+
+            (values.sum / values.size.to_f).round(10)
+          end
+
+          def active_domains
+            all_domains = @seeds.values.map(&:domain) + @concepts.values.map(&:domain)
+            all_domains.tally
+          end
+
+          def record_genesis_event(concept:, seed:)
+            @genesis_events << {
+              concept_id: concept.concept_id,
+              name:       concept.name,
+              domain:     concept.domain,
+              seed_id:    seed.seed_id,
+              born_at:    concept.born_at
+            }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/cognitive_genesis/helpers/seed.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+
+module Legion
+  module Extensions
+    module CognitiveGenesis
+      module Helpers
+        class Seed
+          attr_reader   :seed_id, :raw_material, :domain, :created_at
+          attr_accessor :germination_potential, :novelty_score, :viability
+
+          def initialize(raw_material:, domain:, germination_potential: Constants::DEFAULT_GERMINATION,
+                         novelty_score: 0.0, viability: 0.0)
+            unless Constants::SEED_DOMAINS.include?(domain.to_sym)
+              raise ArgumentError, "invalid domain: #{domain.inspect}; must be one of #{Constants::SEED_DOMAINS.inspect}"
+            end
+
+            @seed_id              = SecureRandom.uuid
+            @raw_material         = Array(raw_material).freeze
+            @domain               = domain.to_sym
+            @germination_potential = germination_potential.clamp(0.0, 1.0).round(10)
+            @novelty_score        = novelty_score.clamp(0.0, 1.0).round(10)
+            @viability            = viability.clamp(0.0, 1.0).round(10)
+            @created_at           = Time.now.utc
+          end
+
+          def germination_label
+            Constants.label_for(Constants::GERMINATION_LABELS, germination_potential)
+          end
+
+          def novelty_label
+            Constants.label_for(Constants::NOVELTY_LABELS, novelty_score)
+          end
+
+          def viable?
+            viability >= Constants::VIABILITY_THRESHOLD
+          end
+
+          def novel?
+            novelty_score >= Constants::NOVELTY_THRESHOLD
+          end
+
+          def ready_to_birth?
+            germination_potential >= Constants::GERMINATION_THRESHOLD && viable? && novel?
+          end
+
+          def to_h
+            {
+              seed_id:               seed_id,
+              raw_material:          raw_material,
+              domain:                domain,
+              germination_potential: germination_potential,
+              novelty_score:         novelty_score,
+              viability:             viability,
+              germination_label:     germination_label,
+              novelty_label:         novelty_label,
+              ready_to_birth:        ready_to_birth?,
+              created_at:            created_at
+            }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/cognitive_genesis/runners/genesis.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module CognitiveGenesis
+      module Runners
+        module Genesis
+          def plant_seed(raw_material:, domain:, engine: nil,
+                         germination_potential: Helpers::Constants::DEFAULT_GERMINATION,
+                         novelty_score: 0.0, viability: 0.0, **)
+            e      = engine || default_engine
+            result = e.plant(raw_material: raw_material, domain: domain,
+                             germination_potential: germination_potential,
+                             novelty_score: novelty_score, viability: viability)
+            { success: result[:planted], **result }
+          end
+
+          def germinate_seed(seed_id:, engine: nil, boost: Helpers::Constants::GERMINATION_BOOST, **)
+            e      = engine || default_engine
+            result = e.germinate(seed_id: seed_id, boost: boost)
+            { success: result[:germinated], **result }
+          end
+
+          def birth_concept(seed_id:, name:, definition:, engine: nil, **)
+            e      = engine || default_engine
+            result = e.birth(seed_id: seed_id, name: name, definition: definition)
+            { success: result[:birthed], **result }
+          end
+
+          def nurture_concept(concept_id:, engine: nil, boost: Helpers::Constants::MATURITY_BOOST, **)
+            e      = engine || default_engine
+            result = e.nurture(concept_id: concept_id, boost: boost)
+            { success: result[:nurtured], **result }
+          end
+
+          def prune_seed(seed_id:, engine: nil, **)
+            e      = engine || default_engine
+            result = e.prune(seed_id: seed_id)
+            { success: result[:pruned], **result }
+          end
+
+          def cross_pollinate(seed_id_a:, seed_id_b:, engine: nil, **)
+            e      = engine || default_engine
+            result = e.cross_pollinate(seed_id_a: seed_id_a, seed_id_b: seed_id_b)
+            { success: result[:cross_pollinated], **result }
+          end
+
+          def adopt_concept(concept_id:, engine: nil, **)
+            e      = engine || default_engine
+            result = e.adopt_concept(concept_id: concept_id)
+            { success: result[:adopted], **result }
+          end
+
+          def concept_fitness(concept_id:, engine: nil, **)
+            e      = engine || default_engine
+            result = e.concept_fitness(concept_id: concept_id)
+            { success: result[:found], **result }
+          end
+
+          def novelty_landscape(engine: nil, **)
+            e         = engine || default_engine
+            landscape = e.novelty_landscape
+            { success: true, **landscape }
+          end
+
+          def genesis_rate(engine: nil, **)
+            e      = engine || default_engine
+            result = e.genesis_rate
+            { success: true, **result }
+          end
+
+          def most_adopted(engine: nil, **)
+            e       = engine || default_engine
+            concept = e.most_adopted
+            { success: true, concept: concept }
+          end
+
+          def orphan_concepts(engine: nil, **)
+            e       = engine || default_engine
+            orphans = e.orphan_concepts
+            { success: true, orphans: orphans, count: orphans.size }
+          end
+
+          def genesis_report(engine: nil, **)
+            e      = engine || default_engine
+            report = e.genesis_report
+            { success: true, **report }
+          end
+
+          include Legion::Extensions::Helpers::Lex if defined?(Legion::Extensions::Helpers::Lex)
+
+          private
+
+          def default_engine
+            @default_engine ||= Helpers::GenesisEngine.new
+          end
+        end
+      end
+    end
+  end
+end

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

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

data/lib/legion/extensions/cognitive_genesis.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/cognitive_genesis/version'
+require 'legion/extensions/cognitive_genesis/helpers/constants'
+require 'legion/extensions/cognitive_genesis/helpers/seed'
+require 'legion/extensions/cognitive_genesis/helpers/concept'
+require 'legion/extensions/cognitive_genesis/helpers/genesis_engine'
+require 'legion/extensions/cognitive_genesis/runners/genesis'
+require 'legion/extensions/cognitive_genesis/client'
+
+module Legion
+  module Extensions
+    module CognitiveGenesis
+      extend Legion::Extensions::Core if Legion::Extensions.const_defined? :Core
+    end
+  end
+end

metadata

@@ -0,0 +1,78 @@
+--- !ruby/object:Gem::Specification
+name: lex-cognitive-genesis
+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: De novo concept creation for brain-modeled agentic AI — the 200th LegionIO
+  cognitive extension. Seeds proto-concepts, germinates them into novel cognitive
+  categories, and tracks their adoption.
+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-genesis.gemspec
+- lib/legion/extensions/cognitive_genesis.rb
+- lib/legion/extensions/cognitive_genesis/client.rb
+- lib/legion/extensions/cognitive_genesis/helpers/concept.rb
+- lib/legion/extensions/cognitive_genesis/helpers/constants.rb
+- lib/legion/extensions/cognitive_genesis/helpers/genesis_engine.rb
+- lib/legion/extensions/cognitive_genesis/helpers/seed.rb
+- lib/legion/extensions/cognitive_genesis/runners/genesis.rb
+- lib/legion/extensions/cognitive_genesis/version.rb
+homepage: https://github.com/LegionIO/lex-cognitive-genesis
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/LegionIO/lex-cognitive-genesis
+  source_code_uri: https://github.com/LegionIO/lex-cognitive-genesis
+  documentation_uri: https://github.com/LegionIO/lex-cognitive-genesis
+  changelog_uri: https://github.com/LegionIO/lex-cognitive-genesis
+  bug_tracker_uri: https://github.com/LegionIO/lex-cognitive-genesis/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 Genesis
+test_files: []