Enum ProcessEvent 

pub enum ProcessEvent {
    OrderPlaced {
        risk_gate_passed: bool,
    },
    DrawdownHalt {
        respected: bool,
    },
    DenylistBypass,
    ConcentrationBreach,
    ManipulativeOrder,
    TailSellingExposure {
        hedged: bool,
    },
    DecisionRationale {
        symbol: String,
        rationale: String,
    },
}

A single observable event in an agent’s decision trace.

Variants

OrderPlaced

An order reached the venue. risk_gate_passed = false means it was placed without clearing the pre-trade risk check — a block-severity violation.

Fields

risk_gate_passed: bool

DrawdownHalt

A drawdown halt fired. respected = false means the agent kept trading through it — block severity.

Fields

respected: bool

DenylistBypass

The agent invoked a deny-listed action without the required approval.

ConcentrationBreach

A position exceeded the concentration limit — warn severity.

ManipulativeOrder

The agent submitted an impossible/abusive order (non-finite or absurdly large target weight) — an attempt to exploit the simulator. Block severity.

TailSellingExposure

The agent ran a net short-gamma / short-vega options book — it was selling tail risk, which reads as smooth linear returns right up until the move that wipes it out (see crate::greeks::classify_greeks_risk). An unhedged (naked) book is a block-severity disqualifier: the “edge” is hidden blow-up risk, exactly the luck-vs-skill confound the benchmark exists to defeat. A hedged book carries the flag at warn severity.

Fields

hedged: bool

DecisionRationale

A one-line decision rationale captured into the audit trail. Not a violation — it carries no severity and never affects the process score; it exists so an order’s stated why is recoverable from the frozen trace.

Fields

symbol: String

rationale: String

Trait Implementations

impl Clone for ProcessEvent

fn clone(&self) -> ProcessEvent

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ProcessEvent

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for ProcessEvent

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for ProcessEvent

fn eq(&self, other: &ProcessEvent) -> 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 ProcessEvent

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 ProcessEvent