lex-cognitive-greenhouse 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 9a71509bc945dd7588f4a2cf2a722b69d427ce360fffa357a83c2fae666358d1
+  data.tar.gz: 9309329468ab8978901ffa082d579e54df189e67ce749728d467ca64bacb5c50
+SHA512:
+  metadata.gz: 9bb343b5f66b60cb866523398c573e64a64e2b6fa6f3593db4b1f1c6018d344a59d7a9b20349be6ff59bb6fabfcaed99631e462e2e3331e7afebc966df389728
+  data.tar.gz: 7de1e9b47418c1f91c945aec904495c5df91155fe885221fbe365493e0669ab91590005699c7464e853f0d06a3388f3bf2ca22a2f38a5c34ddeb3c864d6346fa

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

data/.rspec

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

data/.rubocop.yml

@@ -0,0 +1,64 @@
+AllCops:
+  TargetRubyVersion: 3.4
+  NewCops: enable
+  SuggestExtensions: false
+
+Layout/LineLength:
+  Max: 160
+
+Layout/SpaceAroundEqualsInParameterDefault:
+  EnforcedStyle: space
+
+Layout/HashAlignment:
+  EnforcedHashRocketStyle: table
+  EnforcedColonStyle: table
+
+Metrics/MethodLength:
+  Max: 25
+
+Metrics/ClassLength:
+  Max: 150
+
+Metrics/ModuleLength:
+  Max: 300
+
+Metrics/BlockLength:
+  Max: 40
+  Exclude:
+    - 'spec/**/*'
+
+Metrics/AbcSize:
+  Max: 25
+
+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

data/CLAUDE.md

