Struct EconomicsRun 

pub struct EconomicsRun {

    pub schema: String,
    pub id: String,
    pub suite: String,
    pub suite_version: u32,
    pub methodology: u32,
    pub task: String,
    pub variant: String,
    pub repetition: u32,
    pub provider: String,
    pub harness: EconomicsHarness,
    pub model_requested: String,
    pub models_reported: Vec<String>,
    pub repository: EconomicsRevision,
    pub majordomus_version: String,
    pub fixture_digest: String,
    pub inputs_digest: String,
    pub configuration_digest: String,
    pub started_at: String,
    pub finished_at: String,
    pub sessions: Vec<EconomicsSession>,
    pub outcome: EconomicsOutcome,
}

One recorded run: a task, one variant, one repetition, every session of it. Raw facts only; nothing here is derived from another field.

use majordomus_cli::economics::model::EconomicsRun;
let run: EconomicsRun = serde_json::from_value(serde_json::json!({
    "schema": "economics-run/v1", "id": "vat-rounding--baseline--r1", "suite": "pilot",
    "suite_version": 1, "methodology": 1, "task": "vat-rounding", "variant": "baseline",
    "repetition": 1, "provider": "anthropic",
    "harness": { "name": "claude-code", "version": "2.0.1" },
    "model_requested": "claude-sonnet-5", "models_reported": ["claude-sonnet-5"],
    "repository": { "commit": "8d37d011ef", "dirty": false }, "majordomus_version": "0.7.0",
    "fixture_digest": "f0", "inputs_digest": "i0", "configuration_digest": "c0",
    "started_at": "2026-09-24T10:00:00Z", "finished_at": "2026-09-24T10:05:00Z",
    "sessions": [], "outcome": { "completed": false, "checks": [], "changed_files": [] }
}))
.unwrap();
assert_eq!(run.id, format!("{}--{}--r{}", run.task, run.variant, run.repetition));

Fields

schema: String

economics-run/v1.

id: String

<task>--<variant>--r<repetition>.

suite: String

The suite.

suite_version: u32

The suite’s version.

methodology: u32

The methodology version.

task: String

The task.

variant: String

The variant.

repetition: u32

1-based.

provider: String

The provider.

harness: EconomicsHarness

The harness.

model_requested: String

The model the harness was asked for.

models_reported: Vec<String>

The models the harness reported using, sorted.

repository: EconomicsRevision

The repository revision.

majordomus_version: String

The Majordomus version the treatment was installed from.

fixture_digest: String

Digest of the fixture, setup patch and task declaration the run started from.

inputs_digest: String

Digest of the suite’s freshness inputs when the run was recorded.

configuration_digest: String

Digest of the harness invocation (flags, settings), the prompt excepted.

started_at: String

When the first session started, UTC.

finished_at: String

When the verification finished, UTC.

sessions: Vec<EconomicsSession>

The sessions.

outcome: EconomicsOutcome

The success gates’ verdict.

Trait Implementations

impl Clone for EconomicsRun

fn clone(&self) -> EconomicsRun

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for EconomicsRun

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for EconomicsRun

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl JsonSchema for EconomicsRun

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 EconomicsRun

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

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 EconomicsRun