Struct FileConfig 

pub struct FileConfig {

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

User overrides parsed from ~/.config/ski/config.toml. Every field is optional; an absent field — or an absent/malformed file — leaves the compiled default untouched. Parsing fails open: a malformed file yields an empty overlay (all defaults) rather than an error, so a bad config can never block injection. Unknown keys are ignored (a typo drops one field, not the file).

Fields

model: Option<String>

min_similarity: Option<f32>

score_margin: Option<f32>

max_skills: Option<usize>

char_budget: Option<usize>

keyword_boost: Option<f32>

phrase_boost: Option<f32>

roots: Option<Vec<PathBuf>>

inject_mode: Option<String>

directive_strength: Option<String>

deny: Option<Vec<String>>

force: Option<Vec<String>>

context_depth: Option<usize>

context_weight: Option<f32>

vague_lo: Option<f32>

vague_hi: Option<f32>

file_boost: Option<f32>

project_boost: Option<f32>

recall_floor: Option<f32>

high_conf: Option<f32>

clear_gap: Option<f32>

rerank_top_k: Option<usize>

rerank_min: Option<f32>

rerank_margin: Option<f32>

body_inject_min: Option<f32>

lexical_min: Option<f32>

lexical_margin: Option<f32>

telemetry: Option<bool>

Implementations

impl FileConfig

pub const KEYS: &'static [&'static str]

Every key the overlay understands, in struct order. Used by ski doctor to flag typos: unknown keys are silently ignored at runtime (by design), so a misspelled deny never applies and nothing says why. Adding a field to the struct? Add its key here (the keys_cover_the_struct test below catches a miss).

pub fn load() -> Self

Parse the user config, or an empty (all-default) overlay when the file is missing. Still fail-open on a malformed file (never blocks injection), but — unlike a missing file, which is a normal, silent no-op — a present but unparseable file means the user’s overrides (deny, a tuned rerank_min, …) are being silently ignored, which is worth a one-line stderr warning (with the parse location) so they can find out without already knowing to set SKI_DEBUG.

pub fn apply(&self, cfg: &mut Config)

Overlay every present field onto cfg. roots is ignored while the SKI_ROOTS env override is active (env wins, for evals/tooling). Unknown inject_mode/directive_strength strings are ignored, keeping the default.

pub fn apply_cosine(&self, cfg: &mut Config)

Re-assert just the cosine thresholds. Config::calibrate_to overwrites min_similarity/score_margin from the embedder, so a user pin must be applied after calibration to survive.

Examples found in repository

examples/eval.rs (line 149)

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 FileConfig

fn clone(&self) -> FileConfig

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for FileConfig

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

Formats the value using the given formatter.

impl Default for FileConfig

fn default() -> FileConfig

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for FileConfig

where FileConfig: Default,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.