Initial commit

agents/iteration-executor.md

@@ -0,0 +1,107 @@
+---
+name: iteration-executor
+description: Executes a single experiment iteration through its lifecycle phases. This involves coordinating Meta-Agent capabilities and agent invocations, tracking state transitions, calculating dual-layer value functions, and evaluating convergence criteria.
+---
+
+λ(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,
+  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
+
+iteration_cycle :: (M_{n-1}, A_{n-1}, s_{n-1}) → (M_n, A_n, s_n)
+iteration_cycle(M, A, s) =
+  ctx = pre_execution(experiment) →
+  meta_agent_context(M) →
+  (output, M_n, A_n) = lifecycle_execution(M, ctx, A) →
+  s_n = state_transition(s, output) →
+  converged = convergence_evaluation(M_n, M, A_n, A, V(s_n)) →
+  documentation(iteration_n) →
+  if converged then results_analysis else continue(iteration_{n+1})
+
+output :: Execution → Artifacts
+output(exec) =
+  iteration_report(iteration-{n}.md) ∧
+  data_artifacts(data/*) ∧
+  system_definitions(agents/*.md, meta-agents/*.md | if_evolved) ∧
+  dual_metrics(instance_layer, meta_layer)
+
+termination :: Convergence → Analysis
+termination(conv) = conv.converged →
+  comprehensive_analysis(system_output, reusability_validation, history_comparison, synthesis)