Struct SkillService 

pub struct SkillService { /* private fields */ }

Central skill service coordinating storage + matching.

When a [GovernanceEngine] is attached, all skill mutations (updates, prompt overlays) are gated through Cedar policy evaluation before being applied. This enforces the Skill Mutation PEP for the self-learning pipeline.

Implementations

impl SkillService

pub fn new( persistence: Option<Arc<dyn PersistenceLayer>>, vector_matcher: Option<Arc<VectorMatcher>>, ) -> Self

Create a new skill service.

pub fn with_governance(self, engine: Arc<GovernanceEngine>) -> Self

Attach a governance engine for Cedar policy enforcement on skill mutations.

When attached, update_skill checks is_skill_mutation_allowed before applying changes. Without governance, all mutations are permitted.

pub fn add_provider(&mut self, provider: Arc<dyn SkillStorageProvider>)

Add a storage provider.

pub async fn register_builtins(&self, skills: Vec<Skill>)

Register a batch of Skill { kind = Manifest, origin = Builtin } into the registry, persisting each one when a database is configured.

Used at startup by the builtin-loader. Builtins are not written back through the storage providers in Self::initialize — that would make the pack a provider — but they DO reach the persistence layer, which is what the admin UI, the REST API, and embedded hosts read.

This doc comment previously claimed “these skills are not persisted via storage providers”, which read as not persisted at all and matched the behaviour: nothing reached the database. See super::registry::SkillRegistry::register for the defect.

pub async fn initialize(&self) -> Result<()>

Initialize the service by loading skills from all providers.

pub async fn get_skills(&self) -> Vec<Skill>

Get all skills from all providers.

pub async fn get_enabled_skills(&self) -> Vec<Skill>

Get only enabled skills.

pub async fn refresh(&self) -> Result<Vec<Skill>>

Refresh skills from all providers.

pub async fn toggle_skill(&self, id: &str, enabled: bool) -> bool

Toggle a skill’s enabled state.

pub async fn set_scoped_enabled( &self, id: &str, scope: SkillScope, enabled: bool, ) -> bool

Set a durable enabled-state override at one scope.

pub async fn create_skill(&self, skill: Skill) -> Result<Skill>

Create a new skill dynamically via API.

Persists to the database (via the registry’s auto-persist path) and writes a SKILL.md file to the writable filesystem provider so the skill survives pod restarts.

pub async fn update_skill( &self, id: &str, update: SkillUpdate, ) -> Result<Option<Skill>>

Update an existing skill by ID.

Returns Ok(None) if the skill does not exist.

When a [GovernanceEngine] is attached, the mutation is checked against Cedar policies before being applied. The default environment is "development" (all mutations permitted). Set PROMETHEUS_ENVIRONMENT to "staging" or "production" for stricter enforcement.

pub async fn delete_skill_permanent(&self, id: &str) -> Result<bool>

Permanently delete a skill from the registry, database, and filesystem.

Skills with origin = Builtin are immutable; this method returns Err(SystemSkillImmutable) for them so the API layer can map to 409.

pub async fn match_skills( &self, query: &str, agent_id: Option<&str>, ) -> SkillMatchResult

Match skills to a query without treating candidates as activations.

pub async fn match_skills_scoped( &self, query: &str, agent_id: Option<&str>, conversation_id: Option<&str>, ) -> SkillMatchResult

Match after resolving conversation > agent > global enabled state.

pub async fn get_agent_skill_ids(&self, agent_id: &str) -> Vec<String>

Get skill IDs explicitly enabled for an agent.

pub async fn set_agent_skills(&self, agent_id: &str, skill_ids: Vec<String>)

Replace an agent’s durable skill overrides using allowlist semantics.

pub async fn add_skill_to_agent(&self, agent_id: &str, skill_id: &str)

Enable one skill for an agent.

pub async fn remove_skill_from_agent(&self, agent_id: &str, skill_id: &str)

Disable one skill for an agent.

pub async fn get_enabled_skills_for_agent(&self, agent_id: &str) -> Vec<Skill>

Get skills enabled after resolving agent state over global state.

pub async fn get_matching_config(&self) -> SkillMatchingConfig

Get the current matching configuration.

pub async fn set_matching_config(&self, config: SkillMatchingConfig)

Update the matching configuration.

pub fn registry(&self) -> &Arc<RwLock<SkillRegistry>>

Get access to the internal registry.

pub fn providers(&self) -> &[Arc<dyn SkillStorageProvider>]

Get the list of registered providers.

pub async fn evolve_from_run( &self, run_id: &str, tool_call_count: usize, cfg: &SkillEvolutionConfig, ) -> Result<()>

Post-run skill evolution hook (Hermes learning cycle).

Called after a run completes when SkillEvolutionConfig::enabled is true and the run performed at least min_tool_calls tool completions.

Currently this is a no-op stub — a future implementation will:

1. Retrieve the run transcript / tool call log.
2. Fire a reflection prompt via the configured LLM.
3. Parse suggested skill CRUD operations from the response.
4. Apply them subject to allow_update / allow_deletion guards.

Trait Implementations

impl Debug for SkillService

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

Formats the value using the given formatter.