Struct AblationConfig 

pub struct AblationConfig {

    pub project: PathBuf,
    pub ir_path: PathBuf,
    pub golden_path: PathBuf,
    pub target: String,
    pub models_config_path: Option<PathBuf>,
    pub sweep_tiers: Vec<String>,
    pub base_tier: String,
    pub accuracy_drop_tolerance: f64,
    pub out: Option<PathBuf>,
    pub parallel: usize,
    pub filter: CaseFilter,
    pub no_cache: bool,
    pub cache_dir: Option<PathBuf>,
    pub backend: Backend,
}

Inputs for a per-step ablation sweep.

Fields

project: PathBuf

A queryable wren project (connection + data); agent files are installed here per dispatch.

ir_path: PathBuf

Compiled IR JSON (the same artifact warble dispatch consumes). Re-dispatched per point.

golden_path: PathBuf

Golden cases YAML.

target: String

Dispatch target (e.g. claude-code:headless).

models_config_path: Option<PathBuf>

Optional tier→model config YAML; defaults to the standard strong/cheap/orchestrator map.

sweep_tiers: Vec<String>

Tiers to try per step (e.g. [cheap, strong]).

base_tier: String

Tier every non-ablated step is pinned to (the reference point; conventionally strong).

accuracy_drop_tolerance: f64

A tier qualifies for the recommendation if its accuracy is within this much of the baseline.

out: Option<PathBuf>

Write the full JSON report here.

parallel: usize

Concurrent cases per dispatched point (1 = serial); see RunConfig::parallel.

filter: CaseFilter

Golden case selection (--tags / --sample). Default = full run (every case).

no_cache: bool

Bypass the trace cache (--no-cache): re-run every case at every point.

cache_dir: Option<PathBuf>

Where per-case traces are read/written. None = <project>/.warble/eval-cache.

backend: Backend

Which back-end/runtime to run the ablation through. Distinct from target (the existing per-back-end capability target this crate has always had): today the ablation loop only works with Backend::ClaudeCodeCli (it re-dispatches IR via that back-end’s own Rust emitter directly), so run_ablation validates this at entry and fails loudly otherwise rather than silently ignoring it.