Struct Config 

pub struct Config {

    pub model: String,
    pub min_similarity: f32,
    pub score_margin: f32,
    pub max_skills: usize,
    pub char_budget: usize,
    pub keyword_boost: f32,
    pub phrase_boost: f32,
    pub roots: Vec<PathBuf>,
    pub inject_mode: InjectMode,
    pub directive_strength: Strength,
    pub deny: Vec<String>,
    pub force: Vec<String>,
    pub context_depth: usize,
    pub context_weight: f32,
    pub vague_lo: f32,
    pub vague_hi: f32,
    pub file_boost: f32,
    pub project_boost: f32,
    pub recall_floor: f32,
    pub high_conf: f32,
    pub clear_gap: f32,
    pub rerank_top_k: usize,
    pub rerank_min: f32,
    pub rerank_margin: f32,
    pub body_inject_min: f32,
    pub lexical_min: f32,
    pub lexical_margin: f32,
    pub telemetry: bool,
}

Fields

model: String

Embedding model id. Recognized by the fastembed backend; otherwise the offline bag-of-words backend is used regardless of this value.

min_similarity: f32

Minimum hybrid score for a skill to be eligible for injection.

score_margin: f32

Max gap below the single best-scoring skill a skill may fall and still be injected. Suppresses the weak tail: when the top match is strong, only near-peers ride along; when only weak matches exist (or the leader was already injected this session), nothing clears the gate. Tuned alongside min_similarity per embedder.

max_skills: usize

Max skills injected per prompt.

char_budget: usize

Max total injected characters (budget; enforced in the hook path).

keyword_boost: f32

Added to a skill’s score per matching keyword.

phrase_boost: f32

Added to a skill’s score per matched trigger phrase (see crate::rank::phrase_score). Higher than keyword_boost: a full multi-token phrase match is stronger, higher-precision evidence than a single keyword token.

roots: Vec<PathBuf>

Filesystem roots scanned for SKILL.md files.

inject_mode: InjectMode

How matched skills are injected.

directive_strength: Strength

Forcefulness of directive-mode injections.

deny: Vec<String>

Skill ids never auto-injected.

force: Vec<String>

Skill ids injected whenever a keyword hits, even below min_similarity.

context_depth: usize

How many recent prompts to retain as conversational context (0 = disabled).

context_weight: f32

Max weight the context channel can add to a skill’s score. The effective weight scales from this (a fully vague prompt) down to 0 (a confident, specific prompt) — see crate::rank::context_weight. Cosine-space, tuned per embedder; 0.0 disables the blend.

vague_lo: f32

Prompt best-self-cosine at/below which a prompt counts as fully vague (context applied at full context_weight).

vague_hi: f32

Prompt best-self-cosine at/above which a prompt counts as confident (context suppressed entirely). Between vague_lo and this, context scales linearly.

file_boost: f32

Score added to a skill when a file of its type is referenced in the prompt or recent context (e.g. a .xlsx boosts xlsx; see crate::context::file_ids). High-precision and not vagueness-gated — a named file is unambiguous. 0.0 disables the channel.

project_boost: f32

Score added to a skill whose ecosystem matches the working directory’s project manifests or a code file referenced in the conversation (a uv.lock implies the uv/python terms, a named etl.py implies python, …; see crate::context::project_terms / crate::context::code_terms). Terms resolve dynamically against the installed library (crate::context::skills_for_terms), so the channel surfaces whatever uv/rust/go skill the user actually has, by any name. Unlike a named file, this is an ambient signal present on every turn, so it is the weakest channel and is gated on the skill’s own cosine sitting within crate::rank::PROJECT_GATE_SLACK of min_similarity in crate::rank::rank_all_ctx — it lifts a near-plausible ecosystem skill over the floor (deliberately recall-leaning: the model ignores a surfaced skill it doesn’t need, and per-session dedup caps the cost at one showing) but never rescues a clearly-irrelevant one. 0.0 disables the channel.

recall_floor: f32

Stage-1 score below which a prompt is treated as having no relevant skill, so the (costly) reranker is skipped entirely.

high_conf: f32

Stage-1 score above which the top match may be a confident lone winner.

clear_gap: f32

Minimum stage-1 gap from the top match to the runner-up for the top to count as a lone winner (and thus skip reranking).

