Struct EconomicsContextRun 

pub struct EconomicsContextRun {
    pub schema: String,
    pub suite: String,
    pub suite_version: u32,
    pub methodology: u32,
    pub repository: EconomicsRevision,
    pub majordomus_version: String,
    pub tokenizer: EconomicsTokenizer,
    pub inputs_digest: String,
    pub budget_tokens: u64,
    pub measured_at: String,
    pub seeds: Vec<EconomicsContextSeed>,
    pub refused: Vec<String>,
}

One recorded measurement of the context suite: every seed the compiler compiled, counted, and every seed it refused, named with its reason rather than dropped.

use majordomus_cli::economics::model::EconomicsContextRun;
let run: EconomicsContextRun = serde_json::from_value(serde_json::json!({
    "schema": "economics-context-run/v1", "suite": "context", "suite_version": 1,
    "methodology": 1, "repository": { "commit": "8d37d011ef", "dirty": false },
    "majordomus_version": "0.7.0",
    "tokenizer": { "encoding": "o200k_base", "implementation": "tiktoken-rs 0.12.0" },
    "inputs_digest": "i0", "budget_tokens": 8000, "measured_at": "2026-09-24T10:00:00Z",
    "seeds": []
}))
.unwrap();
assert_eq!(run.tokenizer.encoding, "o200k_base");
assert!(run.seeds.is_empty());
assert!(run.refused.is_empty(), "a record from before refusals were kept reads as none");
let json = serde_json::to_value(&run).unwrap();
assert_eq!(json["refused"], serde_json::json!([]), "a new record says none explicitly");

Fields

schema: String

economics-context-run/v1.

suite: String

The suite.

suite_version: u32

The suite’s version.

methodology: u32

The methodology version.

repository: EconomicsRevision

The repository revision measured.

majordomus_version: String

The Majordomus version that compiled the contexts.

tokenizer: EconomicsTokenizer

The tokenizer.

inputs_digest: String

Digest of the suite’s freshness inputs when measured.

budget_tokens: u64

The compiler’s budget, in its own units.

measured_at: String

When measured, UTC.

seeds: Vec<EconomicsContextSeed>

One entry per seed, sorted by seed.

refused: Vec<String>

The seeds the compiler refused, each with the reason it gave (I0042: no such issue). They were not measured, so they are in no count above; they are kept here so that a ratio over the seeds that compiled is never read as one over every seed. A record written before this field existed reads as an empty list.

Trait Implementations

impl Clone for EconomicsContextRun

fn clone(&self) -> EconomicsContextRun

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for EconomicsContextRun

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for EconomicsContextRun

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl JsonSchema for EconomicsContextRun

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 Ordered for EconomicsContextRun

A context measurement orders by when it was taken, then by the commit it measured, never by its file name, so the last one is the latest. measured_at is a UTC RFC 3339 timestamp at whole seconds, whose digit runs have fixed widths, so the natural order reads it chronologically.

fn order_key(&self) -> OrderKey<'_>

The four parts this item is ordered by. Borrowed from the item: building a key allocates nothing, so sorting a large collection costs the comparisons and no more.

impl PartialEq for EconomicsContextRun

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

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 EconomicsContextRun