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,
    },
    Trace {
        run_id: TraceRunId,
        root_target: SigId,
    },
    ProducerBlock {
        tool_id: String,
        reason: String,
        blocked_at: u64,
    },
    ProducerUnblock {
        tool_id: String,
        reason: String,
        unblocked_at: u64,
    },
    RepairHint {
        failed_op_id: OpId,
        errors: Value,
        suggested_transform: Option<Value>,
    },
    RepairAttempt {
        hint_id: OpId,
        outcome: String,
        applied_op_id: Option<OpId>,
    },
    ProducerTrust {
        tool_id: String,
        score_thousandths: u32,
        evidence: String,
        granted_by: String,
    },
    TrustWaived {
        producer: String,
        score_thousandths: u32,
        threshold_thousandths: u32,
        kind_tag: String,
    },
    CapsuleInstall {
        artifact: String,
        content_hash: ContentHash,
        signer: String,
        effective_grant: 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

Trace

lex run --trace finalized a [lex_trace::TraceTree] (#246). Links the trace blob to the stage that was the run’s entry point. The trace itself stays at <store>/traces/<run_id>/trace.json (per docs/design/trace-vs-vcs.md); this attestation is the audit-side hook so lex attest filter --kind trace and cross-store sync can reason about runs without copying the trace bytes.

root_target is the entry function’s SigId — the call site the user (or agent) typed on the command line. Distinct from Attestation::stage_id, which records the content-addressed stage the entry function resolved to; the same root_target across multiple body edits surfaces as multiple (stage_id, root_target) rows in the attestation log.

Fields

run_id: TraceRunId

root_target: SigId

ProducerBlock

Retroactive producer quarantine (#248). Declares “as of blocked_at, attestations produced by tool_id are no longer trusted; the branch advance gate must refuse to move past any op whose attestations were produced by this tool at or after blocked_at.”

Distinct from policy.json’s blocked_producers (#181): that is a forward-going read-time tag for the activity feed; this is a write-time gate on branch advance, retro- active to a specific timestamp. The two compose cleanly — blocked_producers filters what reviewers see; ProducerBlock stops a compromised tool’s history from being promoted past a known-bad point.

Stored at the attestation log under stage_id == tool_id so the by-stage index doubles as a by-tool lookup for these records — no schema break, no separate index needed. Attestation::stage_id carries the tool_id for these records; the variant payload duplicates it for clarity in the JSON.

Fields

tool_id: String

reason: String

blocked_at: u64

ProducerUnblock

Counterpart to AttestationKind::ProducerBlock (#248). The attestation log is append-only, so revoking a producer block is a separate, later fact rather than a delete. The branch advance gate honors the most recent verdict for each tool_id by timestamp.

Fields

tool_id: String

reason: String

unblocked_at: u64

RepairHint

Auto-emitted by Store::apply_operation_checked when an op is rejected for TypeError (#281). Records the failed op’s id, the structured type-error envelope, and an optional suggested-transform payload (left empty by the gate; the lex repair --apply flow populates it via LLM call). The hint is attached to the candidate stage that didn’t typecheck, so lex_vcs::AttestationLog::list_for_stage surfaces it on the next read.

Schema: errors and suggested_transform are serde_json::Value to keep this crate independent of lex-types::TypeError (which lives downstream) and to let the slice-2 LLM integration ship without a schema bump.

Fields

failed_op_id: OpId

errors: Value

suggested_transform: Option<Value>

RepairAttempt

Records one iteration of lex repair --apply (#281). The repair loop emits a chain of RepairAttempts — one per applied transform — so the audit trail walks the agent’s fix progression.

Fields

hint_id: OpId

outcome: String

Outcome tag: passed / failed / skipped.

applied_op_id: Option<OpId>

ProducerTrust

Positive trust signal for a producer (#293). Complement to Self::ProducerBlock. Computed from a producer’s recent history of (passed, failed, inconclusive) attestations; not manually set. score_thousandths is in [0, 1000] (representing 0.0 .. 1.0); fixed-point because AttestationKind is Eq for content-addressed hashing, which f64 doesn’t implement. Consumers (the required_attestations gate) may waive a requirement when the latest score for a tool exceeds a configured threshold in policy.required_attestations[].skip_if_producer_trust_thousandths_above.

Refuses to grant trust to a tool with an active ProducerBlock (the hard veto wins).

Stored under stage_id == tool_id so the by-stage index doubles as a per-tool lookup — same trick ProducerBlock uses.

Fields

tool_id: String

score_thousandths: u32

Score × 1000, clamped to [0, 1000]. Derived from passed / (passed + failed + inconclusive) over the last window attestations from this tool.

evidence: String

Free-form reference to the evidence corpus the score was derived from — e.g. “window=1000 as of <head_op>”.

granted_by: String

TrustWaived

Records that the required_attestations gate waived a requirement because the producer’s ProducerTrust score exceeded the configured threshold (#293). Audit signal — not load-bearing for gate decisions, but ensures every skip is recoverable from the attestation log.

Fields

producer: String

Tool whose trust score caused the waiver.

score_thousandths: u32

Latest score (× 1000) consulted at gate time.

threshold_thousandths: u32

Threshold (× 1000) from the policy rule.

kind_tag: String

Which required-attestation kind tag was skipped (e.g. spec, type_check).

CapsuleInstall

A capsule installed cleanly under lex-os (lex-os#36 / #38). Promotes the tamper-evident CapsuleInstalled record from a lex-os capsule install --audit-out log into a durable, content-addressed attestation, via lex attest import-install.

In the capsule distribution model the publisher’s signing key is the producer identity, so these records are stored under stage_id == signer and carry produced_by.tool == signer — the same convention ProducerBlock / ProducerTrust use. That makes a publisher’s install track record feed recompute_producer_trust (which scores produced_by.tool) and, through it, the trusted-keys keyring that capsule install --trusted-keys consumes. The loop closes: install → attestation → earned trust → keyring → next install.

Fields

artifact: String

name@version label of the installed artifact.

content_hash: ContentHash

Hex SHA-256 of the published archive bytes — the publish-time identity of exactly which bytes installed. Empty when imported from a pre-content-hash audit log.

signer: String

The publisher’s Ed25519 public key (hex): the verified signer of the capability contract. Duplicated from stage_id / produced_by.tool for clarity in the JSON.

effective_grant: String

The grant the box actually ran at — meet(consumer, requires), pretty-printed.

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 Eq for AttestationKind

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 StructuralPartialEq for AttestationKind