lex-synapse 0.2.3 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 15e9a0134efeddb2987af089e90c91d5f954524aa44c147ec5e11ae9eda9fd0f
-  data.tar.gz: b08d225fdd4d3db84155deb3a707dcc3f6f9ebfeb6e34cb1e71e057c1ef54801
+  metadata.gz: 60a95b064e889f6594f48ea66c0c12e8360b4679ef9daf572e31560e304ea277
+  data.tar.gz: a96ea18996d7b3d87ee309cbba68f2258b34f40fa9a0a61068562f81f347177d
 SHA512:
-  metadata.gz: c6a75eff3fff57732dd4c50f2e5d2f9b94fde785ae4b5f7a3d7eedb3937eb96983c5ef1bb4f85f55229b744e80a4c98f779e69fca4d6cec3ff1fb3568694533a
-  data.tar.gz: da3a2b72741ddc1ac70319e3c2693c77ab050bc5c4b6fd6cefee301ba12bdfe820667356634de93ef8c614ea4a56e1e54f5761cc47ba76d42c1e32ae0ccb0745
+  metadata.gz: 9faa202ea887493c0ab6b3b9df9323757ca00e1fca347b0669876241ef4733aa4f333c5153c8b0a46d59fd28d6ba5e5286f5e7d541dc47d21e65ea4a9b6f554a
+  data.tar.gz: 85411a3ec047e7d9e944b61d08c03ab3ee3868f58887b6e13c3e6ab46d1fcad3ef5a56ddf73d12cc8a32a77b4d1c2d34386caa9d2711950c464a818229fdb495

data/CHANGELOG.md

@@ -1,5 +1,25 @@
 # Changelog
 
+## [0.3.0] - 2026-03-19
+
+### Added
+- Autonomous observation mode: proposal engine for AUTONOMOUS tier (confidence 0.8+)
+- `synapse_proposals` table with migration 004
+- `Runners::Propose` with reactive proposals (no-template, transform failure, pain correlation)
+- `Runners::Propose` with proactive analysis (success rate degradation, payload drift)
+- `Actors::Propose` periodic actor for proactive analysis (every 300s)
+- `Helpers::Proposals` settings helper with configurable thresholds
+- Proposal hook in `Runners::Evaluate` for autonomous synapses (gated by settings)
+- Client `proposals(synapse_id:, status:)` query method
+- Client `review_proposal(proposal_id:, status:)` for approving/rejecting proposals
+- LLM-backed proposal generation via lex-transformer LLM engine
+- Proposal deduplication within configurable window
+- Integration specs for full proposal workflow
+- Settings: `lex-synapse.proposals.*` for master switch, reactive/proactive toggles, max_per_run, LLM engine options, thresholds
+
+### Changed
+- `lex-transformer` dependency bumped to >= 0.3.0 (requires LLM engine with engine_options)
+
 ## [0.2.3] - 2026-03-19
 
 ### Fixed

data/CLAUDE.md

@@ -10,7 +10,7 @@ Cognitive routing layer that wraps task chain relationships with observation, le
 
 **GitHub**: https://github.com/LegionIO/lex-synapse
 **License**: MIT
-**Version**: 0.2.2
+**Version**: 0.3.0
 
 ## Architecture
 
@@ -21,7 +21,8 @@ Legion::Extensions::Synapse
 │   ├── Pain            # Subscription — task.failed handler
 │   ├── Crystallize     # Every 300s — emergent synapse detection
 │   ├── Homeostasis     # Every 30s — spike/drought monitoring
-│   └── Decay           # Every 3600s — idle confidence decay
+│   ├── Decay           # Every 3600s — idle confidence decay
+│   └── Propose          # Every 300s — proactive proposal analysis for AUTONOMOUS synapses
 ├── Runners/
 │   ├── Evaluate        # attention -> transform -> route -> record
 │   ├── Pain            # failure recording, confidence hit, auto-revert
