Enum ConstraintDef 

pub enum ConstraintDef {
    RequiresWhen {
        field: String,
        when_field: String,
        when_value: String,
        severity: ConstraintSeverity,
    },
    Unique {
        fields: Vec<String>,
        severity: ConstraintSeverity,
    },
    EnumFromNeighbour {
        field: String,
        rel_type: String,
        section: String,
        severity: ConstraintSeverity,
    },
    StatusPropagation {
        field: String,
        value: String,
        rel_type: String,
        direction: PropagationDirection,
        severity: ConstraintSeverity,
    },
}

One declared keep-health constraint on a type — the constraint vocabulary (agent-toolbox plan 07). Declarations travel sealed with the schema package and are rendered on the memstead_schema response at BOTH verbosity levels (a hidden legality condition is a defect class of its own). The kind tag is closed: an unknown kind fails deserialization, so no declaration can load and be silently ignored. Forms land vertically — a form is only declarable once the engine evaluates it.

Variants

RequiresWhen

Form 1 — conditional requirement: field (a metadata field or section key of this type) is required whenever when_field holds when_value (“status: checked requires checked_by”).

Fields

field: String

The field or section that becomes required.

when_field: String

The metadata field whose value triggers the requirement.

when_value: String

The triggering value (validated against when_field’s enum, when it declares one).

severity: ConstraintSeverity

Unique

Form 2 — uniqueness: the tuple of metadata-field values named in fields is unique among entities of this type within one mem. Entities missing any of the fields carry no tuple and are not compared. Defaults to block — the whole point of the declaration is preventing the duplicate at write time.

Fields

fields: Vec<String>

The metadata fields forming the unique tuple (each must be a declared metadata field of this type).

severity: ConstraintSeverity

EnumFromNeighbour

Form 3 — enum-from-neighbour: the legal values of field are the bullet-list entries (- value lines) of the section section on the entity reached from this one via a rel_type edge. A set value with no backing entry in any reached neighbour’s section — including the no-neighbour and missing-section cases, where nothing can back it — is a violation.

Fields

field: String

The metadata field whose values the neighbour enumerates.

rel_type: String

The outgoing rel-type that reaches the enumerating entity.

section: String

The section key on the reached entity whose bullet entries are the legal values.

severity: ConstraintSeverity

StatusPropagation

Form 5 — status propagation: when field on an entity of this type holds value (the terminal value), every entity reaching it — transitively — via rel_type edges in direction is tainted; tainted entities surface as health findings naming their tainting ancestor. Always warn-tier: the taint arises from the ancestor’s later change, so it can never refuse the descendant’s historical write (the loader refuses a block declaration on this form rather than accepting a promise the engine will not keep).

Fields

field: String

The status metadata field on this (the tainting) type.

value: String

The terminal value that starts the taint (validated against field’s enum, when it declares one).

rel_type: String

The rel-type the taint travels along.

direction: PropagationDirection

Which direction reaches the dependents: incoming taints the entities whose rel_type edges point at the terminal entity (and their dependents, transitively); outgoing the entities the terminal entity points at.

severity: ConstraintSeverity

Trait Implementations

impl Clone for ConstraintDef

fn clone(&self) -> ConstraintDef

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ConstraintDef

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for ConstraintDef

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl JsonSchema for ConstraintDef

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

The name of the generated JSON Schema.

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

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

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

Generates a JSON Schema for this type.

fn inline_schema() -> bool

Whether JSON Schemas generated for this type should be included directly in parent schemas, rather than being re-used where possible using the $ref keyword.

impl PartialEq for ConstraintDef

fn eq(&self, other: &ConstraintDef) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl Serialize for ConstraintDef

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for ConstraintDef