rerank_top_k: usize

How many stage-1 candidates are handed to the reranker.

rerank_min: f32

Minimum reranker logit for a skill to be injected.

rerank_margin: f32

Max reranker-logit gap below the best reranked skill for a peer to ride along.

body_inject_min: f32

Confidence ([0,1]) at/above which a lone near-certain match is escalated from a directive pointer to a full body inject — the SKILL.md is inlined directly so the model can’t skip the Skill-tool round-trip. Only fires in inject_mode = directive and only when exactly one skill is selected (two co-relevant peers mean we are less certain, so they stay directives). Set deliberately high: in practice this is reached only by a cross-encoder- confirmed match (the cosine→confidence map caps below it for bge), so a fluky stage-1 hit never triggers a body dump. Raise above 1.0 to disable.

lexical_min: f32

Minimum absolute BM25 score for the top description match to be a lexical winner. <= 0 disables the channel entirely.

lexical_margin: f32

Minimum BM25 gap from the top description match to the runner-up for the top to count as dominant (and thus inject directly, skipping the reranker). The margin is what keeps the fast-path high-precision: a cluster of near-equal descriptions abstains and defers to the reranker.

telemetry: bool

Append opt-in JSONL telemetry events (see crate::telemetry). Off by default. Enabled by this field or a truthy SKI_TELEMETRY env var — either one turns it on, so the env var still works without a config file.

Implementations

impl Config

pub fn calibrate_to(&mut self, embedder: &dyn Embedder)

Adopt the active embedder’s score thresholds. Cosine distributions are a property of the embedding space, not user preference, so min_similarity and score_margin follow the embedder that actually ran (bge vs the offline bag-of-words fallback). Other fields are left untouched.

Examples found in repository

examples/eval.rs (line 148)

