orchestrate

orchestrate — the whole pipeline, end to end

orchestrate is the autonomous driver: it runs every phase in order and enforces the guardrails so a full optimization run needs little supervision. It does not add new logic — it sequences the phase skills and refuses to let the run skip a safety check. Its value is that the honesty discipline (ask-if-missing, hard gate, val-only acceptance, sealed test) is applied automatically rather than relying on the operator to remember each one.

Inputs / outputs (manifest tokens)

• needs: project — resolved from capevolve.yaml (which capability / optimizer / algorithm / budget).
• provides: report — the end-to-end result: baseline → best val → sealed test, with the winner named.

The sequence (and the guardrail at each step)

1. intake — collect inputs, scaffold the project, ask for any missing NEEDED input (never fabricate one).
2. implement-and-check — implement the adapter; cap-evolve check must be green (HARD GATE — do not advance until {"ok": true}).
3. baseline — freeze the split (once, seeded), score the seed on val, check headroom (stop early if the seed already saturates val).
4. <algorithm> — run the loop named in capevolve.yaml (default all-at-once): propose → evaluate(val) → diagnose → gate → accept/reject, until budget/stall. Acceptance is always on val, by significance (Δ > k·SE).
5. finalize — score the best candidate on the sealed test split, once.
6. report — baseline vs test; name the winner; surface pass^k and uncertainty.

The wiring is validated structurally: each step's needs must be satisfied by an upstream provides in the manifest, so a misordered or incompatible pipeline is caught before it runs.

Agent-mode loop (orchestration_mode: agent)

When the spec sets orchestration_mode: agent, cap-evolve does intake → check → baseline, then hands YOU the loop (it prints a handoff with the run_dir). YOU — the coding agent in this conversation — run the optimization yourself: read the selected algorithm's "Agent-mode loop" section (skills/algorithms/<algorithm_skill>/SKILL.md), make the capability edits, and run the evaluations directly. You do not delegate the search to a separate optimizer agent — that per-iteration "optimizer" edit-proposer is a deterministic-mode concept; in agent mode you are the optimizer. (You may still spawn helper subagents for parallel sub-tasks if an algorithm's loop calls for it, but the driver is you.)