Enum AttestationKind 

pub enum AttestationKind {
    Examples {
        file_hash: ContentHash,
        count: usize,
    },
    Spec {
        spec_id: SpecId,
        method: SpecMethod,
        trials: Option<usize>,
    },
    DiffBody {
        other_body_hash: ContentHash,
        input_count: usize,
    },
    TypeCheck,
    EffectAudit,
    SandboxRun {
        effects: BTreeSet<String>,
    },
    Override {
        actor: String,
        reason: String,
        target_attestation_id: Option<AttestationId>,
    },
    Defer {
        actor: String,
        reason: String,
    },
    Block {
        actor: String,
        reason: String,
    },
    Unblock {
        actor: String,
        reason: String,
    },
}

What was verified. The variants mirror the verdict surfaces lex agent-tool and the store-write gate already produce.

Variants

Examples

lex agent-tool --examples FILE — body was run against {input, expected} pairs.

Fields

file_hash: ContentHash

count: usize

Spec

lex spec check or lex agent-tool --spec FILE — a behavioral contract was checked against the body.

Fields

spec_id: SpecId

method: SpecMethod

trials: Option<usize>

DiffBody

lex agent-tool --diff-body 'src' — a second body was run on the same inputs and the outputs compared.

Fields

other_body_hash: ContentHash

input_count: usize

TypeCheck

Emitted by the store-write gate (#130) on every accepted op. The store can answer “the HEAD typechecks” as a queryable fact rather than an implicit invariant.

EffectAudit

Emitted by lex audit --effect K when no violations are found. Useful as a trust signal that a stage was checked against a specific effect-policy revision.

SandboxRun

Emitted by lex agent-tool on a successful sandboxed run. effects is the set the sandbox actually allowed; useful for answering “did this code run under fs_write?” after the fact.

Fields

effects: BTreeSet<String>

Override

Human-issued override (lex-tea v3, #172). Records that a human took an action that bypassed an automatic verdict — e.g. activating a stage despite a Spec::Failed or TypeCheck::Failed attestation. Subject to the same trust trail as agent attestations: the audit fact lives in the log alongside what it overrode.

actor is the human’s identifier (today: LEX_TEA_USER env var or --actor flag; v3b adds session auth). target_attestation_id points at the attestation being overridden, when one exists; for unconditional pins (e.g. activate-by-default) it can be None.

Fields

actor: String

reason: String

target_attestation_id: Option<AttestationId>

Defer

lex stage defer (lex-tea v3b, #172). Records that a human looked at the stage and chose to revisit it later. No state change — purely an audit/triage signal so dashboards and AI reviewers can see “this isn’t abandoned, it’s snoozed.”

Fields

actor: String

reason: String

Block

lex stage block (lex-tea v3b, #172). Records that a human has decided this stage should not activate. lex stage pin and any other activation path consults the attestation log and refuses while a Block is the latest decision for the stage. Reversed by AttestationKind::Unblock.

Fields

actor: String

reason: String

Unblock

lex stage unblock (lex-tea v3b, #172). Counterpart to AttestationKind::Block. The attestation log is append- only, so we encode “block lifted” as a separate, later fact rather than mutating the original block.

Fields

actor: String

reason: String

Trait Implementations

impl Clone for AttestationKind

fn clone(&self) -> AttestationKind

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for AttestationKind

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for AttestationKind

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for AttestationKind

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for AttestationKind

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for AttestationKind

impl StructuralPartialEq for AttestationKind