fn main() -> anyhow::Result<()> {
    let args: Vec<String> = std::env::args().skip(1).collect();
    let verbose = args.iter().any(|a| a == "-v" || a == "--verbose");
    let path = args
        .iter()
        .find(|a| !a.starts_with('-'))
        .cloned()
        .unwrap_or_else(|| "tests/data/popular_skills_prompts.tsv".to_string());

    let raw = std::fs::read_to_string(&path)?;
    let cases = parse_cases(&raw);

    let (mut cfg, file) = Config::load(Host::Claude);
    // A/B affordance: override the phrase-channel boost (0.0 disables it) so the
    // same corpus can be scored with and without the channel in one rebuild.
    if let Ok(v) = std::env::var("SKI_PHRASE_BOOST") {
        cfg.phrase_boost = v.parse().expect("SKI_PHRASE_BOOST must be a float");
    }
    // Context enrichment (Goal 3) is off by default; these env knobs activate and
    // tune it for one run, mirroring SKI_PHRASE_BOOST, so the same corpus can be
    // scored with and without conversational context.
    if let Ok(v) = std::env::var("SKI_CONTEXT_DEPTH") {
        cfg.context_depth = v.parse().expect("SKI_CONTEXT_DEPTH must be a usize");
    }
    if let Ok(v) = std::env::var("SKI_CONTEXT_WEIGHT") {
        cfg.context_weight = v.parse().expect("SKI_CONTEXT_WEIGHT must be a float");
    }
    if let Ok(v) = std::env::var("SKI_VAGUE_LO") {
        cfg.vague_lo = v.parse().expect("SKI_VAGUE_LO must be a float");
    }
    if let Ok(v) = std::env::var("SKI_VAGUE_HI") {
        cfg.vague_hi = v.parse().expect("SKI_VAGUE_HI must be a float");
    }
    if let Ok(v) = std::env::var("SKI_FILE_BOOST") {
        cfg.file_boost = v.parse().expect("SKI_FILE_BOOST must be a float");
    }
    if let Ok(v) = std::env::var("SKI_PROJECT_BOOST") {
        cfg.project_boost = v.parse().expect("SKI_PROJECT_BOOST must be a float");
    }
    // Reranker-gate sweep knobs: tune the stage-2 abstention floor/margin for one
    // run without editing config.toml (these are on the logit scale, untouched by
    // `calibrate_to`).
    if let Ok(v) = std::env::var("SKI_RERANK_MIN") {
        cfg.rerank_min = v.parse().expect("SKI_RERANK_MIN must be a float");
    }
    if let Ok(v) = std::env::var("SKI_RERANK_MARGIN") {
        cfg.rerank_margin = v.parse().expect("SKI_RERANK_MARGIN must be a float");
    }
    // Lexical fast-path (BM25 over description) sweep knobs: `lexical_min <= 0`
    // disables it, so the same corpus can be scored with and without the channel.
    if let Ok(v) = std::env::var("SKI_LEXICAL_MIN") {
        cfg.lexical_min = v.parse().expect("SKI_LEXICAL_MIN must be a float");
    }
    if let Ok(v) = std::env::var("SKI_LEXICAL_MARGIN") {
        cfg.lexical_margin = v.parse().expect("SKI_LEXICAL_MARGIN must be a float");
    }
    let skills = skill::discover(&cfg.roots)?;
    let embedder = embed::build(&cfg.model)?;
    cfg.calibrate_to(embedder.as_ref());
    file.apply_cosine(&mut cfg);
    let idx = index::build(&skills, embedder.as_ref(), None)?;
    eprintln!(
        "index: {} skills via {} | rerank_min {:.2} margin {:.2} | min_sim {:.2} | lexical_min {:.2} margin {:.2}",
        idx.skills.len(),
        idx.model,
        cfg.rerank_min,
        cfg.rerank_margin,
        cfg.min_similarity,
        cfg.lexical_min,
        cfg.lexical_margin,
    );

    // Confusion counters. `borderline` rows are tallied separately (observe-only).
    let (mut tp, mut fn_, mut fp, mut tn) = (0u32, 0u32, 0u32, 0u32);
    let (mut n_pos, mut n_neg) = (0u32, 0u32);
    let mut fp_rows: Vec<String> = Vec::new();
    let mut fn_rows: Vec<String> = Vec::new();
    // Stage-1 retrieval ceiling (pre-rerank), over positives only: recall@k is the
    // fraction whose gold skill survives into the top-`rerank_top_k` candidates the
    // reranker is fed (`rerank::rerank` takes exactly that many); top-1 is the
    // fraction already ranked first by hybrid score. recall@k ~100% means retrieval
    // is not the bottleneck and the problem is ranking within the retrieved set.
    let (mut recall_at_k, mut stage1_top1) = (0u32, 0u32);
    let mut recall_miss_rows: Vec<String> = Vec::new();

    for c in &cases {
        let query = embedder
            .embed(std::slice::from_ref(&c.prompt), EmbedKind::Query)?
            .remove(0);
        let cvec = context::vector(embedder.as_ref(), &c.context, &cfg)?;
        // File-type channel: scan this turn's prompt AND its prior context for named
        // files (a `.xlsx` etc.), mapping each to its skill.
        let file_text = format!("{} {}", c.context.join(" "), c.prompt);
        let file_ids = context::file_ids(&file_text);
        // Ambient project-type channel: the case's cwd (5th column) yields
        // ecosystem terms (plus any code file named in the conversation), resolved
        // against the installed index. Empty when the channel is off.
        let project_ids = if cfg.project_boost > 0.0 {
            let mut terms = context::project_terms(&c.cwd);
            terms.extend(context::code_terms(&file_text));
            context::skills_for_terms(&terms, &idx)
                .into_keys()
                .collect()
        } else {
            std::collections::BTreeSet::new()
        };
        let hits = rank::rank_all_ctx(
            &query,
            cvec.as_deref(),
            &file_ids,
            &project_ids,
            &c.prompt,
            &idx,
            &cfg,
        );
        // The reranker reads text: enrich its query with the recent window when the
        // prompt is vague (same gate that lets the context vector contribute).
        let prompt_top = hits.iter().map(|h| h.cosine).fold(0.0_f32, f32::max);
        let rerank_query = context::rerank_query(
            &c.prompt,
            prompt_top,
            &c.context,
            !file_ids.is_empty(),
            &cfg,
        );
        let plan = pipeline::decide(&hits, &idx, &c.prompt, &rerank_query, &cfg);
        let stage = match plan.stage {
            Stage::Lexical => "lexical",
            Stage::Rerank => "rerank",
            Stage::Cosine => "stage1",
        };
        // Caller-side guardrails: the hook's `finalize` minus session dedup (the eval
        // has no session) — drop denied skills, cap at `max_skills`.
        let injected: Vec<Hit> = plan
            .passed
            .into_iter()
            .filter(|h| !cfg.deny.contains(&h.id))
            .take(cfg.max_skills)
            .collect();
        let ids: Vec<String> = injected.iter().map(|h| h.id.clone()).collect();
        let is_neg = c.want == "(none)";
        let observe_only = c.kind == "borderline";

        if verbose {
            let top: Vec<String> = hits
                .iter()
                .take(4)
                .map(|h| format!("{}={:.3}", h.id, h.score))
                .collect();
            let inj: Vec<String> = injected
                .iter()
                .map(|h| {
                    format!(
                        "{}=L{:.2}/cos{:.3}+ctx{:.2}+file{:.2}+proj{:.2}+kw{:.2}+ph{:.2}",
                        h.id, h.score, h.cosine, h.context, h.file, h.project, h.keyword, h.phrase
                    )
                })
                .collect();
            eprintln!(
                "[{:<10}] {:<7} inject=[{}]  top: {}  :: {}",
                c.kind,
                stage,
                inj.join(", "),
                top.join(", "),
                c.prompt,
            );
        }

        if observe_only {
            continue;
        }
        if is_neg {
            n_neg += 1;
            if injected.is_empty() {
                tn += 1;
            } else {
                fp += 1;
                fp_rows.push(format!(
                    "  FP [{:<10}] inject=[{}] :: {}",
                    c.kind,
                    ids.join(", "),
                    c.prompt
                ));
            }
        } else {
            n_pos += 1;
            // Stage-1 ceiling: where does the gold skill land in the full hybrid
            // ranking, before any rerank/threshold gating?
            let rank = hits.iter().position(|h| h.id == c.want);
            if rank == Some(0) {
                stage1_top1 += 1;
            }
            if rank.is_some_and(|r| r < cfg.rerank_top_k) {
                recall_at_k += 1;
            } else {
                recall_miss_rows.push(format!(
                    "  R@k MISS [{:<10}] want={} stage-1 rank={} :: {}",
                    c.kind,
                    c.want,
                    rank.map_or_else(|| "absent".to_string(), |r| r.to_string()),
                    c.prompt
                ));
            }
            if ids.iter().any(|id| id == &c.want) {
                tp += 1;
            } else {
                fn_ += 1;
                fn_rows.push(format!(
                    "  FN [{:<10}] want={} got=[{}] :: {}",
                    c.kind,
                    c.want,
                    ids.join(", "),
                    c.prompt
                ));
            }
        }
    }

    println!("\n=== eval: {} ===", path);
    println!(
        "positives {n_pos}: recall {tp}/{n_pos} ({:.0}%)   misses {fn_}",
        pct(tp, n_pos)
    );
    println!(
        "negatives {n_neg}: false-inject {fp}/{n_neg} ({:.0}%)   clean {tn}",
        pct(fp, n_neg)
    );
    // Headline: recall recovered, net of discounted FP harm. Optimise this — not
    // FP count — because a strong host filters false injects (see module docs).
    let recall_rate = if n_pos == 0 {
        0.0
    } else {
        tp as f32 / n_pos as f32
    };
    let fp_rate = if n_neg == 0 {
        0.0
    } else {
        fp as f32 / n_neg as f32
    };
    println!(
        "host-value {:.0}%  (= recall {:.0}% - {FP_HARM} * fp {:.0}%; FP discounted: a strong host ignores false injects)",
        100.0 * (recall_rate - FP_HARM * fp_rate),
        100.0 * recall_rate,
        100.0 * fp_rate,
    );
    println!(
        "stage-1 (pre-rerank, k={}): recall@k {recall_at_k}/{n_pos} ({:.0}%)   top-1 {stage1_top1}/{n_pos} ({:.0}%)",
        cfg.rerank_top_k,
        pct(recall_at_k, n_pos),
        pct(stage1_top1, n_pos),
    );
    if !recall_miss_rows.is_empty() {
        println!(
            "--- stage-1 recall@k misses (gold below top-{}) ---",
            cfg.rerank_top_k
        );
        recall_miss_rows.iter().for_each(|r| println!("{r}"));
    }
    if !fn_rows.is_empty() {
        println!("--- recall misses ---");
        fn_rows.iter().for_each(|r| println!("{r}"));
    }
    if !fp_rows.is_empty() {
        println!("--- false injections ---");
        fp_rows.iter().for_each(|r| println!("{r}"));
    }
    Ok(())
}

