Struct SkillTrustGate 

pub struct SkillTrustGate { /* private fields */ }

Shared registry + trust-snapshot pair backing both skill-body tool executors.

Cloning is cheap — all fields are Arcs (TurnTrustFloor wraps one internally). Construct one instance per executor from the same trust_snapshot Arc (and the same turn_trust_floor, when available) so load_skill and invoke_skill see identical trust state within a turn.

Implementations

impl SkillTrustGate

pub fn new( registry: Arc<RwLock<SkillRegistry>>, trust_snapshot: Arc<RwLock<HashMap<String, SkillTrustSnapshot>>>, ) -> Self

Build a gate over registry and trust_snapshot, with no turn trust floor wired.

Equivalent to with_turn_trust_floor with None — prefer that constructor when a live agent turn’s floor is available so a Quarantined body read degrades the turn’s trust (#6701, RC-3).

Examples

use std::collections::HashMap;
use std::sync::Arc;

use parking_lot::RwLock;
use zeph_core::SkillTrustGate;
use zeph_skills::registry::SkillRegistry;

let registry = Arc::new(RwLock::new(SkillRegistry::empty()));
let trust_snapshot = Arc::new(RwLock::new(HashMap::new()));
let _gate = SkillTrustGate::new(registry, trust_snapshot);

pub fn with_turn_trust_floor(self, turn_trust_floor: TurnTrustFloor) -> Self

Build a gate over registry and trust_snapshot, wired to the given turn trust floor.

turn_trust_floor should be the same handle TrustGateExecutor::trust_floor() returns for the live agent turn, so an explicit invoke_skill/load_skill of a Quarantined skill folds the turn’s trust floor down (#6701, RC-3) instead of leaving the gate’s weakest-link fold blind to bodies read outside the proactive-activation path.

pub async fn resolve_body( &self, skill_name: &str, ) -> Result<SkillBodyResolution, ToolError>

Resolve skill_name through the trust pipeline shared by load_skill and invoke_skill: refuse Blocked before any body read, re-check integrity when requires_trust_check is set, then sanitize/wrap the body per trust level.

A missing trust-snapshot row resolves to SkillTrustLevel::MISSING_ENTRY_FALLBACK (Trusted) — “never classified”, not “known untrusted”. skill_name is sanitized before it appears in any returned message, including the not-found path.

Errors

Returns an error only when the requires_trust_check integrity re-check’s spawn_blocking task panics or is cancelled — a hash mismatch, missing skill directory, or unreadable SKILL.md are reported as Ok(SkillBodyResolution::Refused(_)), not Err.

Examples

let registry = Arc::new(RwLock::new(SkillRegistry::empty()));
let trust_snapshot = Arc::new(RwLock::new(HashMap::new()));
let gate = SkillTrustGate::new(registry, trust_snapshot);

match gate.resolve_body("nonexistent").await.unwrap() {
    SkillBodyResolution::NotFound(message) => assert!(message.contains("nonexistent")),
    _ => panic!("expected NotFound for an empty registry"),
}

Trait Implementations

impl Clone for SkillTrustGate

fn clone(&self) -> SkillTrustGate

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for SkillTrustGate

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

Formats the value using the given formatter.