Struct SkillsConfig 

pub struct SkillsConfig {

    pub paths: Vec<String>,
    pub max_active_skills: NonZero<usize>,
    pub disambiguation_threshold: f32,
    pub min_injection_score: f32,
    pub cosine_weight: f32,
    pub hybrid_search: bool,
    pub bm25_alpha: f32,
    pub learning: LearningConfig,
    pub trust: TrustConfig,
    pub registry: RegistryConfig,
    pub prompt_mode: SkillPromptMode,
    pub two_stage_matching: bool,
    pub confusability_threshold: f32,
    pub rl_routing_enabled: bool,
    pub rl_learning_rate: f32,
    pub rl_weight: f32,
    pub rl_persist_interval: u32,
    pub rl_warmup_updates: u32,
    pub rl_embed_dim: Option<usize>,
    pub query_rewrite_provider: ProviderName,
    pub generation_provider: ProviderName,
    pub generation_timeout_ms: u64,
    pub generation_output_dir: Option<String>,
    pub mining: SkillMiningConfig,
    pub evaluation: SkillEvaluationConfig,
    pub proactive_exploration: ProactiveExplorationConfig,
    pub disambiguate_provider: ProviderName,
    pub semantic_scan: bool,
    pub semantic_scan_provider: ProviderName,
    pub group_structured: bool,
    pub support_similarity_threshold: f32,
    pub subagent_skill_token_budget: NonZero<usize>,
}

Skill discovery and matching configuration, nested under [skills] in TOML.

Controls where skills are loaded from, how they are ranked during retrieval, the RL re-ranking head, NL skill generation, and automated skill mining.

Example (TOML)

[skills]
paths = ["~/.config/zeph/skills"]
max_active_skills = 5
disambiguation_threshold = 0.20
hybrid_search = true
subagent_skill_token_budget = 12000

Fields

paths: Vec<String>

Directories to scan for *.skill.md / SKILL.md files.

max_active_skills: NonZero<usize>

disambiguation_threshold: f32

min_injection_score: f32

cosine_weight: f32

hybrid_search: bool

bm25_alpha: f32

Blend weight for BM25 hybrid retrieval: score = bm25_alpha * cosine_clamped + (1 - bm25_alpha) * bm25_norm.

Only used when hybrid_search = true. Valid range: [0.0, 1.0]. Values outside this range are clamped at load time with a warning. Default: 0.7 (cosine-dominant).

learning: LearningConfig

trust: TrustConfig

registry: RegistryConfig