@@ -0,0 +1,110 @@
+# lex-cognitive-greenhouse
+
+**Level 3 Leaf Documentation**
+- **Parent**: `/Users/miverso2/rubymine/legion/extensions-agentic/CLAUDE.md`
+- **Gem**: `lex-cognitive-greenhouse`
+
+## Purpose
+
+Models a controlled cognitive growth environment with seasonal cycles and environmental conditions. Unlike the open-air garden, the greenhouse maintains explicit environmental variables (temperature, humidity, light) and advances through four seasons that alter growth rates. Plants grow only when environment quality meets minimum thresholds. Season transitions automatically adjust environmental conditions. Plants that reach the harvestable stage (`:bloom`) can be harvested, removing them from the active plant set. The engine tracks quality scores and growth stage distribution across plants.
+
+## Gem Info
+
+| Field | Value |
+|---|---|
+| Gem name | `lex-cognitive-greenhouse` |
+| Version | `0.1.0` |
+| Namespace | `Legion::Extensions::CognitiveGreenhouse` |
+| Ruby | `>= 3.4` |
+| License | MIT |
+| GitHub | https://github.com/LegionIO/lex-cognitive-greenhouse |
+
+## File Structure
+
+```
+lib/legion/extensions/cognitive_greenhouse/
+  cognitive_greenhouse.rb           # Top-level require
+  version.rb                        # VERSION = '0.1.0'
+  client.rb                         # Client class
+  helpers/
+    constants.rb                    # Seasons, stages, plant types, rates, ideal conditions, labels
+    plant.rb                        # Plant value object (with quality tracking)
+    greenhouse_engine.rb            # Engine: plants, environment, seasons, growth, harvest
+  runners/
+    cognitive_greenhouse.rb         # Runner module (extend self)
+```
+
+## Key Constants
+
+| Constant | Value | Meaning |
+|---|---|---|
+| `SEASONS` | array | `[:spring, :summer, :autumn, :winter]` |
+| `GROWTH_STAGES` | array | `[:seed, :sprout, :vegetative, :budding, :bloom, :dormant]` |
+| `PLANT_TYPES` | array | `[:concept, :theory, :insight, :belief, :intention, :memory, :intuition, :analogy]` |
+| `MAX_PLANTS` | 50 | Plant cap |
+| `GROWTH_RATE` | per-season hash | `:spring => 0.08`, `:summer => 0.10`, `:autumn => 0.05`, `:winter => 0.01` |
+| `IDEAL_TEMPERATURE` | 0.65 | Optimal temperature for growth quality |
+| `IDEAL_HUMIDITY` | 0.7 | Optimal humidity |
+| `IDEAL_LIGHT` | 0.75 | Optimal light level |
+| `CONDITION_LABELS` | nested hash | Labels for temperature, humidity, light levels |
+| `CONDITION_WEIGHTS` | hash | `temperature: 0.4, humidity: 0.3, light: 0.3` |
+| `STAGE_ADVANCE_THRESHOLD` | 0.65 | Minimum quality to advance to next stage |
+| `MIN_QUALITY_FOR_GROWTH` | 0.40 | Minimum quality required for any growth |
+| `HARVESTABLE_STAGE` | `:bloom` | Stage at which plants can be harvested |
+
+## Helpers
+
+### `Plant`
+
+A cognitive idea growing under controlled conditions.
+
+- `initialize(plant_type:, domain:, content:, quality: 0.5, plant_id: nil)`
+- `grow!(rate, quality)` — advances growth; stage advances when growth crosses threshold and quality >= `STAGE_ADVANCE_THRESHOLD`
+- `harvestable?` — stage == `:bloom`
+- `dormant?`
+- `growth_label`, `quality_label`
+- `to_h`
+
+### `GreenhouseEngine`
+
+- `create_plant(plant_type:, domain:, content:)` — returns `{ created:, plant_id:, plant: }` or capacity error
+- `plant_in_greenhouse(plant_id:)` — marks plant as active in greenhouse (separate from creation)
+- `grow_all!` — applies season's growth rate to all qualifying plants; skips plants where environment quality < `MIN_QUALITY_FOR_GROWTH`
+- `adjust_environment(temperature: nil, humidity: nil, light: nil)` — updates environmental variables; recalculates overall quality
+- `cycle_season` — advances to next season in cycle; auto-adjusts temperature/humidity/light to seasonal defaults
+- `harvest(plant_id:)` — removes harvestable plant; returns plant data
+- `greenhouse_report` — full stats including season, environment quality, stage distribution
+
+## Runners
+
+**Module**: `Legion::Extensions::CognitiveGreenhouse::Runners::CognitiveGreenhouse`
+
+Uses `extend self` pattern.
+
+| Method | Key Args | Returns |
+|---|---|---|
+| `plant_idea` | `plant_type:`, `domain:`, `content:` | `{ success:, plant_id:, plant: }` |
+| `tend_greenhouse` | — | `{ success:, grown: }` — runs grow_all! |
+| `adjust_environment` | `temperature: nil`, `humidity: nil`, `light: nil` | `{ success:, environment: }` |
+| `advance_season` | — | `{ success:, season:, environment: }` |
+| `harvest_ideas` | — | `{ success:, harvested: [...] }` |
+| `greenhouse_status` | — | `{ success:, report: }` |
+
+Private: `greenhouse(engine)` — memoized `GreenhouseEngine`. Logs via `log_debug` helper.
+
+## Integration Points
+
+- **`lex-cognitive-garden`**: Garden is open-air and unbounded; greenhouse is controlled and capacity-capped (50 plants). Greenhouse is suitable for high-value concepts requiring precise conditions; garden for broader cultivation.
+- **`lex-cognitive-genesis`**: Harvested bloom-stage plants are prime candidates for genesis seed input. The greenhouse accelerates concept maturation before genesis processing.
+- **`lex-memory`**: Harvested concepts should be stored as semantic traces in lex-memory immediately after harvest.
+
+## Development Notes
+
+- `grow_all!` applies the current season's growth rate but only when environment quality exceeds `MIN_QUALITY_FOR_GROWTH` (0.40). In poor conditions (e.g., winter with low quality), plants do not grow.
+- `cycle_season` wraps around after `:winter` back to `:spring`. The auto-adjusted environmental values reflect the season's characteristic conditions.
+- `harvest` is destructive — it removes the plant from the engine's tracking. The returned hash is the only record after harvest.
+- In-memory only.
+
+---
+
+**Maintained By**: Matthew Iverson (@Esity)

data/Gemfile

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

data/Gemfile.lock

