lex-synapse 0.3.2 → 0.4.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4373abd3a8ec4e508cd8d276b77fc185b667c51e7a54f389313c8b2aa3f353c4
-  data.tar.gz: 97df6f4f7fbef9db59155ef5aeea11636ad0c58fb82bc30a38c1f71207db39bf
+  metadata.gz: 4a9d8a3b5e13c6470c2170ca639e04e1fc8aedc0d596ff709ec9324334374e51
+  data.tar.gz: ecc92ce72c7ec61129495e1b290dbfb1e5df7353c6ce8b9a9ef974f146fbfa9f
 SHA512:
-  metadata.gz: e36c0ef72aa48a0315c12868ec48602ca0b91adf46c842e75da5279799daaefb49b4c80bf2d28f6af8c4ef8b6db334d491e98bf33c9877f32809bafdf0b97c56
-  data.tar.gz: 8570e52cee80e41d5dfc0a1c2de4a642210c471d8a4f59386e87d687815804fc22e7d73c8de1d43c31a58263876d8f44f3e3515c12e4861b6dfd1447d4414eec
+  metadata.gz: bf1e6f5ffe926a283d8e5278cc12546e57e3183b8893604c7b20ca81a57e2b5b571b28ce6448370e4e24576ff62dc55916a5080fd864e67e3814951f93b5ed69
+  data.tar.gz: 7995dee982eda776e8f847ba73202131a5c5fb01f0198193ef9dd5f3bed7d45677be196a76a65b19d4518bd3f41265ddb5622c587cced160cd94164d59771793

data/CHANGELOG.md

@@ -1,5 +1,24 @@
 # Changelog
 
+## [0.4.1] - 2026-03-22
+
+### Fixed
+- Challenge and Propose actors now include their runner modules and override `runner_class` to return `self.class`, fixing `NoMethodError: undefined method 'run_challenge_cycle'` at runtime
+
+## [0.4.0] - 2026-03-22
+
+### Added
+- Adversarial challenge phase for proposals: conflict detection, LLM challenge, weighted aggregation
+- `synapse_challenges` table (migration 005) for per-challenge verdict tracking
+- `Runners::Challenge` with challenge_proposal, resolve_challenge_outcomes, run_challenge_cycle
+- `Helpers::Challenge` with settings, constants, impact threshold helpers
+- `Actors::Challenge` polling every 60s for pending proposals
+- Challenger confidence tracking with outcome-based learning loop
+- Auto-accept/auto-reject thresholds for unanimous verdicts
+- Client methods: challenge_proposal, challenges, challenger_stats
+- New proposal statuses: auto_accepted, auto_rejected
+- Impact scoring gates LLM challenge (expensive calls only for high-impact proposals)
+
 ## [0.3.2] - 2026-03-21
 
 ### 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.3.0
+**Version**: 0.4.0
 
 ## Architecture
 
@@ -22,7 +22,8 @@ Legion::Extensions::Synapse
 │   ├── Crystallize     # Every 300s — emergent synapse detection
 │   ├── Homeostasis     # Every 30s — spike/drought monitoring
 │   ├── Decay           # Every 3600s — idle confidence decay
-│   └── Propose          # Every 300s — proactive proposal analysis for AUTONOMOUS synapses
+│   ├── Propose          # Every 300s — proactive proposal analysis for AUTONOMOUS synapses
+│   └── Challenge        # Every 60s — adversarial challenge pipeline for pending proposals
 ├── Runners/
 │   ├── Evaluate        # attention -> transform -> route -> record
 │   ├── Pain            # failure recording, confidence hit, auto-revert
@@ -34,14 +35,16 @@ Legion::Extensions::Synapse
 │   ├── 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
-│   └── Propose         # reactive (signal-driven) + proactive (periodic) proposal generation
+│   ├── Propose         # reactive (signal-driven) + proactive (periodic) proposal generation
+│   └── Challenge       # conflict detection, LLM challenge, weighted aggregation, outcome resolution
 ├── Helpers/
 │   ├── Confidence      # scoring, adjustments, autonomy ranges, decay
 │   ├── Homeostasis     # spike/drought detection, baseline tracking