pub fn for_host(host: Host) -> Self

Config scoped to host: discovery roots (and, via crate::paths::index_path, the on-disk index) cover only that host’s skill library. Keeps an injected skill name resolvable in the host that receives it — a Claude-only id never injects into opencode and vice versa.

pub fn load(host: Host) -> (Self, FileConfig)

Host-scoped config with the user file (FileConfig) overlaid, returned alongside the parsed file. The file is returned so a caller that calibrates can re-assert the cosine pins afterward: Config::calibrate_to overwrites min_similarity/score_margin from the embedder and would otherwise clobber a user-set value. Callers that never calibrate can ignore the FileConfig.

Examples found in repository

examples/eval.rs (line 102)

fn main() -> anyhow::Result<()> {
    let args: Vec<String> = std::env::args().skip(1).collect();
    let verbose = args.iter().any(|a| a == "-v" || a == "--verbose");
    let path = args
        .iter()
        .find(|a| !a.starts_with('-'))
        .cloned()
        .unwrap_or_else(|| "tests/data/popular_skills_prompts.tsv".to_string());

    let raw = std::fs::read_to_string(&path)?;
    let cases = parse_cases(&raw);

    let (mut cfg, file) = Config::load(Host::Claude);
    // A/B affordance: override the phrase-channel boost (0.0 disables it) so the
    // same corpus can be scored with and without the channel in one rebuild.
    if let Ok(v) = std::env::var("SKI_PHRASE_BOOST") {
        cfg.phrase_boost = v.parse().expect("SKI_PHRASE_BOOST must be a float");
    }
    // Context enrichment (Goal 3) is off by default; these env knobs activate and
    // tune it for one run, mirroring SKI_PHRASE_BOOST, so the same corpus can be
    // scored with and without conversational context.
    if let Ok(v) = std::env::var("SKI_CONTEXT_DEPTH") {
        cfg.context_depth = v.parse().expect("SKI_CONTEXT_DEPTH must be a usize");
    }
    if let Ok(v) = std::env::var("SKI_CONTEXT_WEIGHT") {
        cfg.context_weight = v.parse().expect("SKI_CONTEXT_WEIGHT must be a float");
    }
    if let Ok(v) = std::env::var("SKI_VAGUE_LO") {
        cfg.vague_lo = v.parse().expect("SKI_VAGUE_LO must be a float");
    }
    if let Ok(v) = std::env::var("SKI_VAGUE_HI") {
        cfg.vague_hi = v.parse().expect("SKI_VAGUE_HI must be a float");
    }
    if let Ok(v) = std::env::var("SKI_FILE_BOOST") {
        cfg.file_boost = v.parse().expect("SKI_FILE_BOOST must be a float");
    }
    if let Ok(v) = std::env::var("SKI_PROJECT_BOOST") {
        cfg.project_boost = v.parse().expect("SKI_PROJECT_BOOST must be a float");
    }
    // Reranker-gate sweep knobs: tune the stage-2 abstention floor/margin for one
    // run without editing config.toml (these are on the logit scale, untouched by
    // `calibrate_to`).
    if let Ok(v) = std::env::var("SKI_RERANK_MIN") {
        cfg.rerank_min = v.parse().expect("SKI_RERANK_MIN must be a float");
    }
    if let Ok(v) = std::env::var("SKI_RERANK_MARGIN") {
        cfg.rerank_margin = v.parse().expect("SKI_RERANK_MARGIN must be a float");
    }
    // Lexical fast-path (BM25 over description) sweep knobs: `lexical_min <= 0`
    // disables it, so the same corpus can be scored with and without the channel.
    if let Ok(v) = std::env::var("SKI_LEXICAL_MIN") {
        cfg.lexical_min = v.parse().expect("SKI_LEXICAL_MIN must be a float");
    }
    if let Ok(v) = std::env::var("SKI_LEXICAL_MARGIN") {
        cfg.lexical_margin = v.parse().expect("SKI_LEXICAL_MARGIN must be a float");
    }
    let skills = skill::discover(&cfg.roots)?;
    let embedder = embed::build(&cfg.model)?;
    cfg.calibrate_to(embedder.as_ref());
    file.apply_cosine(&mut cfg);
    let idx = index::build(&skills, embedder.as_ref(), None)?;
    eprintln!(
        "index: {} skills via {} | rerank_min {:.2} margin {:.2} | min_sim {:.2} | lexical_min {:.2} margin {:.2}",
        idx.skills.len(),
        idx.model,
        cfg.rerank_min,
        cfg.rerank_margin,
        cfg.min_similarity,
        cfg.lexical_min,
        cfg.lexical_margin,
    );

    // Confusion counters. `borderline` rows are tallied separately (observe-only).
    let (mut tp, mut fn_, mut fp, mut tn) = (0u32, 0u32, 0u32, 0u32);
    let (mut n_pos, mut n_neg) = (0u32, 0u32);
    let mut fp_rows: Vec<String> = Vec::new();
    let mut fn_rows: Vec<String> = Vec::new();
    // Stage-1 retrieval ceiling (pre-rerank), over positives only: recall@k is the
    // fraction whose gold skill survives into the top-`rerank_top_k` candidates the
    // reranker is fed (`rerank::rerank` takes exactly that many); top-1 is the
    // fraction already ranked first by hybrid score. recall@k ~100% means retrieval
    // is not the bottleneck and the problem is ranking within the retrieved set.
    let (mut recall_at_k, mut stage1_top1) = (0u32, 0u32);
    let mut recall_miss_rows: Vec<String> = Vec::new();

    for c in &cases {
        let query = embedder
            .embed(std::slice::from_ref(&c.prompt), EmbedKind::Query)?
            .remove(0);
        let cvec = context::vector(embedder.as_ref(), &c.context, &cfg)?;
        // File-type channel: scan this turn's prompt AND its prior context for named
        // files (a `.xlsx` etc.), mapping each to its skill.
        let file_text = format!("{} {}", c.context.join(" "), c.prompt);
        let file_ids = context::file_ids(&file_text);
        // Ambient project-type channel: the case's cwd (5th column) yields
        // ecosystem terms (plus any code file named in the conversation), resolved
        // against the installed index. Empty when the channel is off.
        let project_ids = if cfg.project_boost > 0.0 {
            let mut terms = context::project_terms(&c.cwd);
            terms.extend(context::code_terms(&file_text));
            context::skills_for_terms(&terms, &idx)
                .into_keys()
                .collect()
        } else {
            std::collections::BTreeSet::new()
        };
        let hits = rank::rank_all_ctx(
            &query,
            cvec.as_deref(),
            &file_ids,
            &project_ids,
            &c.prompt,
            &idx,
            &cfg,
        );
        // The reranker reads text: enrich its query with the recent window when the
        // prompt is vague (same gate that lets the context vector contribute).
        let prompt_top = hits.iter().map(|h| h.cosine).fold(0.0_f32, f32::max);
        let rerank_query = context::rerank_query(
            &c.prompt,
            prompt_top,
            &c.context,
            !file_ids.is_empty(),
            &cfg,
        );
        let plan = pipeline::decide(&hits, &idx, &c.prompt, &rerank_query, &cfg);
        let stage = match plan.stage {
            Stage::Lexical => "lexical",
            Stage::Rerank => "rerank",
            Stage::Cosine => "stage1",
        };
        // Caller-side guardrails: the hook's `finalize` minus session dedup (the eval
        // has no session) — drop denied skills, cap at `max_skills`.
        let injected: Vec<Hit> = plan
            .passed
            .into_iter()
            .filter(|h| !cfg.deny.contains(&h.id))
            .take(cfg.max_skills)
            .collect();
        let ids: Vec<String> = injected.iter().map(|h| h.id.clone()).collect();
        let is_neg = c.want == "(none)";
        let observe_only = c.kind == "borderline";

        if verbose {
            let top: Vec<String> = hits
                .iter()
                .take(4)
                .map(|h| format!("{}={:.3}", h.id, h.score))
                .collect();
            let inj: Vec<String> = injected
                .iter()
                .map(|h| {
                    format!(
                        "{}=L{:.2}/cos{:.3}+ctx{:.2}+file{:.2}+proj{:.2}+kw{:.2}+ph{:.2}",
                        h.id, h.score, h.cosine, h.context, h.file, h.project, h.keyword, h.phrase
                    )
                })
                .collect();
            eprintln!(
                "[{:<10}] {:<7} inject=[{}]  top: {}  :: {}",
                c.kind,
                stage,
                inj.join(", "),
                top.join(", "),
                c.prompt,
            );
        }

        if observe_only {
            continue;
        }
        if is_neg {
            n_neg += 1;
            if injected.is_empty() {
                tn += 1;
            } else {
                fp += 1;
                fp_rows.push(format!(
                    "  FP [{:<10}] inject=[{}] :: {}",
                    c.kind,
                    ids.join(", "),
                    c.prompt
                ));
            }
        } else {
            n_pos += 1;
            // Stage-1 ceiling: where does the gold skill land in the full hybrid
            // ranking, before any rerank/threshold gating?
            let rank = hits.iter().position(|h| h.id == c.want);
            if rank == Some(0) {
                stage1_top1 += 1;
            }
            if rank.is_some_and(|r| r < cfg.rerank_top_k) {
                recall_at_k += 1;
            } else {
                recall_miss_rows.push(format!(
                    "  R@k MISS [{:<10}] want={} stage-1 rank={} :: {}",
                    c.kind,
                    c.want,
                    rank.map_or_else(|| "absent".to_string(), |r| r.to_string()),
                    c.prompt
                ));
            }
            if ids.iter().any(|id| id == &c.want) {
                tp += 1;
            } else {
                fn_ += 1;
                fn_rows.push(format!(
                    "  FN [{:<10}] want={} got=[{}] :: {}",
                    c.kind,
                    c.want,
                    ids.join(", "),
                    c.prompt
                ));
            }
        }
    }

    println!("\n=== eval: {} ===", path);
    println!(
        "positives {n_pos}: recall {tp}/{n_pos} ({:.0}%)   misses {fn_}",
        pct(tp, n_pos)
    );
    println!(
        "negatives {n_neg}: false-inject {fp}/{n_neg} ({:.0}%)   clean {tn}",
        pct(fp, n_neg)
    );
    // Headline: recall recovered, net of discounted FP harm. Optimise this — not
    // FP count — because a strong host filters false injects (see module docs).
    let recall_rate = if n_pos == 0 {
        0.0
    } else {
        tp as f32 / n_pos as f32
    };
    let fp_rate = if n_neg == 0 {
        0.0
    } else {
        fp as f32 / n_neg as f32
    };
    println!(
        "host-value {:.0}%  (= recall {:.0}% - {FP_HARM} * fp {:.0}%; FP discounted: a strong host ignores false injects)",
        100.0 * (recall_rate - FP_HARM * fp_rate),
        100.0 * recall_rate,
        100.0 * fp_rate,
    );
    println!(
        "stage-1 (pre-rerank, k={}): recall@k {recall_at_k}/{n_pos} ({:.0}%)   top-1 {stage1_top1}/{n_pos} ({:.0}%)",
        cfg.rerank_top_k,
        pct(recall_at_k, n_pos),
        pct(stage1_top1, n_pos),
    );
    if !recall_miss_rows.is_empty() {
        println!(
            "--- stage-1 recall@k misses (gold below top-{}) ---",
            cfg.rerank_top_k
        );
        recall_miss_rows.iter().for_each(|r| println!("{r}"));
    }
    if !fn_rows.is_empty() {
        println!("--- recall misses ---");
        fn_rows.iter().for_each(|r| println!("{r}"));
    }
    if !fp_rows.is_empty() {
        println!("--- false injections ---");
        fp_rows.iter().for_each(|r| println!("{r}"));
    }
    Ok(())
}

Trait Implementations

impl Clone for Config

fn clone(&self) -> Config

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Config

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for Config

fn default() -> Self

The Claude-scoped config. ski index/why (and the eval harness) default here; the hot paths build Config::for_host from their --host flag.