External skill/plugin registry discovery (zeph skill search/add, zeph plugin search/add), nested under [skills.registry] in TOML (spec-045, #5869).

Off by default: no network call is ever made to a registry unless enabled = true (NFR-001).

prompt_mode: SkillPromptMode

two_stage_matching: bool

Enable two-stage category-first skill matching (requires category set in SKILL.md). Falls back to flat matching when no multi-skill categories are available.

confusability_threshold: f32

Warn when any two skills have cosine similarity ≥ this threshold. Set to 0.0 (default) to disable the confusability check entirely.

rl_routing_enabled: bool

Enable RL routing head for skill re-ranking (disabled by default).

rl_learning_rate: f32

Learning rate for REINFORCE weight updates.

rl_weight: f32

Blend weight: final_score = (1-rl_weight)*cosine + rl_weight*rl_score.

rl_persist_interval: u32

Persist weights every N updates (0 = persist every update).

rl_warmup_updates: u32

Skip RL blending for the first N updates (cold-start warmup).

rl_embed_dim: Option<usize>

Embedding dimension for the RL routing head. Must match the output dimension of the configured embedding provider. Defaults to None → 1536 (text-embedding-3-small output dimension).

query_rewrite_provider: ProviderName

Provider name for optional query rewriting before skill matching.

When set to a non-empty provider name, the query is rewritten via a fast LLM call (5 s timeout) before embedding. The rewritten query is used only for skill matching, not for the conversation. When empty (default), query rewriting is disabled and the raw user query is embedded directly — zero overhead.

generation_provider: ProviderName

Provider name for /skill create NL generation. Empty = primary provider.

generation_timeout_ms: u64

Timeout in milliseconds for /skill create LLM generation. For /skill create this is enforced as a single end-to-end budget covering the initial call and its retry. The background promotion path (GeneratorSkillWriter) reuses the same value as a per-call budget instead (via SkillGenerator::with_generation_timeout_ms), so a generate-with-retry there may take up to 2x this value. Default: 60000 (60 s).

generation_output_dir: Option<String>

Directory where generated skills are written. Defaults to first entry in paths.

mining: SkillMiningConfig

Skill mining configuration.

evaluation: SkillEvaluationConfig

External-feedback skill evaluator configuration (#3319).

proactive_exploration: ProactiveExplorationConfig

Proactive world-knowledge exploration configuration (#3320).

disambiguate_provider: ProviderName

Provider name for skill disambiguation LLM classification calls.

When set, the named provider is used instead of the primary provider for skill disambiguation. Useful to route disambiguation to a cheaper or faster model. When empty (the default), the primary provider is used.

semantic_scan: bool

Enable LLM-backed semantic SKILL.md compliance scan on plugin add.

When true, the agent asks an LLM whether the skill’s declared purpose is consistent with its actual content. Non-compliant skills are rejected with a user-facing error message. PluginError::SemanticViolation is used only by the Stage-1 ephemeral path. Stage-1 regex scan always runs and is advisory regardless of this setting.

Default: false.

semantic_scan_provider: ProviderName

Provider name (from [[llm.providers]]) used for the semantic scan.

When empty (the default), the primary/main provider is used.

group_structured: bool

Enable GoSkills group-structured skill injection.

When true, the top-N matched skills are presented to the LLM as an entry-point + support structure, improving multi-skill task execution. Falls back to flat injection when no pair exceeds support_similarity_threshold.

Default: false.

support_similarity_threshold: f32

Inter-skill cosine similarity threshold for GoSkills grouping.

A candidate skill becomes a support skill when its cosine similarity to the entry point exceeds this value (strict >). Valid range: [0.0, 1.0].

Default: 0.50.

subagent_skill_token_budget: NonZero<usize>

Token budget for skill bodies injected into a sub-agent’s one-shot system prompt.

Sub-agent definitions with an empty skills.include filter inherit every skill in the registry (documented, intentional — see crate::SkillFilter). Unlike the main agent’s per-turn skill matcher, a sub-agent’s skill bodies are injected once, at spawn time, with no relevance ranking and no later opportunity to trim: an unbounded include set can silently blow the turn-1 context budget (#6421). This budget applies only to that empty-include case — a definition with an explicit, hand-curated include list is never capped, since the operator opted into that specific set on purpose. Skill bodies are greedily packed in registry order (alphabetical by skill directory, not relevance-ranked) up to the budget — an over-budget skill is skipped, not a hard stop, so a smaller skill later in the order can still fit — and any skills left out are surfaced via a visible truncation marker rather than silently dropped.

Default: 12000 tokens.

Examples

use std::num::NonZeroUsize;
use zeph_config::Config;

let config = Config::default();
assert_eq!(
    config.skills.subagent_skill_token_budget,
    NonZeroUsize::new(12_000).unwrap()
);

Trait Implementations

impl Debug for SkillsConfig

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for SkillsConfig

fn deserialize<__D>( __deserializer: __D, ) -> Result<SkillsConfig, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<&SkillsConfig> for SkillConfigParams

Extracts the fields Agent::with_skill_config needs from a full [skills] config section — the shape available at src/runner.rs’s and src/daemon.rs’s call sites, which hold the whole Config rather than pre-extracted scalars.

fn from(skills: &SkillsConfig) -> Self

Converts to this type from the input type.

impl Serialize for SkillsConfig

fn serialize<__S>( &self, __serializer: __S, ) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.