Struct SkillRegistry 

pub struct SkillRegistry { /* private fields */ }

In-memory skill index.

Implementations

impl SkillRegistry

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

pub async fn register(&mut self, skill: Skill)

Register a skill in the in-memory index, and persist it when a database is configured.

Persistence is NOT gated on the embedder

This previously read if let (Some(db), Some(vm)) = …, so a host with a database but no VectorMatcher persisted nothing — silently, with no error, because the tuple pattern simply did not match. Measured on the embedded path: 3 skills discovered, 0 rows written.

That is the embedded case, which has no embedding service by definition, so the platform R1 exists for was exactly the one that never reached the database. Any consumer reading skills from persistence — the admin UI, the REST API, a mobile host — saw an empty catalogue from a process that looked healthy.

An embedding is an enrichment for vector search. Failing to compute one is not a reason to discard the skill, so the two concerns are now independent: persist whenever there is a database, and attach an embedding when one can be produced.

pub fn register_loaded(&mut self, skill: Skill)

Register a skill that has already been loaded from durable storage.

Startup hydration must not re-persist or eagerly embed every skill. In addition to duplicating storage writes, doing so makes the UAR listener depend on optional ONNX initialization. Embeddings are created only by explicit mutations or when an embedding-backed operation is requested.

There is a second reason this must not route through Self::register: save_skill upserts embedding = EXCLUDED.embedding, so a host with no VectorMatcher would overwrite a good stored embedding with an empty one on every restart — silently degrading vector search on a database that was previously fine. Load and save are separate operations, not one operation that happens to be idempotent when an embedder is configured.

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

Bulk register skills, persisting each one.

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

Register built-ins while preserving durable enabled-state configuration.

Pack metadata is refreshed from skills, but a persisted row remains authoritative for its global and scoped enabled values. The durable catalogue is read once for the batch so startup does not perform one full-table read per built-in.

pub fn register_all_loaded(&mut self, skills: Vec<Skill>)

Hydrate a batch that already belongs to a configured storage provider.

pub fn get(&self, id: &str) -> Option<&Skill>

Look up a skill by ID.

pub fn list(&self) -> Vec<Skill>

List all registered skills.

pub fn list_enabled(&self) -> Vec<Skill>

List only enabled skills.

pub fn toggle(&mut self, id: &str, enabled: bool) -> bool

Toggle a skill’s enabled state.

pub fn remove(&mut self, id: &str) -> Option<Skill>

Remove a skill from the registry.

pub fn clear(&mut self)

Clear all skills.

pub fn len(&self) -> usize

Get the count of registered skills.

pub fn is_empty(&self) -> bool

Check if the registry is empty.

pub fn find_by_keyword(&self, query: &str) -> Vec<Skill>

Find skills matching a query (fallback keyword search).

pub async fn find_matches(&self, query: &str) -> Vec<Skill>

Vector-based skill matching (uses persistence + VectorMatcher).

pub async fn find_candidates(&self, query: &str) -> Vec<SkillCandidate>

Preserve real similarity scores for thresholding and shadow telemetry.

Trait Implementations

impl Clone for SkillRegistry

fn clone(&self) -> SkillRegistry

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for SkillRegistry

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

Formats the value using the given formatter.

impl Default for SkillRegistry

fn default() -> Self

Returns the “default value” for a type.