@@ -32,7 +33,8 @@ Legion::Extensions::Synapse
 │   ├── Dream           # replay historical signals in simulation mode; replay/simulate
 │   ├── GaiaReport      # GAIA tick hook: report confidence and health per synapse
 │   ├── Promote         # Apollo integration: promote high-confidence synapse patterns to shared knowledge
-│   └── Retrieve        # Apollo integration: retrieve relevant synapse patterns from shared knowledge
+│   ├── Retrieve        # Apollo integration: retrieve relevant synapse patterns from shared knowledge
+│   └── Propose         # reactive (signal-driven) + proactive (periodic) proposal generation
 ├── Helpers/
 │   ├── Confidence      # scoring, adjustments, autonomy ranges, decay
 │   ├── Homeostasis     # spike/drought detection, baseline tracking
@@ -79,6 +81,16 @@ Legion::Extensions::Synapse
 - **synapse_mutations**: Versioned change history with before/after JSON snapshots
 - **synapse_signals**: Per-signal outcome records (attention pass, transform success, latency, downstream outcome)
 
+## Autonomous Observation Mode (v0.3.0)
+
+- **Proposal engine**: AUTONOMOUS tier (confidence 0.8+) generates proposals instead of executing autonomous actions
+- **Reactive proposals**: on signal evaluation — no-template inference, transform failure fix, attention pain correlation
+- **Proactive proposals**: periodic analysis — success rate degradation, payload drift detection
+- **LLM-backed**: proposals call lex-transformer LLM engine for real output generation
+- **Settings**: `lex-synapse.proposals.*` — enabled, reactive, proactive, max_per_run, llm_engine_options, thresholds
+- **Data**: `synapse_proposals` table with status lifecycle (pending -> approved/rejected/applied/expired)
+- **Client methods**: `proposals(synapse_id:, status:)`, `review_proposal(proposal_id:, status:)`
+
 ## GAIA / Apollo Integration (v0.2.2)
 
 - **GaiaReport runner**: Called during the GAIA tick cycle to report per-synapse confidence and health metrics.
@@ -91,18 +103,18 @@ Legion::Extensions::Synapse
 | Gem | Purpose |
 |-----|---------|
 | `lex-conditioner` >= 0.3.0 | Attention evaluation (condition rules) |
-| `lex-transformer` >= 0.2.0 | Payload transformation (template engines) |
+| `lex-transformer` >= 0.3.0 | Payload transformation (template engines) |
 | `legion-data` | Required — database persistence via Sequel |
 
 ## Testing
 
 ```bash
 bundle install
-bundle exec rspec     # 308 specs, 0 failures
+bundle exec rspec     # 366 specs, 0 failures
 bundle exec rubocop   # 0 offenses
 ```
 
-308 specs, 96%+ coverage. Uses in-memory SQLite for model/runner tests.
+366 specs, 95%+ coverage. Uses in-memory SQLite for model/runner tests.
 
 ---
 

data/lex-synapse.gemspec

@@ -27,5 +27,5 @@ Gem::Specification.new do |spec|
   spec.require_paths = ['lib']
 
   spec.add_dependency 'lex-conditioner', '>= 0.3.0'
-  spec.add_dependency 'lex-transformer', '>= 0.2.0'
+  spec.add_dependency 'lex-transformer', '>= 0.3.0'
 end

data/lib/legion/extensions/synapse/actors/propose.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Synapse
+      module Actor
+        class Propose < Legion::Extensions::Actors::Every
+          def runner_function
+            'propose_proactive'
+          end
+
+          def time
+            300
+          end
+
+          def use_runner?
+            false
+          end
+
+          def check_subtask?
+            false
+          end
+
+          def generate_task?
+            false
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -10,6 +10,9 @@ require_relative 'runners/gaia_report'
 require_relative 'runners/dream'
 require_relative 'runners/promote'
 require_relative 'runners/retrieve'
