gepa-autorun

gepa-autorun

A thin loop around gepa-run: invoke gepa run, fulfill any pending envelope (reflection / rollout / metric — exactly as gepa-run describes), then consult decide_stop on the run's telemetry before the next iteration. Stop when the policy says stop; otherwise continue. A live session can always stop manually.

Stop conditions (checked after every gepa run exit)

Condition	Reason emitted
budget_exhausted	max_metric_calls reached
preflight_abort	preflight hook aborted the run
no_accept_streak >= saturation_patience AND saturation_corroborated	surface saturated (corroborated)
invalid_patch_streak >= invalid_patch_patience	too many consecutive invalid patches

Default patiences: saturation_patience=3, invalid_patch_patience=3. Override in .gepa/config.yaml under an autorun: block:

autorun:
  saturation_patience: 5
  invalid_patch_patience: 4

The loop

gepa-anywhere run --config .gepa/config.yaml

Repeat until exit 0 or a stop-policy fires:

1. Run the command above.
2. Exit 0 → optimization complete. Read done.json and surface the result. Check stop-policy one last time (budget note). Hand off to gepa-frontier. STOP.
3. Exit 42 → fulfill the envelope exactly as gepa-run describes:
   • reflection → propose improved component text, write to response_path.
   • rollout → dispatch Agent tool per request, write outputs.
   • metric → dispatch gepa-judge per request, write {score, feedback}. After all responses/outputs are written, check stop-policy (step 4), then GOTO 1.
4. Check stop-policy (after every exit, before re-invoking). Build the state dict, then apply decide_stop logic in this priority order:
   • budget_exhausted — core-emitted. Read it from:

     gepa-anywhere state --config .gepa/config.yaml
     

     whose autorun_telemetry carries the end-of-optimize state (budget_exhausted, best_idx, total_metric_calls). If true → STOP, report budget hit.
   • preflight_abort — signalled by exit 1 + done.json {aborted: true} (step 5 / preflight gate), not by telemetry. If aborted → STOP, report abort.
   • no_accept_streak / invalid_patch_streak / saturation_corroborated — YOU track these across iterations; gepa state does NOT emit them (GEPA's result object exposes no per-iteration streak counters). As you drive the loop: increment no_accept_streak on any iteration that accepted no new candidate (reset to 0 on an accept); increment invalid_patch_streak each time a reflection patch was rejected as malformed (the adapter re-suspended — reset on a valid patch); set saturation_corroborated only when a second signal confirms (e.g. holdout flat too, or the frontier unchanged for the streak). Then:
     • If no_accept_streak >= saturation_patience AND saturation_corroborated → STOP, report surface saturated.
     • If invalid_patch_streak >= invalid_patch_patience → STOP, report patch loop.
   • Otherwise → continue (GOTO 1).
5. Exit 1+ → surface stderr, stop.

Reporting on stop

When a stop-policy fires, tell the user:

• Which condition triggered and what the telemetry values were.
• Whether a winner exists (done.json → best_candidate).
• Whether holdout improved (from holdout-report.json if present).
• Suggested next step: gepa-frontier to inspect + promote, or re-run with adjusted patiences / more golden data if the stop was premature.

Notes

• The stop-policy does NOT alter the optimization math — GEPA runs until it exits 0 (or the budget fires inside gepa run itself); the policy is a session-level gate on whether to re-invoke.
• If no autorun: config block is present, defaults apply silently.
• A live session can stop at any point — just don't re-invoke gepa run. The checkpoint is durable; the run can resume later.
• gepa-anywhere state --config .gepa/config.yaml surfaces autorun_telemetry at any time without re-running.