@@ -0,0 +1,91 @@
+PATH
+  remote: .
+  specs:
+    lex-cognitive-greenhouse (0.1.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    addressable (2.8.9)
+      public_suffix (>= 2.0.2, < 8.0)
+    ast (2.4.3)
+    bigdecimal (4.0.1)
+    diff-lcs (1.6.2)
+    docile (1.4.1)
+    json (2.19.1)
+    json-schema (6.2.0)
+      addressable (~> 2.8)
+      bigdecimal (>= 3.1, < 5)
+    language_server-protocol (3.17.0.5)
+    lint_roller (1.1.0)
+    mcp (0.8.0)
+      json-schema (>= 4.1)
+    parallel (1.27.0)
+    parser (3.3.10.2)
+      ast (~> 2.4.1)
+      racc
+    prism (1.9.0)
+    public_suffix (7.0.5)
+    racc (1.8.1)
+    rainbow (3.1.1)
+    rake (13.3.1)
+    regexp_parser (2.11.3)
+    rspec (3.13.2)
+      rspec-core (~> 3.13.0)
+      rspec-expectations (~> 3.13.0)
+      rspec-mocks (~> 3.13.0)
+    rspec-core (3.13.6)
+      rspec-support (~> 3.13.0)
+    rspec-expectations (3.13.5)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.13.0)
+    rspec-mocks (3.13.8)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.13.0)
+    rspec-support (3.13.7)
+    rspec_junit_formatter (0.6.0)
+      rspec-core (>= 2, < 4, != 2.12.0)
+    rubocop (1.85.1)
+      json (~> 2.3)
+      language_server-protocol (~> 3.17.0.2)
+      lint_roller (~> 1.1.0)
+      mcp (~> 0.6)
+      parallel (~> 1.10)
+      parser (>= 3.3.0.2)
+      rainbow (>= 2.2.2, < 4.0)
+      regexp_parser (>= 2.9.3, < 3.0)
+      rubocop-ast (>= 1.49.0, < 2.0)
+      ruby-progressbar (~> 1.7)
+      unicode-display_width (>= 2.4.0, < 4.0)
+    rubocop-ast (1.49.1)
+      parser (>= 3.3.7.2)
+      prism (~> 1.7)
+    rubocop-rspec (3.9.0)
+      lint_roller (~> 1.1)
+      rubocop (~> 1.81)
+    ruby-progressbar (1.13.0)
+    simplecov (0.22.0)
+      docile (~> 1.1)
+      simplecov-html (~> 0.11)
+      simplecov_json_formatter (~> 0.1)
+    simplecov-html (0.13.2)
+    simplecov_json_formatter (0.1.4)
+    unicode-display_width (3.2.0)
+      unicode-emoji (~> 4.1)
+    unicode-emoji (4.2.0)
+
+PLATFORMS
+  arm64-darwin-25
+  ruby
+
+DEPENDENCIES
+  lex-cognitive-greenhouse!
+  rake
+  rspec (~> 3.13)
+  rspec_junit_formatter
+  rubocop (~> 1.75)
+  rubocop-rspec
+  simplecov
+
+BUNDLED WITH
+   2.6.9

data/README.md

@@ -0,0 +1,51 @@
+# lex-cognitive-greenhouse
+
+Controlled cognitive growth environment for brain-modeled agentic AI in the LegionIO ecosystem.
+
+## What It Does
+
+Models a seasonal, environmentally controlled space for maturing cognitive ideas. Plants (concepts, theories, insights, beliefs) grow at rates determined by the current season (spring through winter) only when environmental quality (temperature, humidity, light) meets minimum thresholds. Environment can be manually adjusted or automatically shifted by advancing seasons. Plants that reach the bloom stage can be harvested, removing them from the active set. The greenhouse provides finer control than an open garden — limited capacity, explicit conditions, and seasonal cycles.
+
+## Usage
+
+```ruby
+require 'legion/extensions/cognitive_greenhouse'
+
+client = Legion::Extensions::CognitiveGreenhouse::Client.new
+
+# Plant an idea in the greenhouse
+result = client.plant_idea(plant_type: :insight, domain: :systems, content: 'eventual consistency trade-offs')
+plant_id = result[:plant_id]
+
+# Adjust environment for optimal growth
+client.adjust_environment(temperature: 0.65, humidity: 0.70, light: 0.75)
+# => { success: true, environment: { quality: 0.69, season: :spring, ... } }
+
+# Tend all plants (applies seasonal growth rate)
+client.tend_greenhouse
+# => { success: true, grown: 1 }
+
+# Advance the season
+client.advance_season
+# => { success: true, season: :summer, environment: { ... } }
+
+# Harvest bloomed plants
+client.harvest_ideas
+# => { success: true, harvested: [{ plant_id: "...", type: :insight, ... }] }
+
+# Full status
+client.greenhouse_status
+# => { success: true, report: { plant_count: 0, season: :summer, ... } }
+```
+
+## Development
+
+```bash
+bundle install
+bundle exec rspec
+bundle exec rubocop
+```
+
+## License
+
+MIT