+require_relative 'runners/propose'
+require_relative 'data/models/synapse_proposal'
+require_relative 'helpers/proposals'
 
 module Legion
   module Extensions
@@ -25,6 +28,7 @@ module Legion
         include Runners::Dream
         include Runners::Promote
         include Runners::Retrieve
+        include Runners::Propose
 
         attr_reader :conditioner_client, :transformer_client
 
@@ -57,6 +61,24 @@ module Legion
             status:             origin == 'emergent' ? 'observing' : 'active'
           )
         end
+
+        def proposals(synapse_id:, status: nil)
+          Data::Model.define_synapse_proposal_model
+          dataset = Data::Model::SynapseProposal.where(synapse_id: synapse_id)
+          dataset = dataset.where(status: status) if status
+          dataset.order(Sequel.desc(:id)).all
+        end
+
+        def review_proposal(proposal_id:, status:)
+          Data::Model.define_synapse_proposal_model
+          return { success: false, error: "invalid status: #{status}" } unless Helpers::Proposals::VALID_STATUSES.include?(status)
+
+          proposal = Data::Model::SynapseProposal[proposal_id]
+          return { success: false, error: 'proposal not found' } unless proposal
+
+          proposal.update(status: status, reviewed_at: Time.now)
+          { success: true, proposal_id: proposal_id, status: status }
+        end
       end
     end
   end

data/lib/legion/extensions/synapse/data/migrations/004_create_synapse_proposals.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+Sequel.migration do
+  up do
+    create_table(:synapse_proposals) do
+      primary_key :id
+      foreign_key :synapse_id, :synapses, null: false, index: true
+      Integer    :signal_id
+      String     :proposal_type, null: false, size: 50
+      String     :trigger, null: false, size: 50
+      String     :inputs, text: true
+      String     :output, text: true
+      String     :rationale, text: true
+      String     :status, default: 'pending', size: 50
+      Float      :estimated_confidence_impact
+      DateTime   :created_at, null: false, default: Sequel::CURRENT_TIMESTAMP
+      DateTime   :reviewed_at
+    end
+  end
+
+  down do
+    drop_table :synapse_proposals
+  end
+end

data/lib/legion/extensions/synapse/data/models/synapse.rb

@@ -17,6 +17,8 @@ module Legion
                                       key:   :synapse_id
               one_to_many :signals,   class: 'Legion::Extensions::Synapse::Data::Model::SynapseSignal',
                                       key:   :synapse_id
+              one_to_many :proposals, class: 'Legion::Extensions::Synapse::Data::Model::SynapseProposal',
+                                      key:   :synapse_id
             end
             klass.set_primary_key :id
             const_set(:Synapse, klass)

data/lib/legion/extensions/synapse/data/models/synapse_proposal.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Synapse
+      module Data
+        module Model
+          def self.define_synapse_proposal_model
+            return if const_defined?(:SynapseProposal, false)
+            return unless defined?(Legion::Data) && Legion::Settings.dig(:data, :connected)
+
+            db = Sequel::Model.db
+            return unless db&.table_exists?(:synapse_proposals)
+
+            klass = Class.new(Sequel::Model(:synapse_proposals)) do
+              many_to_one :synapse, class: 'Legion::Extensions::Synapse::Data::Model::Synapse',
+                                    key:   :synapse_id
+            end
+            klass.set_primary_key :id
+            const_set(:SynapseProposal, klass)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/synapse/helpers/proposals.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Synapse
+      module Helpers
+        module Proposals
+          VALID_PROPOSAL_TYPES = %w[llm_transform attention_mutation transform_mutation route_change].freeze
+          VALID_TRIGGERS = %w[reactive proactive].freeze
+          VALID_STATUSES = %w[pending approved rejected applied expired].freeze
+
+          DEFAULT_SETTINGS = {
+            enabled:                 true,
+            reactive:                true,
+            proactive:               true,
+            proactive_interval:      300,
+            max_per_run:             3,
+            llm_engine_options:      { temperature: 0.3, max_tokens: 1024 },
+            success_rate_threshold:  0.8,
+            payload_drift_threshold: 0.2,
+            dedup_window_hours:      24
+          }.freeze
+
+          class << self
+            def settings
+              raw = Legion::Settings.dig('lex-synapse', 'proposals')
+              return DEFAULT_SETTINGS.dup unless raw.is_a?(Hash)
+
+              merged = DEFAULT_SETTINGS.dup
+              raw.each { |k, v| merged[k.to_sym] = v unless v.nil? }
+              merged
+            end
+
+            def enabled?
+              settings[:enabled] == true
+            end
+
+            def reactive?
+              s = settings
+              s[:enabled] == true && s[:reactive] == true
+            end
+
+            def proactive?
+              s = settings
+              s[:enabled] == true && s[:proactive] == true
+            end
+
+            def llm_engine_options
+              s = settings
+              opts = s[:llm_engine_options]
+              opts.is_a?(Hash) ? opts.transform_keys(&:to_sym) : DEFAULT_SETTINGS[:llm_engine_options].dup
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/synapse/runners/evaluate.rb