-│   └── RelationshipWrapper  # Layer 1 -> Layer 2 wrapping
+│   ├── RelationshipWrapper  # Layer 1 -> Layer 2 wrapping
+│   └── Challenge       # settings, constants, impact threshold helpers
 ├── Data/
-│   ├── Migrations/     # 001 synapses, 002 mutations, 003 signals
-│   └── Models/         # Synapse, SynapseMutation, SynapseSignal
+│   ├── Migrations/     # 001 synapses, 002 mutations, 003 signals, 004 proposals, 005 challenges
+│   └── Models/         # Synapse, SynapseMutation, SynapseSignal, SynapseProposal, SynapseChallenge
 ├── Transport/
 │   ├── Exchanges/Synapse
 │   ├── Queues/Evaluate, Pain
@@ -80,6 +83,8 @@ Legion::Extensions::Synapse
 - **synapses**: Core routing definition with confidence, status, version, baseline_throughput
 - **synapse_mutations**: Versioned change history with before/after JSON snapshots
 - **synapse_signals**: Per-signal outcome records (attention pass, transform success, latency, downstream outcome)
+- **synapse_proposals**: Proposed changes with status lifecycle, challenge_state, challenge_score, impact_score
+- **synapse_challenges**: Per-challenge verdicts (conflict/LLM), confidence tracking, outcome resolution
 
 ## Autonomous Observation Mode (v0.3.0)
 
@@ -91,6 +96,18 @@ Legion::Extensions::Synapse
 - **Data**: `synapse_proposals` table with status lifecycle (pending -> approved/rejected/applied/expired)
 - **Client methods**: `proposals(synapse_id:, status:)`, `review_proposal(proposal_id:, status:)`
 
+## Adversarial Challenge Phase (v0.4.0)
+
+- **Challenge pipeline**: pending proposals go through conflict detection (mechanical) -> impact scoring -> LLM challenge (gated) -> weighted aggregation -> auto-accept/reject/await-review
+- **Conflict detection**: queries sibling pending proposals on same synapse; conflicting types produce 'challenge' verdict
+- **LLM challenge**: gated by `impact_score >= 0.3`; calls lex-transformer LLM engine; parses SUPPORT/CHALLENGE/ABSTAIN
+- **Aggregation**: `support_weight / (support_weight + challenge_weight)`, abstains excluded; >= 0.85 auto-accepts, <= 0.15 auto-rejects
+- **Challenger confidence**: starting 0.5, correct +0.05, incorrect -0.08, decay *0.998/hr; tracks via outcome resolution after observation window (50 signals post-application)
+- **Settings**: `lex-synapse.challenge.*` — enabled, impact_threshold, auto_accept_threshold, auto_reject_threshold, llm_engine_options, outcome_observation_window, max_per_cycle
+- **Data**: `synapse_challenges` table; `synapse_proposals` gains challenge_state, challenge_score, impact_score columns
+- **Statuses**: `auto_accepted`, `auto_rejected` added to proposal lifecycle
+- **Client methods**: `challenge_proposal(proposal_id:)`, `challenges(proposal_id:)`, `challenger_stats`
+
 ## GAIA / Apollo Integration (v0.2.2)
 
 - **GaiaReport runner**: Called during the GAIA tick cycle to report per-synapse confidence and health metrics.
@@ -110,11 +127,11 @@ Legion::Extensions::Synapse
 
 ```bash
 bundle install
-bundle exec rspec     # 353 specs, 0 failures
+bundle exec rspec     # 412 specs, 0 failures
 bundle exec rubocop   # 0 offenses
 ```
 
-353 specs, 95%+ coverage. Uses in-memory SQLite for model/runner tests.
+412 specs, 94%+ coverage. Uses in-memory SQLite for model/runner tests.
 
 ---
 

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

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require_relative '../runners/challenge'
+
+module Legion
+  module Extensions
+    module Synapse
+      module Actor
+        class Challenge < Legion::Extensions::Actors::Every
+          include Legion::Extensions::Synapse::Runners::Challenge
+
+          def runner_class = self.class
+
+          def runner_function
+            'run_challenge_cycle'
+          end
+
+          def time
+            60
+          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/actors/propose.rb