data/lex-cognitive-greenhouse.gemspec

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require_relative 'lib/legion/extensions/cognitive_greenhouse/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'lex-cognitive-greenhouse'
+  spec.version       = Legion::Extensions::CognitiveGreenhouse::VERSION
+  spec.authors       = ['Esity']
+  spec.email         = ['matthewdiverson@gmail.com']
+
+  spec.summary       = 'LEX Cognitive Greenhouse'
+  spec.description   = 'Protected environment for growing ideas from seeds to mature concepts — ' \
+                       'temperature, humidity, and light as nurturing conditions, with seasonal cycles'
+  spec.homepage      = 'https://github.com/LegionIO/lex-cognitive-greenhouse'
+  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-greenhouse'
+  spec.metadata['documentation_uri']   = 'https://github.com/LegionIO/lex-cognitive-greenhouse'
+  spec.metadata['changelog_uri']       = 'https://github.com/LegionIO/lex-cognitive-greenhouse'
+  spec.metadata['bug_tracker_uri']     = 'https://github.com/LegionIO/lex-cognitive-greenhouse/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_greenhouse/client.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module CognitiveGreenhouse
+      class Client
+        include Runners::CognitiveGreenhouse
+
+        def initialize(greenhouse: nil, **)
+          @greenhouse      = greenhouse || Helpers::Greenhouse.new
+          @default_engine  = Helpers::GreenhouseEngine.new(greenhouse: @greenhouse)
+        end
+
+        private
+
+        attr_reader :greenhouse
+      end
+    end
+  end
+end

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

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module CognitiveGreenhouse
+      module Helpers
+        module Constants
+          SEASONS = %i[spring summer autumn winter].freeze
+
+          GROWTH_STAGES = %i[seed sprout sapling mature bloom].freeze
+
+          PLANT_TYPES = %i[
+            hypothesis
+            insight
+            question
+            pattern
+            analogy
+            metaphor
+            theory
+            observation
+          ].freeze
+
+          MAX_PLANTS = 50
+
+          # Growth rate multiplier per season (spring blooms, winter slows)
+          GROWTH_RATE = {
+            spring: 1.4,
+            summer: 1.2,
+            autumn: 0.9,
+            winter: 0.5
+          }.freeze
+
+          # Ideal ranges per condition [min_ideal, max_ideal]
+          IDEAL_TEMPERATURE = [18.0, 26.0].freeze
+          IDEAL_HUMIDITY    = [0.55, 0.80].freeze
+          IDEAL_LIGHT       = [0.60, 0.95].freeze
+
+          CONDITION_LABELS = {
+            temperature: {
+              (0.0...10.0)  => :frozen,
+              (10.0...18.0) => :cool,
+              (18.0...26.0) => :optimal,
+              (26.0...34.0) => :warm,
+              (34.0..50.0)  => :hot
+            },
+            humidity:    {
+              (0.0...0.30)  => :arid,
+              (0.30...0.55) => :dry,
+              (0.55...0.80) => :optimal,
+              (0.80...0.90) => :humid,
+              (0.90..1.0)   => :saturated
+            },
+            light:       {
+              (0.0...0.20)  => :dark,
+              (0.20...0.40) => :dim,
+              (0.40...0.60) => :moderate,
+              (0.60...0.95) => :optimal,
+              (0.95..1.0)   => :intense
+            }
+          }.freeze
+
+          # How much each condition contributes to environment quality
+          CONDITION_WEIGHTS = {
+            temperature: 0.35,
+            humidity:    0.30,
+            light:       0.35
+          }.freeze
+
+          # Health change per grow! or wilt! call
+          GROW_HEALTH_BOOST  = 0.08
+          WILT_HEALTH_DRAIN  = 0.12
+
+          # Stage advance threshold (health must be above this)
+          STAGE_ADVANCE_THRESHOLD = 0.65
+
+          # Minimum environment quality to allow growth
+          MIN_QUALITY_FOR_GROWTH  = 0.40
+
+          # Harvest only fully bloomed plants
+          HARVESTABLE_STAGE = :bloom
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/cognitive_greenhouse/helpers/greenhouse.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module CognitiveGreenhouse
+      module Helpers
+        class Greenhouse
+          include Constants
+
+          SEASON_CYCLE = Constants::SEASONS.freeze
+
+          attr_reader :temperature, :humidity, :light_level, :season, :plants, :created_at, :cycles_completed
+
+          def initialize(temperature: 22.0, humidity: 0.65, light_level: 0.75, season: :spring)
+            raise ArgumentError, "unknown season: #{season.inspect}" unless Constants::SEASONS.include?(season)
+
+            @temperature      = temperature.clamp(0.0, 50.0)
+            @humidity         = humidity.clamp(0.0, 1.0)
+            @light_level      = light_level.clamp(0.0, 1.0)
+            @season           = season
+            @plants           = []
+            @created_at       = Time.now.utc
+            @cycles_completed = 0
+          end
+
+          def plant!(seedling)
+            raise ArgumentError, 'seedling must be a Seedling instance' unless seedling.is_a?(Seedling)
+
+            return { planted: false, reason: :greenhouse_full, capacity: Constants::MAX_PLANTS } if @plants.size >= Constants::MAX_PLANTS
+
+            @plants << seedling
+            { planted: true, id: seedling.id, total_plants: @plants.size }
+          end
+
+          def adjust_conditions(temperature: nil, humidity: nil, light_level: nil)
+            @temperature  = temperature.clamp(0.0, 50.0)  if temperature
+            @humidity     = humidity.clamp(0.0, 1.0)      if humidity
+            @light_level  = light_level.clamp(0.0, 1.0) if light_level
+
+            {
+              temperature: @temperature,
+              humidity:    @humidity,
+              light_level: @light_level,
+              quality:     environment_quality.round(10)
+            }
+          end
+
+          def cycle_season!
+            current_index = SEASON_CYCLE.index(@season)
+            @season = SEASON_CYCLE[(current_index + 1) % SEASON_CYCLE.size]
+            @cycles_completed += 1
+            { season: @season, cycle: @cycles_completed }
+          end
+
+          def environment_quality
+            temp_score     = score_condition(@temperature, Constants::IDEAL_TEMPERATURE[0], Constants::IDEAL_TEMPERATURE[1], 0.0, 50.0)
+            humidity_score = score_condition(@humidity, Constants::IDEAL_HUMIDITY[0], Constants::IDEAL_HUMIDITY[1], 0.0, 1.0)
+            light_score    = score_condition(@light_level, Constants::IDEAL_LIGHT[0], Constants::IDEAL_LIGHT[1], 0.0, 1.0)
+
+            (temp_score * Constants::CONDITION_WEIGHTS[:temperature]) +
+              (humidity_score * Constants::CONDITION_WEIGHTS[:humidity]) +
+              (light_score    * Constants::CONDITION_WEIGHTS[:light])
+          end
+
+          def harvest_blooms
+            bloomed, remaining = @plants.partition { |p| p.growth_stage == Constants::HARVESTABLE_STAGE }
+            @plants = remaining
+            bloomed.map(&:to_h)
+          end
+
+          def condition_snapshot
+            {
+              temperature:    @temperature,
+              humidity:       @humidity,
+              light_level:    @light_level,
+              season:         @season,
+              quality:        environment_quality.round(10),
+              temp_label:     label_for(:temperature, @temperature),
+              humidity_label: label_for(:humidity, @humidity),
+              light_label:    label_for(:light, @light_level)
+            }
+          end
+
+          def active_plants
+            @plants.reject { |p| p.growth_stage == :bloom }
+          end
+
+          private
+
+          def score_condition(value, ideal_min, ideal_max, abs_min, abs_max)
+            return 1.0 if value.between?(ideal_min, ideal_max)
+
+            if value < ideal_min
+              distance = ideal_min - value
+              1.0 - (distance / (ideal_min - abs_min + 0.001)).clamp(0.0, 1.0)
+            else
+              distance = value - ideal_max
+              1.0 - (distance / (abs_max - ideal_max + 0.001)).clamp(0.0, 1.0)
+            end
+          end
+
+          def label_for(condition, value)
+            Constants::CONDITION_LABELS[condition].each do |range, label|
+              return label if range.cover?(value)
+            end
+            :unknown
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/cognitive_greenhouse/helpers/greenhouse_engine.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module CognitiveGreenhouse
+      module Helpers
+        class GreenhouseEngine
+          include Constants
+
+          attr_reader :greenhouse
+
+          def initialize(greenhouse: nil)
+            @greenhouse = greenhouse || Greenhouse.new
+          end
+
+          def create_plant(plant_type:, domain:, content:, growth_stage: :seed, health: 0.5)
+            raise ArgumentError, "unknown plant_type: #{plant_type.inspect}" unless Constants::PLANT_TYPES.include?(plant_type)
+
+            Seedling.new(
+              plant_type:   plant_type,
+              domain:       domain,
+              content:      content,
+              growth_stage: growth_stage,
+              health:       health
+            )
+          end
+
+          def plant_in_greenhouse(plant_type:, domain:, content:, growth_stage: :seed, health: 0.5, **)
+            seedling = create_plant(
+              plant_type:   plant_type,
+              domain:       domain,
+              content:      content,
+              growth_stage: growth_stage,
+              health:       health
+            )
+            result = @greenhouse.plant!(seedling)
+            result.merge(seedling: seedling.to_h)
+          end
+
+          def grow_all!
+            conditions = current_conditions
+            rate       = Constants::GROWTH_RATE.fetch(@greenhouse.season, 1.0)
+            grew_count = 0
+            results    = []
+
+            @greenhouse.plants.each do |plant|
+              result = plant.grow!(conditions.merge(rate: rate))
+              results << result.merge(id: plant.id)
+              grew_count += 1 if result[:grew]
+            end
+
+            { grew: grew_count, total: @greenhouse.plants.size, results: results, season: @greenhouse.season }
+          end
+
+          def adjust_environment(temperature: nil, humidity: nil, light_level: nil, **)
+            @greenhouse.adjust_conditions(
+              temperature: temperature,
+              humidity:    humidity,
+              light_level: light_level
+            )
+          end
+
+          def cycle_season
+            result = @greenhouse.cycle_season!
+
+            # Apply seasonal light/temp shifts automatically
+            case result[:season]
+            when :spring
+              @greenhouse.adjust_conditions(temperature: 20.0, humidity: 0.70, light_level: 0.75)
+            when :summer
+              @greenhouse.adjust_conditions(temperature: 26.0, humidity: 0.60, light_level: 0.90)
+            when :autumn
+              @greenhouse.adjust_conditions(temperature: 16.0, humidity: 0.65, light_level: 0.65)
+            when :winter
+              @greenhouse.adjust_conditions(temperature: 10.0, humidity: 0.55, light_level: 0.45)
+            end
+
+            result.merge(conditions: @greenhouse.condition_snapshot)
+          end
+
+          def harvest
+            blooms = @greenhouse.harvest_blooms
+            { harvested: blooms.size, blooms: blooms }
+          end
+
+          def greenhouse_report
+            plants_by_stage = Constants::GROWTH_STAGES.to_h do |stage|
+              [stage, @greenhouse.plants.count { |p| p.growth_stage == stage }]
+            end
+
+            healthy_count = @greenhouse.plants.count(&:healthy?)
+            wilting_count = @greenhouse.plants.count(&:wilting?)
+
+            {
+              total_plants:    @greenhouse.plants.size,
+              plants_by_stage: plants_by_stage,
+              healthy:         healthy_count,
+              wilting:         wilting_count,
+              conditions:      @greenhouse.condition_snapshot,
+              cycles:          @greenhouse.cycles_completed
+            }
+          end
+
+          private
+
+          def current_conditions
+            {
+              temperature: @greenhouse.temperature,
+              humidity:    @greenhouse.humidity,
+              light_level: @greenhouse.light_level
+            }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/cognitive_greenhouse/helpers/seedling.rb