@@ -1,18 +1,23 @@
 # frozen_string_literal: true
 
 require_relative '../helpers/confidence'
+require_relative '../helpers/proposals'
 require_relative '../data/models/synapse'
 require_relative '../data/models/synapse_mutation'
 require_relative '../data/models/synapse_signal'
+require_relative 'propose'
 
 module Legion
   module Extensions
     module Synapse
       module Runners
         module Evaluate
+          include Propose
+
           def evaluate(synapse_id:, payload: {}, conditioner_client: nil, transformer_client: nil)
             Data::Model.define_synapse_model
             Data::Model.define_synapse_signal_model
+            Data::Model.define_synapse_proposal_model
             synapse = Data::Model::Synapse[synapse_id]
             return { success: false, error: 'synapse not found' } unless synapse
             return { success: false, error: 'synapse not active' } unless Helpers::Confidence::EVALUABLE_STATUSES.include?(synapse.status)
@@ -40,6 +45,16 @@ module Legion
             new_confidence = Helpers::Confidence.adjust(synapse.confidence, event)
             synapse.update(confidence: new_confidence)
 
+            # Step 5: Generate proposals if autonomous
+            if Helpers::Confidence.can_self_modify?(new_confidence) && Helpers::Proposals.reactive?
+              signal_record = Data::Model::SynapseSignal.where(synapse_id: synapse.id).order(Sequel.desc(:id)).first
+              propose_reactive(
+                synapse: synapse, payload: payload, signal_id: signal_record&.id,
+                attention_result: attention_result, transform_result: transform_result,
+                transformer_client: transformer_client
+              )
+            end
+
             {
               success:     transform_result[:success],
               mode:        mode,

data/lib/legion/extensions/synapse/runners/propose.rb

@@ -0,0 +1,253 @@
+# frozen_string_literal: true
+
+require_relative '../helpers/confidence'
+require_relative '../helpers/proposals'
+require_relative '../data/models/synapse'
+require_relative '../data/models/synapse_signal'
+require_relative '../data/models/synapse_proposal'
+
+module Legion
+  module Extensions
+    module Synapse
+      module Runners
+        module Propose
+          PAIN_CORRELATION_THRESHOLD = 3
+
+          def propose_reactive(synapse:, payload:, signal_id:, attention_result:, transform_result:,
+                               transformer_client: nil)
+            Data::Model.define_synapse_proposal_model
+            return { proposals: [] } unless Helpers::Proposals.reactive?
+            return { proposals: [] } unless transformer_client
+
+            proposals = []
+
+            # Trigger 1: No transform template exists
+            proposals << propose_llm_transform(synapse, payload, signal_id, transformer_client) if synapse.transform.nil? || synapse.transform.to_s.strip.empty?
+
+            # Trigger 2: Transform failed
+            if transform_result[:success] == false && synapse.transform && !synapse.transform.to_s.strip.empty?
+              proposals << propose_transform_fix(synapse, payload, signal_id, transform_result, transformer_client)
+            end
+
+            # Trigger 3: Pain correlation — attention passed but recent downstream failures
+            proposals << propose_attention_adjustment(synapse, payload, signal_id, transformer_client) if attention_result[:passed] && pain_pattern?(synapse)
+
+            { proposals: proposals.compact }
+          end
+
+          def propose_proactive
+            Data::Model.define_synapse_model
+            Data::Model.define_synapse_proposal_model
+            Data::Model.define_synapse_signal_model
+            return { proposals: [] } unless Helpers::Proposals.proactive?
+
+            settings = Helpers::Proposals.settings
+            max_per_run = settings[:max_per_run] || 3
+            all_proposals = []
+
+            Data::Model::Synapse.where(status: 'active').all.each do |synapse|
+              next unless Helpers::Confidence.can_self_modify?(synapse.confidence)
+
+              count = 0
+              proposal = analyze_success_rate(synapse, settings)
+              if proposal
+                all_proposals << proposal
+                count += 1
+              end
+
+              if count < max_per_run
+                proposal = analyze_payload_drift(synapse, settings)
+                if proposal
+                  all_proposals << proposal
+                  count += 1
+                end
+              end
+
+              if count < max_per_run
+                proposal = analyze_routing(synapse)
+                all_proposals << proposal if proposal
+              end
+            end
+
+            { proposals: all_proposals }
+          end
+
+          private
+
+          def propose_llm_transform(synapse, payload, signal_id, transformer_client)
+            source_schema = infer_schema(payload)
+            target_schema = lookup_target_schema(synapse)
+            prompt = build_transform_prompt(source_schema, target_schema)
+
+            llm_result = call_llm(transformer_client, prompt)
+            create_proposal(
+              synapse: synapse, signal_id: signal_id, proposal_type: 'llm_transform',
+              trigger: 'reactive',
+              inputs: Legion::JSON.dump({ source_schema: source_schema, target_schema: target_schema }),
+              output: llm_result[:output],
+              rationale: 'no transform template exists for this synapse'
+            )
+          end
+
+          def propose_transform_fix(synapse, payload, signal_id, transform_result, transformer_client)
+            source_schema = infer_schema(payload)
+            current_transform = synapse.transform
+            errors = transform_result[:error]
+            prompt = build_fix_prompt(current_transform, source_schema, errors)
+
+            llm_result = call_llm(transformer_client, prompt)
+            create_proposal(
+              synapse: synapse, signal_id: signal_id, proposal_type: 'transform_mutation',
+              trigger: 'reactive',
+              inputs: Legion::JSON.dump({ current_transform: current_transform, errors: errors, payload_schema: source_schema }),
+              output: llm_result[:output],
+              rationale: "transform failed: #{Array(errors).first}"
+            )
+          end
+
+          def propose_attention_adjustment(synapse, payload, signal_id, transformer_client)
+            recent_failures = recent_failed_signals(synapse, 10)
+            prompt = build_attention_prompt(synapse.attention, payload, recent_failures)
+
+            llm_result = call_llm(transformer_client, prompt)
+            create_proposal(
+              synapse: synapse, signal_id: signal_id, proposal_type: 'attention_mutation',
+              trigger: 'reactive',
+              inputs: Legion::JSON.dump({ current_attention: synapse.attention, recent_failures: recent_failures.size }),
+              output: llm_result[:output],
+              rationale: "#{recent_failures.size} recent downstream failures despite attention passing"
+            )
+          end
+
+          def analyze_success_rate(synapse, settings)
+            threshold = settings[:success_rate_threshold] || 0.8
+            signals = Data::Model::SynapseSignal.where(synapse_id: synapse.id).order(Sequel.desc(:id)).limit(100).all
+            return nil if signals.size < 10
+
+            success_count = signals.count(&:transform_success)
+            rate = success_count.to_f / signals.size
+            return nil if rate >= threshold
+            return nil if dedup_exists?(synapse.id, 'transform_mutation', 'proactive', settings)
+
+            create_proposal(
+              synapse: synapse, signal_id: nil, proposal_type: 'transform_mutation',
+              trigger: 'proactive',
+              inputs: Legion::JSON.dump({ success_rate: rate.round(3), sample_size: signals.size, threshold: threshold }),
+              output: nil,
+              rationale: "success rate #{(rate * 100).round(1)}% below threshold #{(threshold * 100).round(1)}%"
+            )
+          end
+
+          def analyze_payload_drift(synapse, settings)
+            return nil if synapse.transform.nil? || synapse.transform.to_s.strip.empty?
+
+            drift_threshold = settings[:payload_drift_threshold] || 0.2
+            signals = Data::Model::SynapseSignal.where(synapse_id: synapse.id).order(Sequel.desc(:id)).limit(50).all
+            return nil if signals.size < 10
+
+            failed = signals.count { |s| !s.transform_success }
+            drift_rate = failed.to_f / signals.size
+            return nil if drift_rate < drift_threshold
+            return nil if dedup_exists?(synapse.id, 'transform_mutation', 'proactive', settings)
+
+            create_proposal(
+              synapse: synapse, signal_id: nil, proposal_type: 'transform_mutation',
+              trigger: 'proactive',
+              inputs: Legion::JSON.dump({ drift_rate: drift_rate.round(3), sample_size: signals.size }),
+              output: nil,
+              rationale: "payload drift detected: #{(drift_rate * 100).round(1)}% transform failures in recent signals"
+            )
+          end
+
+          def analyze_routing(synapse)
+            return nil if dedup_exists?(synapse.id, 'route_change', 'proactive', Helpers::Proposals.settings)
+
+            signals = Data::Model::SynapseSignal.where(synapse_id: synapse.id).order(Sequel.desc(:id)).limit(50).all
+            return nil if signals.size < 10
+
+            nil
+          end
+
+          def pain_pattern?(synapse)
+            recent = recent_failed_signals(synapse, 20)
+            recent.size >= PAIN_CORRELATION_THRESHOLD
+          end
+
+          def recent_failed_signals(synapse, limit)
+            Data::Model::SynapseSignal.where(
+              synapse_id: synapse.id, downstream_outcome: 'failed'
+            ).order(Sequel.desc(:id)).limit(limit).all
+          end
+
+          def dedup_exists?(synapse_id, proposal_type, trigger, settings)
+            window = settings[:dedup_window_hours] || 24
+            cutoff = Time.now - (window * 3600)
+            Data::Model::SynapseProposal.where(
+              synapse_id: synapse_id, proposal_type: proposal_type,
+              trigger: trigger, status: 'pending'
+            ).where(Sequel.lit('created_at >= ?', cutoff)).any?
+          end
+
+          def create_proposal(synapse:, signal_id:, proposal_type:, trigger:, inputs:, output:, rationale:)
+            Data::Model::SynapseProposal.create(
+              synapse_id:    synapse.id,
+              signal_id:     signal_id,
+              proposal_type: proposal_type,
+              trigger:       trigger,
+              inputs:        inputs,
+              output:        output,
+              rationale:     rationale,
+              status:        'pending'
+            )
+          end
+
+          def call_llm(transformer_client, prompt)
+            return { output: nil } unless transformer_client
+
+            engine_options = Helpers::Proposals.llm_engine_options
+            result = transformer_client.transform(
+              transformation: prompt, payload: {}, engine: :llm, engine_options: engine_options
+            )
+            { output: result[:success] ? Legion::JSON.dump(result[:result]) : nil }
+          rescue StandardError => e
+            Legion::Logging.warn("Proposal LLM call failed: #{e.message}")
+            { output: nil }
+          end
+
+          def infer_schema(payload)
+            return {} unless payload.is_a?(Hash)
+
+            payload.transform_values { |v| v.class.name }
+          end
+
+          def lookup_target_schema(synapse)
+            return {} unless synapse.target_function_id
+            return {} unless defined?(Legion::Extensions::Lex)
+
+            {}
+          end
+
+          def build_transform_prompt(source_schema, target_schema)
+            "Given a payload with schema: #{Legion::JSON.dump(source_schema)}, " \
+              "generate a JSON transform template that maps it to target schema: #{Legion::JSON.dump(target_schema)}. " \
+              'Return only the JSON template string, no explanation.'
+          end
+
+          def build_fix_prompt(current_transform, source_schema, errors)
+            "The current transform template is: #{current_transform}. " \
+              "It failed with errors: #{Array(errors).join(', ')}. " \
+              "The payload schema is: #{Legion::JSON.dump(source_schema)}. " \
+              'Suggest a corrected transform template. Return only the JSON template string.'
+          end
+
+          def build_attention_prompt(current_attention, payload, recent_failures)
+            "The current attention rules are: #{current_attention}. " \
+              "Recent payload example: #{Legion::JSON.dump(payload)}. " \
+              "There have been #{recent_failures.size} downstream failures despite attention passing. " \
+              'Suggest refined attention rules as a JSON condition object. Return only JSON.'
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -3,7 +3,7 @@
 module Legion
   module Extensions
     module Synapse
-      VERSION = '0.2.3'
+      VERSION = '0.3.0'
     end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lex-synapse
 version: !ruby/object:Gem::Version
-  version: 0.2.3
+  version: 0.3.0
 platform: ruby
 authors:
 - Esity
@@ -29,14 +29,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.2.0
+        version: 0.3.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.2.0
+        version: 0.3.0
 description: Attention, transformation, and routing with confidence scoring, pain
   signals, homeostasis, and self-governance
 email:
@@ -61,15 +61,19 @@ files:
 - lib/legion/extensions/synapse/actors/evaluate.rb
 - lib/legion/extensions/synapse/actors/homeostasis.rb
 - lib/legion/extensions/synapse/actors/pain.rb
+- lib/legion/extensions/synapse/actors/propose.rb
 - lib/legion/extensions/synapse/client.rb
 - lib/legion/extensions/synapse/data/migrations/001_create_synapses.rb
 - lib/legion/extensions/synapse/data/migrations/002_create_synapse_mutations.rb
 - lib/legion/extensions/synapse/data/migrations/003_create_synapse_signals.rb
+- lib/legion/extensions/synapse/data/migrations/004_create_synapse_proposals.rb
 - lib/legion/extensions/synapse/data/models/synapse.rb
 - lib/legion/extensions/synapse/data/models/synapse_mutation.rb
+- lib/legion/extensions/synapse/data/models/synapse_proposal.rb
 - lib/legion/extensions/synapse/data/models/synapse_signal.rb
 - lib/legion/extensions/synapse/helpers/confidence.rb
 - lib/legion/extensions/synapse/helpers/homeostasis.rb
+- lib/legion/extensions/synapse/helpers/proposals.rb
 - lib/legion/extensions/synapse/helpers/relationship_wrapper.rb
 - lib/legion/extensions/synapse/runners/crystallize.rb
 - lib/legion/extensions/synapse/runners/dream.rb
@@ -78,6 +82,7 @@ files:
 - lib/legion/extensions/synapse/runners/mutate.rb
 - lib/legion/extensions/synapse/runners/pain.rb
 - lib/legion/extensions/synapse/runners/promote.rb
+- lib/legion/extensions/synapse/runners/propose.rb
 - lib/legion/extensions/synapse/runners/report.rb
 - lib/legion/extensions/synapse/runners/retrieve.rb
 - lib/legion/extensions/synapse/runners/revert.rb