@@ -1,10 +1,16 @@
 # frozen_string_literal: true
 
+require_relative '../runners/propose'
+
 module Legion
   module Extensions
     module Synapse
       module Actor
         class Propose < Legion::Extensions::Actors::Every
+          include Legion::Extensions::Synapse::Runners::Propose
+
+          def runner_class = self.class
+
           def runner_function
             'propose_proactive'
           end

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

@@ -11,6 +11,7 @@ require_relative 'runners/dream'
 require_relative 'runners/promote'
 require_relative 'runners/retrieve'
 require_relative 'runners/propose'
+require_relative 'runners/challenge'
 require_relative 'data/models/synapse_proposal'
 require_relative 'helpers/proposals'
 
@@ -29,6 +30,7 @@ module Legion
         include Runners::Promote
         include Runners::Retrieve
         include Runners::Propose
+        include Runners::Challenge
 
         attr_reader :conditioner_client, :transformer_client
 
@@ -79,6 +81,25 @@ module Legion
           proposal.update(status: status, reviewed_at: Time.now)
           { success: true, proposal_id: proposal_id, status: status }
         end
+
+        def challenge_proposal(proposal_id:)
+          super(proposal_id: proposal_id, transformer_client: @transformer_client)
+        end
+
+        def challenges(proposal_id:)
+          Data::Model.define_synapse_challenge_model
+          Data::Model::SynapseChallenge.where(proposal_id: proposal_id).order(Sequel.desc(:id)).all
+        end
+
+        def challenger_stats
+          Data::Model.define_synapse_challenge_model
+          resolved = Data::Model::SynapseChallenge.exclude(outcome: nil)
+          {
+            total:   resolved.count,
+            correct: resolved.where(outcome: 'correct').count,
+            by_type: resolved.group_and_count(:challenger_type).to_h { |r| [r[:challenger_type], r[:count]] }
+          }
+        end
       end
     end
   end

data/lib/legion/extensions/synapse/data/migrations/005_add_synapse_challenges.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+Sequel.migration do
+  up do
+    create_table(:synapse_challenges) do
+      primary_key :id
+      foreign_key :proposal_id, :synapse_proposals, null: false, index: true
+      String     :challenger_type, null: false, size: 50
+      String     :verdict, null: false, size: 50
+      String     :reasoning, text: true
+      Float      :challenger_confidence, default: 0.5
+      DateTime   :created_at, null: false, default: Sequel::CURRENT_TIMESTAMP
+      DateTime   :resolved_at
+      String     :outcome, size: 50
+    end
+
+    alter_table(:synapse_proposals) do
+      add_column :challenge_state, String, size: 50
+      add_column :challenge_score, Float
+      add_column :impact_score, Float
+    end
+  end
+
+  down do
+    drop_table :synapse_challenges
+
+    alter_table(:synapse_proposals) do
+      drop_column :challenge_state
+      drop_column :challenge_score
+      drop_column :impact_score
+    end
+  end
+end

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

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

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

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Synapse
+      module Helpers
+        module Challenge
+          VALID_VERDICTS = %w[support challenge abstain].freeze
+          VALID_CHALLENGER_TYPES = %w[conflict llm].freeze
+          VALID_OUTCOMES = %w[correct incorrect].freeze
+          VALID_CHALLENGE_STATES = %w[challenging challenged].freeze
+
+          IMPACT_WEIGHTS = {
+            'llm_transform'      => 0.7,
+            'transform_mutation' => 0.5,
+            'attention_mutation' => 0.6,
+            'route_change'       => 0.8
+          }.freeze
+
+          DEFAULT_SETTINGS = {
+            enabled:                         true,
+            impact_threshold:                0.3,
+            auto_accept_threshold:           0.85,
+            auto_reject_threshold:           0.15,
+            llm_engine_options:              { temperature: 0.2, max_tokens: 512 },
+            outcome_observation_window:      50,
+            max_per_cycle:                   5,
+            challenger_starting_confidence:  0.5,
+            challenger_correct_adjustment:   0.05,
+            challenger_incorrect_adjustment: -0.08
+          }.freeze
+
+          class << self
+            def settings
+              raw = Legion::Settings.dig('lex-synapse', 'challenge')
+              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 above_impact_threshold?(impact_score)
+              impact_score >= settings[:impact_threshold]
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -7,7 +7,7 @@ module Legion
         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
