lex-synapse 0.4.11 → 0.4.12

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 712f9976e4ce62962405f83fd39b3bd2dfa2ea678bed7f183a246b80506f6623
-  data.tar.gz: 73c470450fd5d6800054c81441bc48bd603e12e161cc0e963a4306853de5fa5d
+  metadata.gz: 868277c8084e7cd4e50c660e65cf93d3bd3554c183f8c7852bddf7ae28ff91dd
+  data.tar.gz: c588730afaa91b1842f35eb3e20584445ebb6f62d2e1042831de6942f9b712e7
 SHA512:
-  metadata.gz: 6356f7f31a55ac536e5d7d3d2aa2923bae4e723c1f4f3be68adf83027d8916020d19a44d363e199af015c825c5ccf0eeeeee0126e33396623e95b4af5b1cf7eb
-  data.tar.gz: 0677dfdaa1c422b1db309036c2872d8b22473e376050a259ca16e8733d91cbfa720a18291b46c9119d28f6430b0d889cd5ab09ba83217fcca8dad3fcaa1f9b46
+  metadata.gz: 63aa10dd7948c59e7f3f603748a2bfa5bca217aad2dd99d05e898cdf9b102358c21f66b73d4eb258f81fed54b1c90dca23ce6569f942fa9db632fd269c564a8b
+  data.tar.gz: dc9a028d79dca386c03672a46237d1190c8001ee35c9704630ed9b8f310ba38322983176d02d178ab979b2695699cbd0178addb4f890d5fe03b498bce4c1008b

data/CHANGELOG.md

@@ -1,5 +1,11 @@
 # Changelog
 
+## [0.4.12] - 2026-05-07
+### Fixed
+- Added challenge proposal application through the mutate runner so auto-accepted proposals can advance to `applied` and later resolve challenger outcomes.
+- Averaged resolved LLM challenger confidence, auto-accepted all-abstain challenges, and ensured proactive proposals store a non-empty candidate output.
+- Look up target function schemas through extension discovery when building transform proposals.
+
 ## [0.4.11] - 2026-04-22
 ### Fixed
 - `handle_pain` now actually calls `revert` when consecutive failures reach threshold (was only setting a flag)

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

@@ -7,6 +7,7 @@ require_relative '../data/models/synapse_proposal'
 require_relative '../data/models/synapse_challenge'
 require_relative '../data/models/synapse_signal'
 require_relative 'blast_radius'
+require_relative 'mutate'
 
 module Legion
   module Extensions
@@ -87,10 +88,37 @@ module Legion
             { success: true, proposal_id: proposal_id, success_rate: success_rate, resolved: challenges.size }
           end
 
+          def apply_proposal(proposal_id:)
+            Data::Model.define_synapse_proposal_model
+            Data::Model.define_synapse_model
+
+            proposal = Data::Model::SynapseProposal[proposal_id]
+            return { success: false, error: 'proposal not found' } unless proposal
+            return { success: false, error: 'proposal not approved' } unless %w[approved auto_accepted].include?(proposal.status)
+            return { success: false, error: 'proposal output missing' } if proposal.output.nil? || proposal.output.to_s.strip.empty?
+
+            synapse = Data::Model::Synapse[proposal.synapse_id]
+            return { success: false, error: 'synapse not found' } unless synapse
+
+            mutation = mutation_for_proposal(proposal)
+            return { success: false, error: "unsupported proposal_type: #{proposal.proposal_type}" } unless mutation
+
+            result = Object.new.extend(Mutate).mutate(
+              synapse_id:    proposal.synapse_id,
+              mutation_type: mutation[:mutation_type],
+              changes:       mutation[:changes],
+              trigger:       'gaia'
+            )
+            return result unless result[:success]
+
+            proposal.update(status: 'applied', reviewed_at: Time.now)
+            result.merge(proposal_id: proposal.id, status: 'applied', decision: 'applied')
+          end
+
           def run_challenge_cycle(transformer_client: nil)
             Data::Model.define_synapse_proposal_model
             Data::Model.define_synapse_challenge_model
-            return { challenged: 0, resolved: 0 } unless Helpers::Challenge.enabled?
+            return { challenged: 0, applied: 0, resolved: 0 } unless Helpers::Challenge.enabled?
 
             settings = Helpers::Challenge.settings
             max = settings[:max_per_cycle] || 5
