Enum Guard 

pub enum Guard {
    Spec(Pred),
    Custom(Arc<dyn Fn(&FlowCtx<'_>) -> bool + Send + Sync>),
}

A boolean predicate over (state, marking) — the only predicate type.

Use the constructors (Guard::is_true, Guard::captured, Guard::called_ok, …) for the serializable closed atoms, or Guard::custom for a bespoke closure (not serializable).

Variants

Spec(Pred)

A serializable predicate built from the closed atom set.

Custom(Arc<dyn Fn(&FlowCtx<'_>) -> bool + Send + Sync>)

A code-only escape hatch. Not serializable.

Implementations

impl Guard

pub fn always() -> Self

Always true.

pub fn is_true(key: impl Into<String>) -> Self

State key holds boolean true.

pub fn is_set(key: impl Into<String>) -> Self

State key is present.

pub fn eq(key: impl Into<String>, value: impl Into<Value>) -> Self

State key equals the given JSON value.

pub fn captured<I, S>(fields: I) -> Self

where I: IntoIterator<Item = S>, S: Into<String>,

All of the given state keys are present (extracted slots).

pub fn called_ok(tool: impl Into<String>) -> Self

The named tool has completed successfully.

pub fn done(step: impl Into<String>) -> Self

The named step is done.

pub fn resolved(name: impl AsRef<str>) -> Self

True once an orchestrated agent named name has produced a result (its {name}:result state key is set). Pairs with the orchestration call/dispatch/background.

pub fn all(guards: impl IntoIterator<Item = Guard>) -> Self

Conjunction.

If every input is a serializable atom, the result is a serializable Pred::All. If any input is a Guard::custom, the result is itself a custom guard that evaluates the conjunction at runtime — the custom guard is never silently dropped (it merely makes the combinator non-serializable, which surfaces as an error only if you try to serialize the flow).

pub fn any(guards: impl IntoIterator<Item = Guard>) -> Self

Disjunction.

Mirrors Guard::all: custom inputs are preserved as a runtime closure rather than erased.

pub fn not(guard: Guard) -> Self

Negation of a serializable atom.

pub fn describe(&self) -> String

This guard as a short prose clause, for telling a model what a refusal is waiting on.

A refusal that names only the tool leaves the model to guess the precondition, and a wrong guess is indistinguishable from a wrong model: in the governed collections evaluation, record_promise_to_pay was refused with “not available in the current step”, and the model — with nothing else to go on — decided it must need to re-verify the caller and asked for the card digits it had already checked.

pub fn custom(f: impl Fn(&FlowCtx<'_>) -> bool + Send + Sync + 'static) -> Self

A bespoke closure over (state, marking). Not serializable.

pub fn eval(&self, ctx: &FlowCtx<'_>) -> bool

Evaluate the guard.

pub fn eval_state(&self, state: &State) -> bool

Evaluate against state alone, with an empty Marking.

For contexts outside a governed flow (phase transitions, watcher conditions) where no marking exists: called_ok/done atoms evaluate false there — a validator should reject them in such positions.

pub fn explain_trace(&self, ctx: &FlowCtx<'_>) -> GuardTrace

Evaluate to a GuardTrace — the predicate tree with per-node truth values. A Guard::custom yields a single opaque node.

Trait Implementations

impl Clone for Guard

fn clone(&self) -> Guard

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Guard

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Guard

fn deserialize<D: Deserializer<'de>>(d: D) -> Result<Self, D::Error>

Deserialize this value from the given Serde deserializer.

impl JsonSchema for Guard

fn is_referenceable() -> bool

Whether JSON Schemas generated for this type should be re-used where possible using the $ref keyword.

fn schema_name() -> String

The name of the generated JSON Schema.

fn json_schema(generator: &mut SchemaGenerator) -> Schema

Generates a JSON Schema for this type.

fn schema_id() -> Cow<'static, str>

Returns a string that uniquely identifies the schema produced by this type.

impl Serialize for Guard

fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error>

Serialize this value into the given Serde serializer.