Module: Legion::Extensions::Agentic::Social::Entrainment::Runners::CognitiveEntrainment

Includes:
Helpers::Lex
Included in:
Client
Defined in:
lib/legion/extensions/agentic/social/entrainment/runners/cognitive_entrainment.rb

Instance Method Summary collapse

Instance Method Details

#cognitive_entrainment_stats ⇒ Object 



71
72
73
74
75
76
 
# File 'lib/legion/extensions/agentic/social/entrainment/runners/cognitive_entrainment.rb', line 71

def cognitive_entrainment_stats(**)
  stats = engine.to_h
  log.debug '[cognitive_entrainment] stats ' \
            "total=#{stats[:total_pairings]}"
  { success: true }.merge(stats)
end

#create_entrainment_pairing(agent_a:, agent_b:, domain:) ⇒ Object 



13
14
15
16
17
18
19
 
# File 'lib/legion/extensions/agentic/social/entrainment/runners/cognitive_entrainment.rb', line 13

def create_entrainment_pairing(agent_a:, agent_b:, domain:, **)
  pairing = engine.create_pairing(agent_a: agent_a, agent_b: agent_b, domain: domain)
  log.debug '[cognitive_entrainment] pairing ' \
            "#{agent_a}<->#{agent_b} domain=#{domain} id=#{pairing.id[0..7]}"
  { success: true, pairing_id: pairing.id, agent_a: agent_a,
    agent_b: agent_b, domain: domain, synchrony: pairing.synchrony }
end

#domain_entrainment(domain:) ⇒ Object 



49
50
51
52
53
54
55
 
# File 'lib/legion/extensions/agentic/social/entrainment/runners/cognitive_entrainment.rb', line 49

def domain_entrainment(domain:, **)
  pairings = engine.by_domain(domain: domain)
  log.debug "[cognitive_entrainment] domain=#{domain} " \
            "count=#{pairings.size}"
  { success: true, domain: domain,
    pairings: pairings.map(&:to_h), count: pairings.size }
end

#entrained_partners(agent_id:) ⇒ Object 



36
37
38
39
40
41
 
# File 'lib/legion/extensions/agentic/social/entrainment/runners/cognitive_entrainment.rb', line 36

def entrained_partners(agent_id:, **)
  partners = engine.entrained_partners(agent_id: agent_id)
  log.debug '[cognitive_entrainment] entrained_partners ' \
            "agent=#{agent_id} count=#{partners.size}"
  { success: true, agent_id: agent_id, partners: partners, count: partners.size }
end

#overall_entrainment_level ⇒ Object 



57
58
59
60
61
62
 
# File 'lib/legion/extensions/agentic/social/entrainment/runners/cognitive_entrainment.rb', line 57

def overall_entrainment_level(**)
  sync = engine.overall_entrainment
  log.debug "[cognitive_entrainment] overall_sync=#{sync.round(3)}"
  { success: true, overall_synchrony: sync,
    entrained_count: engine.entrained_pairings.size }
end

#pairings_for_agent(agent_id:) ⇒ Object 



28
29
30
31
32
33
34
 
# File 'lib/legion/extensions/agentic/social/entrainment/runners/cognitive_entrainment.rb', line 28

def pairings_for_agent(agent_id:, **)
  pairings = engine.pairings_for(agent_id: agent_id)
  log.debug '[cognitive_entrainment] pairings_for ' \
            "agent=#{agent_id} count=#{pairings.size}"
  { success: true, agent_id: agent_id,
    pairings: pairings.map(&:to_h), count: pairings.size }
end

#record_entrainment_interaction(pairing_id:, aligned:) ⇒ Object 



21
22
23
24
25
26
 
# File 'lib/legion/extensions/agentic/social/entrainment/runners/cognitive_entrainment.rb', line 21

def record_entrainment_interaction(pairing_id:, aligned:, **)
  result = engine.record_interaction(pairing_id: pairing_id, aligned: aligned)
  log.debug '[cognitive_entrainment] interaction ' \
            "id=#{pairing_id[0..7]} aligned=#{aligned}"
  result
end

#strongest_entrainment_pairings(limit: 5) ⇒ Object 



43
44
45
46
47
 
# File 'lib/legion/extensions/agentic/social/entrainment/runners/cognitive_entrainment.rb', line 43

def strongest_entrainment_pairings(limit: 5, **)
  pairings = engine.strongest_pairings(limit: limit)
  log.debug "[cognitive_entrainment] strongest count=#{pairings.size}"
  { success: true, pairings: pairings.map(&:to_h), count: pairings.size }
end

#update_cognitive_entrainment ⇒ Object 



64
65
66
67
68
69
 
# File 'lib/legion/extensions/agentic/social/entrainment/runners/cognitive_entrainment.rb', line 64

def update_cognitive_entrainment(**)
  engine.drift_all
  pruned = engine.prune_independent
  log.debug "[cognitive_entrainment] drift+prune pruned=#{pruned}"
  { success: true, pruned: pruned }
end