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 decided(question: impl Into<String>) -> Self

The caller’s current turn settles the declared question question: a boolean answered yes, a choice that picked an option, or a score. See decided.

pub fn decided_no(question: impl Into<String>) -> Self

The caller’s current turn answers the boolean question no (or a choice picks “none of these”).

pub fn decided_is( question: impl Into<String>, option: impl Into<String>, ) -> Self

The caller’s current turn picks option for the choice question.

pub fn decided_at_least(question: impl Into<String>, bound: f64) -> Self

The score question is at least bound.

pub fn decided_at_most(question: impl Into<String>, bound: f64) -> Self

The score question is at most bound.

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 possible(&self, ctx: &FlowCtx<'_>) -> Option<bool>

Evaluate the guard as the caller’s next words could leave it: every decided atom unknown, since its question is asked again about each turn. Some(value) when no decision can change the outcome, None when one could make the guard hold or fail. A custom guard is evaluated as it stands.

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.

pub fn decisions(&self) -> BTreeSet<String>

The questions this guard’s decided atoms name.

pub fn state_keys(&self) -> BTreeSet<String>

The state keys this guard reads (is_true/is_set/eq/captured atoms). A custom guard reads nothing that can be named, so it reports none.

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.