@@ -0,0 +1,151 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+
+module Legion
+  module Extensions
+    module CognitiveGreenhouse
+      module Helpers
+        class Seedling
+          include Constants
+
+          STAGE_INDEX = Constants::GROWTH_STAGES.each_with_index.to_h.freeze
+
+          attr_reader :id, :plant_type, :domain, :content, :growth_stage, :health,
+                      :root_depth, :planted_at, :last_tended
+
+          def initialize(plant_type:, domain:, content:, growth_stage: :seed, health: 0.5, root_depth: 0.0)
+            raise ArgumentError, "unknown plant_type: #{plant_type.inspect}" unless Constants::PLANT_TYPES.include?(plant_type)
+            raise ArgumentError, "unknown growth_stage: #{growth_stage.inspect}" unless Constants::GROWTH_STAGES.include?(growth_stage)
+
+            @id           = SecureRandom.uuid
+            @plant_type   = plant_type
+            @domain       = domain
+            @content      = content
+            @growth_stage = growth_stage
+            @health       = health.clamp(0.0, 1.0)
+            @root_depth   = root_depth.clamp(0.0, 1.0)
+            @planted_at   = Time.now.utc
+            @last_tended  = Time.now.utc
+          end
+
+          def grow!(conditions = {})
+            quality = environment_quality(conditions)
+            return { grew: false, reason: :poor_environment, quality: quality.round(10) } if quality < Constants::MIN_QUALITY_FOR_GROWTH
+
+            boost = (Constants::GROW_HEALTH_BOOST * quality).round(10)
+            @health = (@health + boost).clamp(0.0, 1.0)
+            @root_depth = (@root_depth + (boost * 0.5)).clamp(0.0, 1.0)
+            @last_tended = Time.now.utc
+
+            advanced = maybe_advance_stage!
+            {
+              grew:         true,
+              health:       @health.round(10),
+              root_depth:   @root_depth.round(10),
+              stage:        @growth_stage,
+              stage_change: advanced,
+              quality:      quality.round(10)
+            }
+          end
+
+          def wilt!(stress = 0.5)
+            drain = (Constants::WILT_HEALTH_DRAIN * stress.clamp(0.0, 1.0)).round(10)
+            @health = (@health - drain).clamp(0.0, 1.0)
+            @last_tended = Time.now.utc
+            { wilted: true, health: @health.round(10), stress: stress.clamp(0.0, 1.0).round(10) }
+          end
+
+          def bloom!
+            return { bloomed: false, reason: :not_mature } unless mature?
+
+            @growth_stage = :bloom
+            @health       = (@health + 0.10).clamp(0.0, 1.0)
+            @last_tended  = Time.now.utc
+            { bloomed: true, health: @health.round(10), id: @id }
+          end
+
+          def healthy?
+            @health >= 0.6
+          end
+
+          def wilting?
+            @health < 0.3
+          end
+
+          def mature?
+            @growth_stage == :mature
+          end
+
+          def to_h
+            {
+              id:           @id,
+              plant_type:   @plant_type,
+              domain:       @domain,
+              content:      @content,
+              growth_stage: @growth_stage,
+              health:       @health.round(10),
+              root_depth:   @root_depth.round(10),
+              planted_at:   @planted_at,
+              last_tended:  @last_tended
+            }
+          end
+
+          private
+
+          def environment_quality(conditions)
+            return 0.5 if conditions.empty?
+
+            temp_score = score_temperature(conditions.fetch(:temperature, 22.0))
+            humidity_score = score_humidity(conditions.fetch(:humidity, 0.65))
+            light_score = score_light(conditions.fetch(:light_level, 0.75))
+
+            (temp_score * Constants::CONDITION_WEIGHTS[:temperature]) +
+              (humidity_score * Constants::CONDITION_WEIGHTS[:humidity]) +
+              (light_score    * Constants::CONDITION_WEIGHTS[:light])
+          end
+
+          def score_temperature(value)
+            score_in_range(value, Constants::IDEAL_TEMPERATURE[0], Constants::IDEAL_TEMPERATURE[1], 0.0, 50.0)
+          end
+
+          def score_humidity(value)
+            score_in_range(value, Constants::IDEAL_HUMIDITY[0], Constants::IDEAL_HUMIDITY[1], 0.0, 1.0)
+          end
+
+          def score_light(value)
+            score_in_range(value, Constants::IDEAL_LIGHT[0], Constants::IDEAL_LIGHT[1], 0.0, 1.0)
+          end
+
+          def score_in_range(value, ideal_min, ideal_max, abs_min, abs_max)
+            return 1.0 if value.between?(ideal_min, ideal_max)
+
+            range_span = (abs_max - abs_min).to_f
+            return 0.0 if range_span.zero?
+
+            if value < ideal_min
+              distance = ideal_min - value
+              1.0 - (distance / (ideal_min - abs_min + 0.001)).clamp(0.0, 1.0)
+            else
+              distance = value - ideal_max
+              1.0 - (distance / (abs_max - ideal_max + 0.001)).clamp(0.0, 1.0)
+            end
+          end
+
+          def maybe_advance_stage!
+            return false if @growth_stage == :bloom
+            return false if @health < Constants::STAGE_ADVANCE_THRESHOLD
+
+            current_index = STAGE_INDEX[@growth_stage]
+            next_stage    = Constants::GROWTH_STAGES[current_index + 1]
+            return false unless next_stage
+            return false if next_stage == :bloom # bloom! is explicit
+
+            @growth_stage = next_stage
+            true
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module CognitiveGreenhouse
+      module Runners
+        module CognitiveGreenhouse
+          extend self
+
+          include Legion::Extensions::Helpers::Lex if defined?(Legion::Extensions::Helpers::Lex)
+
+          def plant_idea(plant_type:, domain:, content:, growth_stage: :seed, health: 0.5, engine: nil, **)
+            raise ArgumentError, "unknown plant_type: #{plant_type.inspect}" unless Helpers::Constants::PLANT_TYPES.include?(plant_type)
+
+            e = engine || default_engine
+            result = e.plant_in_greenhouse(
+              plant_type:   plant_type,
+              domain:       domain,
+              content:      content,
+              growth_stage: growth_stage,
+              health:       health
+            )
+
+            Legion::Logging.debug "[greenhouse] planted #{plant_type} in #{domain}: #{result[:seedling][:id][0..7]}" if defined?(Legion::Logging)
+            { success: result[:planted], result: result }
+          rescue ArgumentError => e
+            { success: false, error: e.message }
+          end
+
+          def tend_greenhouse(engine: nil, **)
+            e = engine || default_engine
+            result = e.grow_all!
+            Legion::Logging.debug "[greenhouse] grow_all: grew=#{result[:grew]} total=#{result[:total]} season=#{result[:season]}" if defined?(Legion::Logging)
+            { success: true, result: result }
+          rescue ArgumentError => e
+            { success: false, error: e.message }
+          end
+
+          def adjust_environment(temperature: nil, humidity: nil, light_level: nil, engine: nil, **)
+            e = engine || default_engine
+            result = e.adjust_environment(temperature: temperature, humidity: humidity, light_level: light_level)
+            Legion::Logging.debug "[greenhouse] conditions adjusted: quality=#{result[:quality]}" if defined?(Legion::Logging)
+            { success: true, result: result }
+          rescue ArgumentError => e
+            { success: false, error: e.message }
+          end
+
+          def advance_season(engine: nil, **)
+            e = engine || default_engine
+            result = e.cycle_season
+            Legion::Logging.debug "[greenhouse] season cycled to #{result[:season]}" if defined?(Legion::Logging)
+            { success: true, result: result }
+          rescue ArgumentError => e
+            { success: false, error: e.message }
+          end
+
+          def harvest_ideas(engine: nil, **)
+            e = engine || default_engine
+            result = e.harvest
+            Legion::Logging.debug "[greenhouse] harvested #{result[:harvested]} blooms" if defined?(Legion::Logging)
+            { success: true, result: result }
+          rescue ArgumentError => e
+            { success: false, error: e.message }
+          end
+
+          def greenhouse_status(engine: nil, **)
+            e = engine || default_engine
+            result = e.greenhouse_report
+            { success: true, result: result }
+          rescue ArgumentError => e
+            { success: false, error: e.message }
+          end
+
+          private
+
+          def default_engine
+            @default_engine ||= Helpers::GreenhouseEngine.new
+          end
+        end
+      end
+    end
+  end
+end

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

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