+          VALID_STATUSES = %w[pending challenging challenged approved rejected applied expired auto_accepted auto_rejected].freeze
 
           DEFAULT_SETTINGS = {
             enabled:                 true,

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

@@ -0,0 +1,249 @@
+# frozen_string_literal: true
+
+require_relative '../helpers/challenge'
+require_relative '../helpers/confidence'
+require_relative '../data/models/synapse'
+require_relative '../data/models/synapse_proposal'
+require_relative '../data/models/synapse_challenge'
+require_relative '../data/models/synapse_signal'
+
+module Legion
+  module Extensions
+    module Synapse
+      module Runners
+        module Challenge
+          def pending_challenges
+            Data::Model.define_synapse_proposal_model
+            Data::Model::SynapseProposal.where(status: 'pending', challenge_state: nil)
+                                        .order(Sequel.asc(:id)).all
+          end
+
+          def challenge_proposal(proposal_id:, transformer_client: nil)
+            Data::Model.define_synapse_proposal_model
+            Data::Model.define_synapse_challenge_model
+            Data::Model.define_synapse_model
+            Data::Model.define_synapse_signal_model
+
+            return { success: true, skipped: true } unless Helpers::Challenge.enabled?
+
+            proposal = Data::Model::SynapseProposal[proposal_id]
+            return { success: false, error: 'proposal not found' } unless proposal
+            return { success: false, error: 'proposal not challengeable' } unless proposal.status == 'pending' && proposal.challenge_state.nil?
+
+            synapse = Data::Model::Synapse[proposal.synapse_id]
+            return { success: false, error: 'synapse not found' } unless synapse
+
+            proposal.update(challenge_state: 'challenging')
+
+            impact = calculate_impact_score(proposal, synapse)
+            proposal.update(impact_score: impact)
+
+            conflict_check(proposal)
+
+            llm_challenge(proposal, synapse, transformer_client) if Helpers::Challenge.above_impact_threshold?(impact) && transformer_client
+
+            aggregate_challenges(proposal)
+          end
+
+          def resolve_challenge_outcomes(proposal_id:)
+            Data::Model.define_synapse_proposal_model
+            Data::Model.define_synapse_challenge_model
+            Data::Model.define_synapse_signal_model
+
+            proposal = Data::Model::SynapseProposal[proposal_id]
+            return { success: false, error: 'proposal not found' } unless proposal
+            return { success: false, error: 'proposal not applied' } unless proposal.status == 'applied'
+
+            settings = Helpers::Challenge.settings
+            window = settings[:outcome_observation_window] || 50
+
+            signals = Data::Model::SynapseSignal.where(synapse_id: proposal.synapse_id)
+                                                .order(Sequel.desc(:id)).limit(window).all
+            return { success: false, error: 'insufficient signals' } if signals.size < window
+
+            success_rate = signals.count(&:transform_success).to_f / signals.size
+            proposal_succeeded = success_rate >= 0.7
+
+            challenges = Data::Model::SynapseChallenge.where(proposal_id: proposal_id)
+                                                      .exclude(verdict: 'abstain').all
+
+            challenges.each do |challenge|
+              supported = challenge.verdict == 'support'
+              correct = (supported && proposal_succeeded) || (!supported && !proposal_succeeded)
+              outcome = correct ? 'correct' : 'incorrect'
+
+              adj = correct ? settings[:challenger_correct_adjustment] : settings[:challenger_incorrect_adjustment]
+              new_conf = (challenge.challenger_confidence + adj).clamp(0.0, 1.0)
+
+              challenge.update(outcome: outcome, challenger_confidence: new_conf, resolved_at: Time.now)
+            end
+
+            { success: true, proposal_id: proposal_id, success_rate: success_rate, resolved: challenges.size }
+          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?
+
+            settings = Helpers::Challenge.settings
+            max = settings[:max_per_cycle] || 5
+
+            challenged = 0
+            pending_challenges.first(max).each do |proposal|
+              challenge_proposal(proposal_id: proposal.id, transformer_client: transformer_client)
+              challenged += 1
+            end
+
+            resolved = 0
+            window = settings[:outcome_observation_window] || 50
+            Data::Model.define_synapse_signal_model
+            Data::Model::SynapseProposal.where(status: 'applied').each do |proposal|
+              cutoff = proposal.respond_to?(:reviewed_at) && proposal.reviewed_at ? proposal.reviewed_at : proposal.created_at
+              post_signals = Data::Model::SynapseSignal.where(synapse_id: proposal.synapse_id)
+                                                       .where { created_at >= cutoff }.count
+              next unless post_signals >= window
+
+              unresolved = Data::Model::SynapseChallenge.where(proposal_id: proposal.id, outcome: nil)
+                                                        .exclude(verdict: 'abstain')
+              next unless unresolved.any?
+
+              resolve_challenge_outcomes(proposal_id: proposal.id)
+              resolved += 1
+            end
+
+            { challenged: challenged, resolved: resolved }
+          end
+
+          private
+
+          def conflict_check(proposal)
+            conflicts = Data::Model::SynapseProposal.where(
+              synapse_id:    proposal.synapse_id,
+              proposal_type: proposal.proposal_type,
+              status:        'pending'
+            ).exclude(id: proposal.id)
+
+            if conflicts.any?
+              Data::Model::SynapseChallenge.create(
+                proposal_id: proposal.id, challenger_type: 'conflict',
+                verdict: 'challenge',
+                reasoning: "#{conflicts.count} conflicting #{proposal.proposal_type} proposal(s) pending on same synapse",
+                challenger_confidence: Helpers::Challenge.settings[:challenger_starting_confidence]
+              )
+            else
+              Data::Model::SynapseChallenge.create(
+                proposal_id: proposal.id, challenger_type: 'conflict',
+                verdict: 'support', reasoning: 'no conflicting proposals',
+                challenger_confidence: Helpers::Challenge.settings[:challenger_starting_confidence]
+              )
+            end
+          end
+
+          def llm_challenge(proposal, synapse, transformer_client)
+            prompt = build_challenge_prompt(proposal, synapse)
+            engine_options = Helpers::Challenge.settings[:llm_engine_options]
+
+            result = transformer_client.transform(
+              transformation: prompt, payload: {}, engine: :llm, engine_options: engine_options
+            )
+
+            verdict, reasoning = parse_llm_verdict(result[:success] ? result[:result] : nil)
+
+            llm_confidence = rolling_llm_confidence
+            Data::Model::SynapseChallenge.create(
+              proposal_id: proposal.id, challenger_type: 'llm',
+              verdict: verdict, reasoning: reasoning,
+              challenger_confidence: llm_confidence
+            )
+          rescue StandardError => e
+            Legion::Logging.warn("Challenge LLM call failed: #{e.message}") if defined?(Legion::Logging)
+            Data::Model::SynapseChallenge.create(
+              proposal_id: proposal.id, challenger_type: 'llm',
+              verdict: 'abstain', reasoning: "LLM error: #{e.message}",
+              challenger_confidence: Helpers::Challenge.settings[:challenger_starting_confidence]
+            )
+          end
+
+          def aggregate_challenges(proposal)
+            challenges = Data::Model::SynapseChallenge.where(proposal_id: proposal.id)
+                                                      .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' }
+            end
+
+            support_weight = challenges.select { |c| c.verdict == 'support' }.sum(&:challenger_confidence)
+            challenge_weight = challenges.select { |c| c.verdict == 'challenge' }.sum(&:challenger_confidence)
+            total = support_weight + challenge_weight
+
+            score = total.zero? ? 0.5 : support_weight / total
+
+            settings = Helpers::Challenge.settings
+            decision = if score >= settings[:auto_accept_threshold]
+                         proposal.update(status: 'auto_accepted', challenge_state: 'challenged', challenge_score: score)
+                         'auto_accepted'
+                       elsif score <= settings[:auto_reject_threshold]
+                         proposal.update(status: 'auto_rejected', challenge_state: 'challenged', challenge_score: score)
+                         'auto_rejected'
+                       else
+                         proposal.update(challenge_state: 'challenged', challenge_score: score)
+                         'challenged'
+                       end
+
+            { success: true, challenge_score: score, decision: decision }
+          end
+
+          def calculate_impact_score(proposal, synapse)
+            base = Helpers::Challenge::IMPACT_WEIGHTS.fetch(proposal.proposal_type, 0.5)
+            recent_signals = Data::Model::SynapseSignal.where(synapse_id: synapse.id).count
+            baseline = [synapse.respond_to?(:baseline_throughput) && synapse.baseline_throughput ? synapse.baseline_throughput : 1.0, 1.0].max
+            throughput_factor = [recent_signals.to_f / baseline, 2.0].min
+
+            (base * synapse.confidence * throughput_factor).clamp(0.0, 1.0)
+          end
+
+          def build_challenge_prompt(proposal, synapse)
+            "Evaluate this proposed change to a cognitive routing synapse.\n\n" \
+              "Synapse confidence: #{synapse.confidence}\n" \
+              "Proposal type: #{proposal.proposal_type}\n" \
+              "Rationale: #{proposal.rationale}\n" \
+              "Proposed inputs: #{proposal.inputs}\n" \
+              "Proposed output: #{proposal.output}\n\n" \
+              "Is this change sound? Respond in exactly this format:\n" \
+              "VERDICT: SUPPORT or CHALLENGE or ABSTAIN\n" \
+              'REASONING: one sentence explanation'
+          end
+
+          def parse_llm_verdict(response)
+            return ['abstain', 'no LLM response'] unless response.is_a?(String)
+
+            text = response.to_s.strip
+            verdict = if text.match?(/VERDICT:\s*SUPPORT/i)
+                        'support'
+                      elsif text.match?(/VERDICT:\s*CHALLENGE/i)
+                        'challenge'
+                      else
+                        'abstain'
+                      end
+
+            reasoning_match = text.match(/REASONING:\s*(.+)/i)
+            reasoning = reasoning_match ? reasoning_match[1].strip : text.slice(0, 200)
+
+            [verdict, reasoning]
+          end
+
+          def rolling_llm_confidence
+            recent = Data::Model::SynapseChallenge.where(challenger_type: 'llm')
+                                                  .exclude(outcome: nil)
+                                                  .order(Sequel.desc(:id)).limit(20).all
+            return Helpers::Challenge.settings[:challenger_starting_confidence] if recent.empty?
+
+            recent.first.challenger_confidence
+          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.3.2'
+      VERSION = '0.4.1'
     end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lex-synapse
 version: !ruby/object:Gem::Version
-  version: 0.3.2
+  version: 0.4.1
 platform: ruby
 authors:
 - Esity
@@ -56,6 +56,7 @@ files:
 - Rakefile
 - lex-synapse.gemspec
 - lib/legion/extensions/synapse.rb
+- lib/legion/extensions/synapse/actors/challenge.rb
 - lib/legion/extensions/synapse/actors/crystallize.rb
 - lib/legion/extensions/synapse/actors/decay.rb
 - lib/legion/extensions/synapse/actors/evaluate.rb
@@ -67,14 +68,18 @@ files:
 - 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/migrations/005_add_synapse_challenges.rb
 - lib/legion/extensions/synapse/data/models/synapse.rb
+- lib/legion/extensions/synapse/data/models/synapse_challenge.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/challenge.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/challenge.rb
 - lib/legion/extensions/synapse/runners/crystallize.rb
 - lib/legion/extensions/synapse/runners/dream.rb
 - lib/legion/extensions/synapse/runners/evaluate.rb