Module: Legion::Extensions::MindGrowth::Runners::Orchestrator

Extended by:
Orchestrator
Includes:
Helpers::Lex
Included in:
Orchestrator
Defined in:
lib/legion/extensions/mind_growth/runners/orchestrator.rb

Constant Summary collapse

REQUIREMENT_CATEGORIES = 
{
  attention:           :perception,
  global_workspace:    :cognition,
  broadcasting:        :communication,
  working_memory:      :memory,
  consciousness:       :introspection,
  prediction:          :cognition,
  free_energy:         :cognition,
  predictive_coding:   :cognition,
  belief_revision:     :cognition,
  active_inference:    :cognition,
  error_monitoring:    :safety,
  intuition:           :cognition,
  dual_process:        :cognition,
  inhibition:          :safety,
  executive_function:  :cognition,
  cognitive_control:   :cognition,
  emotion:             :introspection,
  somatic_marker:      :introspection,
  interoception:       :perception,
  appraisal:           :introspection,
  embodied_simulation: :perception,
  episodic_buffer:     :memory,
  cognitive_load:      :introspection
}.freeze

Instance Method Summary collapse

Instance Method Details

#growth_status ⇒ Object 



69
70
71
72
73
74
75
76
77
 
# File 'lib/legion/extensions/mind_growth/runners/orchestrator.rb', line 69

def growth_status(**)
  stats = Runners::Proposer.proposal_stats
  profile = Runners::Analyzer.cognitive_profile

  { success:        true,
    proposals:      stats[:stats],
    coverage:       profile[:overall_coverage],
    model_coverage: profile[:model_coverage]&.map { |m| { model: m[:model], coverage: m[:coverage] } } }
end

#post_build_pipeline(proposal_id:, base_path: nil) ⇒ Object

rubocop:disable Lint/UnusedMethodArgument



79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
 
# File 'lib/legion/extensions/mind_growth/runners/orchestrator.rb', line 79

def post_build_pipeline(proposal_id:, base_path: nil, **) # rubocop:disable Lint/UnusedMethodArgument
  proposal = Runners::Proposer.get_proposal_object(proposal_id)
  return { success: false, skipped: true, reason: 'proposal not found' } unless proposal
  return { success: false, skipped: true, reason: "not in :passing state (is #{proposal.status})" } unless proposal.status == :passing

  result = { proposal_id: proposal_id }

  log.info "[orchestrator] wiring proposal #{proposal_id}"
  wire_result = wire_proposal(proposal)
  result[:wire] = wire_result

  gaia_wire_skip = wire_result[:reason] == :gaia_not_available
  wire_failed    = !gaia_wire_skip && wire_result[:success] == false

  if wire_failed
    log.warn "[orchestrator] wiring failed for #{proposal_id}: #{wire_result[:reason]}"
    result[:activated] = false
    result[:success]   = false
    result[:reason]    = :wire_failed
    return result
  end

  if gaia_wire_skip
    log.info "[orchestrator] wiring skipped for #{proposal_id} (GAIA unavailable)"
  else
    proposal.transition!(:wired)
    Runners::Proposer.persist_proposal(proposal)
  end

  log.info "[orchestrator] testing proposal #{proposal_id}"
  test_result = test_proposal(proposal)
  result[:integration_test] = test_result

  if test_result[:reason] == :gaia_not_available
    log.info "[orchestrator] integration test skipped for #{proposal_id} (GAIA unavailable)"
    result[:success]   = false
    result[:activated] = false
    result[:reason]    = :gaia_not_available
    return result
  end

  if test_result[:success] == false
    proposal.transition!(:degraded)
    Runners::Proposer.persist_proposal(proposal)
    result[:activated] = false
    result[:success]   = false
    log.info "[orchestrator] proposal #{proposal_id} degraded after integration test"
  else
    proposal.transition!(:active)
    Runners::Proposer.persist_proposal(proposal)
    result[:activated] = true
    result[:success]   = true
    log.info "[orchestrator] proposal #{proposal_id} activated"
  end

  result
rescue StandardError => e
  log.error "[orchestrator] post_build_pipeline failed for #{proposal_id}: #{e.message}"
  { success: false, error: e.message }
end

#run_growth_cycle(existing_extensions: nil, base_path: nil, max_proposals: 3, force: false) ⇒ Object 



13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
 
# File 'lib/legion/extensions/mind_growth/runners/orchestrator.rb', line 13

def run_growth_cycle(existing_extensions: nil, base_path: nil, max_proposals: 3, force: false, **)
  trace = { started_at: Time.now.utc, steps: [] }

  # Step 1: Analyze gaps in the cognitive ecosystem
  gaps = Runners::Analyzer.recommend_priorities(existing_extensions: existing_extensions)
  trace[:steps] << { step: :analyze, result: gaps }
  return failure(trace, 'gap analysis failed') unless gaps[:success]
  return failure(trace, 'no priorities identified') if gaps[:priorities].empty?

  # Step 2: Propose concepts for the top priorities
  proposals = propose_from_priorities(gaps[:priorities], max_proposals)
  trace[:steps] << { step: :propose, count: proposals.size, proposals: proposals.map { |p| p[:proposal][:id] } }
  return failure(trace, 'no proposals created') if proposals.empty?

  # Step 3: Evaluate each proposal
  classify_and_trace_evaluations(evaluate_proposals(proposals), trace)

  # Step 4: Build — auto-approved build immediately; regular approved only when forced
  result = execute_build_step(trace, base_path, force)
  return result if result

  trace[:completed_at] = Time.now.utc
  trace[:duration_ms] = ((trace[:completed_at] - trace[:started_at]) * 1000).round

  log_cycle_summary(trace)
  { success: true, trace: trace }
rescue StandardError => e
  { success: false, error: e.message, trace: trace }
end