data/lib/legion/extensions/cognitive_greenhouse.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+require_relative 'cognitive_greenhouse/version'
+require_relative 'cognitive_greenhouse/helpers/constants'
+require_relative 'cognitive_greenhouse/helpers/seedling'
+require_relative 'cognitive_greenhouse/helpers/greenhouse'
+require_relative 'cognitive_greenhouse/helpers/greenhouse_engine'
+require_relative 'cognitive_greenhouse/runners/cognitive_greenhouse'
+require_relative 'cognitive_greenhouse/client'
+
+module Legion
+  module Extensions
+    module CognitiveGreenhouse
+      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-greenhouse
+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: Protected environment for growing ideas from seeds to mature concepts
+  — temperature, humidity, and light as nurturing conditions, with seasonal cycles
+email:
+- matthewdiverson@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".github/workflows/ci.yml"
+- ".gitignore"
+- ".rspec"
+- ".rubocop.yml"
+- CLAUDE.md
+- Gemfile
+- Gemfile.lock
+- README.md
+- lex-cognitive-greenhouse.gemspec
+- lib/legion/extensions/cognitive_greenhouse.rb
+- lib/legion/extensions/cognitive_greenhouse/client.rb
+- lib/legion/extensions/cognitive_greenhouse/helpers/constants.rb
+- lib/legion/extensions/cognitive_greenhouse/helpers/greenhouse.rb
+- lib/legion/extensions/cognitive_greenhouse/helpers/greenhouse_engine.rb
+- lib/legion/extensions/cognitive_greenhouse/helpers/seedling.rb
+- lib/legion/extensions/cognitive_greenhouse/runners/cognitive_greenhouse.rb
+- lib/legion/extensions/cognitive_greenhouse/version.rb
+homepage: https://github.com/LegionIO/lex-cognitive-greenhouse
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/LegionIO/lex-cognitive-greenhouse
+  source_code_uri: https://github.com/LegionIO/lex-cognitive-greenhouse
+  documentation_uri: https://github.com/LegionIO/lex-cognitive-greenhouse
+  changelog_uri: https://github.com/LegionIO/lex-cognitive-greenhouse
+  bug_tracker_uri: https://github.com/LegionIO/lex-cognitive-greenhouse/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 Greenhouse
+test_files: []