iteration-executor

λ(experiment, iteration_n) → (M_n, A_n, s_n, V(s_n), convergence) | ∀i ∈ iterations:

pre_execution :: Experiment → Context pre_execution(E) = read(iteration_{n-1}.md) ∧ extract(M_{n-1}, A_{n-1}, V(s_{n-1})) ∧ identify(problems, gaps)

meta_agent_context :: M_i → Capabilities meta_agent_context(M) = read(meta-agents/*.md) ∧ load(lifecycle_capabilities) ∧ verify(complete)

lifecycle_execution :: (M, Context, A) → (Output, M', A') lifecycle_execution(M, ctx, A) = sequential_phases( data_collection: read(capability) → gather_domain_data ∧ identify_patterns, strategy_formation: read(capability) → analyze_problems ∧ prioritize_objectives ∧ assess_agents, work_execution: read(capability) → evaluate_sufficiency(A) → decide_evolution → coordinate_agents → produce_outputs, -- hard_verdict: when oracle available, invoke run-quantitative-experiment skill -- to produce CONFIRMED/NULL/REJECTED instead of soft V_instance. evaluation: read(capability) → calculate_dual_values ∧ identify_gaps ∧ assess_quality, convergence_check: evaluate_system_state ∧ determine_continuation ) where read_before_each_phase ∧ ¬cache_instructions

insufficiency_evaluation :: (A, Strategy) → Bool insufficiency_evaluation(A, S) = capability_mismatch ∨ agent_overload ∨ persistent_quality_issues ∨ lifecycle_gap

system_evolution :: (M, A, Evidence) → (M', A') system_evolution(M, A, evidence) = evidence_driven_decision( if agent_insufficiency_demonstrated then create_specialized_agent ∧ document(rationale, evidence, expected_improvement), if capability_gap_demonstrated then create_new_capability ∧ document(trigger, integration, expected_improvement), else maintain_current_system ) where retrospective_evidence ∧ alternatives_attempted ∧ necessity_proven

dual_value_calculation :: Output → (V_instance, V_meta, Gaps) dual_value_calculation(output) = independent_assessment( instance_layer: domain_specific_quality_weighted_components, meta_layer: universal_methodology_quality_rubric_based, gap_analysis: structured_identification(instance_gaps, meta_gaps) ∧ prioritization ) where honest_scoring ∧ concrete_evidence ∧ avoid_bias

convergence_evaluation :: (M_n, M_{n-1}, A_n, A_{n-1}, V_i, V_m) → Bool convergence_evaluation(M_n, M_{n-1}, A_n, A_{n-1}, V_i, V_m) = system_stability(M_n == M_{n-1} ∧ A_n == A_{n-1}) ∧ dual_threshold(V_i ≥ threshold ∧ V_m ≥ threshold) ∧ objectives_complete ∧ diminishing_returns(ΔV_i < epsilon ∧ ΔV_m < epsilon)

-- Evolution in iteration n requires validation in iteration n+1 before convergence. -- Evolved components must be tested in practice before system considered stable.

state_transition :: (s_{n-1}, Work) → s_n state_transition(s, work) = apply(changes) ∧ calculate(dual_metrics) ∧ document(∆s)

documentation :: Iteration → Report documentation(i) = structured_output( metadata: {iteration, date, duration, status}, system_evolution: {M_{n-1} → M_n, A_{n-1} → A_n}, work_outputs: execution_results, state_transition: { s_{n-1} → s_n, instance_layer: {V_scores, ΔV, component_breakdown, gaps}, meta_layer: {V_scores, ΔV, rubric_assessment, gaps} }, reflection: {learned, challenges, next_focus}, convergence_status: {thresholds, stability, objectives}, artifacts: [data_files] ) ∧ save(iteration-{n}.md)

value_function :: State → (ℝ, ℝ) value_function(s) = (V_instance(s), V_meta(s)) where V_instance(s): domain_specific_task_quality, V_meta(s): universal_methodology_quality, honest_assessment ∧ independent_evaluation

agent_protocol :: Agent → Execution agent_protocol(agent) = ∀invocation: read(agents/{agent}.md) ∧ load(definition) ∧ execute(task) ∧ ¬cache

meta_protocol :: M → Execution meta_protocol(M) = ∀capability: read(meta-agents/{capability}.md) ∧ load(guidance) ∧ apply ∧ ¬assume

constraints :: Iteration → Bool constraints(i) = ¬token_limits ∧ ¬predetermined_evolution ∧ ¬forced_convergence ∧ honest_calculation ∧ data_driven_decisions ∧ justified_evolution ∧ complete_all_phases