Struct ResolvedExecutionSnapshot 

pub struct ResolvedExecutionSnapshot {

    pub session_id: SessionId,
    pub workspace_id: WorkspaceId,
    pub harness_id: HarnessId,
    pub agent_id: Option<AgentId>,
    pub organization_id: String,
    pub instructions: Option<String>,
    pub default_model_id: Option<ModelId>,
    pub capabilities: Vec<CapabilityRef>,
    pub tools: Vec<ToolDefinition>,
    pub initial_files: Vec<InitialFile>,
    pub mcp_servers: BTreeMap<String, SnapshotMcpServer>,
    pub network_access: Option<NetworkAccessList>,
    pub max_iterations: Option<usize>,
    pub parallel_tool_calls: Option<bool>,
    pub locale: Option<String>,
    pub tags: Vec<String>,
    pub blueprint_id: Option<String>,
    pub blueprint_config: Option<Value>,
    pub cumulative_usage: Option<TokenUsage>,
    pub embedder_metadata: BTreeMap<String, String>,
}

Canonical resolved execution value for one session’s turn execution.

Contains only turn-relevant configuration plus the typed correlation values execution needs. Produced by ResolvedExecutionSnapshot::project — the platform projection boundary where missing, mismatched, or inactive stored records fail before host execution begins.

Field order is fixed and map fields are BTreeMaps, so serialization of equal values is byte-identical (deterministic).

Fields

session_id: SessionId

workspace_id: WorkspaceId

harness_id: HarnessId

agent_id: Option<AgentId>

organization_id: String

Public (org_…) organization id used for execution scoping. This is a correlation value, not the organization record.

instructions: Option<String>

Effective instructions (merged system prompt, session goal included).

default_model_id: Option<ModelId>

Effective model specification; None selects the host default model.

capabilities: Vec<CapabilityRef>

Configured capability references with per-layer config merged.

tools: Vec<ToolDefinition>

Explicitly configured tools (client-side or capability-provided).

initial_files: Vec<InitialFile>

Effective initial workspace files.

mcp_servers: BTreeMap<String, SnapshotMcpServer>

Effective scoped MCP servers, credential values excluded.

network_access: Option<NetworkAccessList>

Effective workspace network policy.

max_iterations: Option<usize>

Maximum reason iterations per turn.

parallel_tool_calls: Option<bool>

Request-level parallel tool calling preference.

locale: Option<String>

tags: Vec<String>

blueprint_id: Option<String>

blueprint_config: Option<Value>

cumulative_usage: Option<TokenUsage>

Cumulative LLM usage projected from the session for turn accounting.

embedder_metadata: BTreeMap<String, String>

Embedder metadata folded from the harness chain (root base, leaf wins).

Implementations

impl ResolvedExecutionSnapshot

pub fn project( harness: &HarnessDefinition, agent: Option<&AgentDefinition>, session: &ExecutionSession, ) -> Result<Self>

Project loaded records into the canonical execution value.

This is the execution projection boundary: it fails when a referenced agent is missing or does not match the session’s agent id. Harness lifecycle and inheritance validation happen one step earlier, at the host loading seam (EVE-881): parent-chain loading, cycle/error handling, and archived/deleted validation run before only the effective, executable HarnessDefinition reaches this projection. Agent lifecycle validation likewise fails at that host seam (EVE-877). Host execution never sees a snapshot built from broken record wiring.

Precedence is applied exactly once, through the same AgentConfigOverlay merge semantics the runtime capability resolution uses: harness → agent → session, leaf wins.

Trait Implementations

impl Clone for ResolvedExecutionSnapshot

fn clone(&self) -> ResolvedExecutionSnapshot

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ResolvedExecutionSnapshot

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for ResolvedExecutionSnapshot

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for ResolvedExecutionSnapshot

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

where __S: Serializer,

Serialize this value into the given Serde serializer.