Struct ServerExecutionResult 

pub struct ServerExecutionResult {

    pub success: bool,
    pub flow_name: String,
    pub source_file: String,
    pub backend: String,
    pub steps_executed: usize,
    pub latency_ms: u64,
    pub tokens_input: u64,
    pub tokens_output: u64,
    pub anchor_checks: usize,
    pub anchor_breaches: usize,
    pub errors: usize,
    pub step_names: Vec<String>,
    pub step_results: Vec<String>,
    pub trace_id: u64,
    pub effect_policies: Vec<(String, String)>,
    pub enforcement_summaries: Vec<(String, EnforcementSummaryWire)>,
    pub runtime_warnings: Vec<RuntimeWarning>,
    pub provenance_events: Vec<String>,
    pub blame_attribution: Option<BlameContext>,
    pub epistemic_envelopes: Vec<EpistemicEnvelope>,
    pub error: Option<String>,
    pub temporal_context: Option<TemporalRecord>,
}

Server-side execution result.

§Fase 39.b — promoted from struct to pub struct (and all fields to pub) so the new crate::wire_envelope::FlowEnvelope module can consume it as the converter input. Pre-39.b this type was internal to axon_server; v2.0.0 elevates it to a crate-public shape because it is the canonical input of the wire envelope builder. It is intentionally NOT part of the JSON wire (the FlowEnvelope is); it remains a runtime-internal aggregation step.

Fields

success: bool

flow_name: String

source_file: String

backend: String

steps_executed: usize

latency_ms: u64

tokens_input: u64

tokens_output: u64

anchor_checks: usize

anchor_breaches: usize

errors: usize

step_names: Vec<String>

step_results: Vec<String>

trace_id: u64

effect_policies: Vec<(String, String)>

§Fase 33.e — Per-step stream-effect policies declared in the source. Each entry is (step_name, policy_slug) where slug is one of the closed catalog {drop_oldest, degrade_quality, pause_upstream, fail}. Empty when no step in the flow declares a <stream:<policy>> effect. Surfaced on the SSE axon.complete wire envelope so adopters can observe the policy is bound to runtime.

enforcement_summaries: Vec<(String, EnforcementSummaryWire)>

§Fase 33.x.d — Per-step EnforcementSummary from the StreamPolicyEnforcer runs. Empty in two cases:

1. Legacy synchronous path (deleted in 33.z.e) — the enforcer is not run; the wire stays byte-identical with v1.24.0 (D4 byte-compat).
2. Async streaming path where no step in the flow has a declared <stream:<policy>> effect — the enforcer is not constructed (no policy to enforce); D2 contract. Surfaced on the SSE axon.complete wire envelope so adopters can observe whether the declared policy actually fired in production (a drop_oldest policy that never fires under sustained load is a configuration smell).

runtime_warnings: Vec<RuntimeWarning>

§Fase 33.x.g — Closed-catalog runtime warnings. Populated only when server_execute_streaming falls back to the legacy synchronous path; carries one axon-W002 streaming-not-supported warning with the specific FallbackMode tag identifying WHY. Empty on the happy (async-streaming-active) path = D4 byte-compat preserved (wire field elided when empty).

provenance_events: Vec<String>

§Fase 39.c.y — semantic provenance events from the runtime walk (retrieve:<store>, shield:<name>, mutate:<store>, etc.). Merged into the FlowEnvelope.provenance_chain by the converter. Empty for flows with no taxonomy-participating steps.

blame_attribution: Option<BlameContext>

§Fase 39.c.z — surfaced blame attribution when the flow proceeded on degraded posture (anchor breach / shield rejection / store breach / backend soft-fail / type mismatch). None on clean happy path; the converter writes this slot into the wire envelope’s blame_attribution field verbatim.

epistemic_envelopes: Vec<EpistemicEnvelope>

§Fase 55.b — per-tool epistemic envelopes (base, scope, confidence) for every flow-level use <Tool> whose tool declares an epistemic:<level> effect. Propagated from the runner’s IR-derived capture and written into FlowEnvelope.epistemic_envelopes by the converter; the streaming path derives the identical set via resolve_epistemic_envelopes_for_flow. Empty (and elided from the wire) for flows that dispatch no epistemic-annotated tool.

error: Option<String>

§Fase 65.F — the HONEST hard-failure detail when a node’s DispatchError aborted the non-streaming flow (a failing persist/mutate/purge store write, a backend error, etc.): Some("flow 'F' failed at persist into 'S': <cause>"), naming the failing node + the underlying cause. Byte-parity with the streaming dispatcher’s FlowError.error (§37.e/D6). None on the clean path; the converter writes this slot into FlowEnvelope.error verbatim and counts it as one errors so the wire envelope’s certainty bounds to the derived ceiling. Closes the §65.E.2 silent-abort regression (a pre-insert store failure used to present as success:false + empty result + zero diagnostic). Elided from the wire when None.

temporal_context: Option<TemporalRecord>

§Fase 91.b — the run’s temporal record when any step rendered a declared now: (captured_utc + tzdb_version + zones — the replayability triple of time_is_an_explicit_input, §71/§91). The converter writes it into FlowEnvelope.temporal_context verbatim. None — and elided from the wire — for every now:-less flow, so every pre-§91 envelope stays byte-identical.

Trait Implementations

impl Clone for ServerExecutionResult

fn clone(&self) -> ServerExecutionResult

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ServerExecutionResult

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

Formats the value using the given formatter.

impl Serialize for ServerExecutionResult

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

where __S: Serializer,

Serialize this value into the given Serde serializer.