@@ -101,6 +129,12 @@ module Legion
               challenged += 1
             end
 
+            applied = 0
+            Data::Model::SynapseProposal.where(status: 'auto_accepted').order(Sequel.asc(:id)).limit(max).each do |proposal|
+              result = apply_proposal(proposal_id: proposal.id)
+              applied += 1 if result[:success]
+            end
+
             resolved = 0
             window = settings[:outcome_observation_window] || 50
             Data::Model.define_synapse_signal_model
@@ -118,11 +152,22 @@ module Legion
               resolved += 1
             end
 
-            { challenged: challenged, resolved: resolved }
+            { challenged: challenged, applied: applied, resolved: resolved }
           end
 
           private
 
+          def mutation_for_proposal(proposal)
+            case proposal.proposal_type
+            when 'llm_transform', 'transform_mutation'
+              { mutation_type: 'transform_adjusted', changes: { transform: proposal.output } }
+            when 'attention_mutation'
+              { mutation_type: 'attention_adjusted', changes: { attention: proposal.output } }
+            when 'route_change'
+              { mutation_type: 'route_changed', changes: { routing_strategy: proposal.output } }
+            end
+          end
+
           def conflict_check(proposal)
             conflicts = Data::Model::SynapseProposal.where(
               synapse_id:    proposal.synapse_id,
@@ -176,8 +221,8 @@ module Legion
                                                       .exclude(verdict: 'abstain').all
 
             if challenges.empty?
-              proposal.update(challenge_state: 'challenged', challenge_score: 0.5)
-              return { success: true, challenge_score: 0.5, decision: 'challenged' }
+              proposal.update(status: 'auto_accepted', challenge_state: 'challenged', challenge_score: 0.0)
+              return { success: true, challenge_score: 0.0, decision: 'auto_accepted' }
             end
 
             support_weight = challenges.select { |c| c.verdict == 'support' }.sum(&:challenger_confidence)
@@ -253,7 +298,7 @@ module Legion
                                                   .order(Sequel.desc(:id)).limit(20).all
             return Helpers::Challenge.settings[:challenger_starting_confidence] if recent.empty?
 
-            recent.first.challenger_confidence
+            recent.sum(&:challenger_confidence).to_f / recent.size
           end
 
           include Legion::Extensions::Helpers::Lex if defined?(Legion::Extensions::Helpers::Lex)

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

@@ -135,7 +135,7 @@ module Legion
               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,
+              output: proactive_transform_output(synapse, success_rate: rate.round(3), sample_size: signals.size),
               rationale: "success rate #{(rate * 100).round(1)}% below threshold #{(threshold * 100).round(1)}%"
             )
           end
@@ -156,7 +156,7 @@ module Legion
               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,
+              output: proactive_transform_output(synapse, drift_rate: drift_rate.round(3), sample_size: signals.size),
               rationale: "payload drift detected: #{(drift_rate * 100).round(1)}% transform failures in recent signals"
             )
           end
@@ -226,9 +226,25 @@ module Legion
 
           def lookup_target_schema(synapse)
             return {} unless synapse.target_function_id
-            return {} unless defined?(Legion::Extensions::Lex)
 
-            {}
+            discovery_schema(synapse.target_function_id) || {}
+          end
+
+          def discovery_schema(function_id)
+            discovery = defined?(Legion::Extensions::Discovery) && Legion::Extensions::Discovery
+            return unless discovery.respond_to?(:function_schema)
+
+            discovery.function_schema(function_id)
+          rescue StandardError => e
+            log.debug("lookup_target_schema failed for #{function_id}: #{e.message}")
+            nil
+          end
+
+          def proactive_transform_output(synapse, **metadata)
+            existing = synapse.transform.to_s.strip
+            return existing unless existing.empty?
+
+            Legion::JSON.dump(metadata.merge(action: 'review_transform', synapse_id: synapse.id))
           end
 
           def build_transform_prompt(source_schema, target_schema)

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

@@ -3,7 +3,7 @@
 module Legion
   module Extensions
     module Synapse
-      VERSION = '0.4.11'
+      VERSION = '0.4.12'
     end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lex-synapse
 version: !ruby/object:Gem::Version
-  version: 0.4.11
+  version: 0.4.12
 platform: ruby
 authors:
 - Esity