Struct RecordReport 

pub struct RecordReport {
    pub recorded: usize,
    pub passed: usize,
    pub commit: String,
    pub working_tree: String,
    pub unknown: Vec<String>,
    pub dropped: Vec<EvidenceDropped>,
    pub ledger: String,
    pub run_record: EvidenceRunRecord,
}

What a recording did: how much of the run reached the ledger, and under what provenance.

The recorder decides nothing, and this report says so. A result no runner in this repository owns is named in unknown rather than written under a guessed identity, and a failure is recorded like a pass — the ledger holds what happened, so passed is a count and never a filter.

use majordomus_cli::capability::builtin::evidence::RecordReport;

let report = RecordReport {
    recorded: 3,
    passed: 2,
    commit: "06fa258913a1b2c3d4e5f60718293a4b5c6d7e8f".to_string(),
    working_tree: "clean".to_string(),
    unknown: vec!["docs/CLAIMS.yaml".to_string()],
    dropped: vec![],
    ledger: majordomus_cli::evidence::LEDGER_PATH.to_string(),
    run_record: serde_json::from_value(serde_json::json!({
        "schema": 1, "id": "local:06fa258913a1:20260926T120000Z", "origin": "local",
        "commit": "06fa258913a1b2c3d4e5f60718293a4b5c6d7e8f", "working_tree": "clean",
        "recorded_at": "2026-09-26T12:00:00Z", "ledger": "repo"
    }))
    .unwrap(),
};
// the failing test is one of the three recorded, not a fourth thing that was dropped
assert_eq!(report.recorded - report.passed, 1);
assert!(report.ledger.starts_with(".ai/repo/"));

let json = serde_json::to_value(&report).unwrap();
assert_eq!(json["unknown"].as_array().unwrap().len(), 1);
assert_eq!(json["working_tree"], "clean");
// a suite-only recording listed nothing, and its document is what it always was
assert!(json.get("dropped").is_none());

Fields

recorded: usize

How many executions were written.

passed: usize

How many of them passed.

commit: String

The commit they were recorded against.

working_tree: String

The tree’s state at the time.

unknown: Vec<String>

Results the run named that no runner in this repository owns.

dropped: Vec<EvidenceDropped>

What the reports held that no claim can name yet: the crate’s unit-test binary, its doctests. Listed rather than ignored, and absent from the document when empty.

ledger: String

Where the ledger was written: the path of the target the recording named.

run_record: EvidenceRunRecord

The recording as a typed run.

Trait Implementations

impl Clone for RecordReport

fn clone(&self) -> RecordReport

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for RecordReport

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

Formats the value using the given formatter.

impl JsonSchema for RecordReport

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 Serialize for RecordReport

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

where __S: Serializer,

Serialize this value into the given Serde serializer.