Struct ReplayEntry 

pub struct ReplayEntry {
    pub run_id: RunId,
    pub step_ref: String,
    pub input_hash: String,
    pub occurrence: u32,
    pub ctx_snapshot_json: String,
    pub step_output_json: String,
    pub created_at: u64,
}

One persisted row in the replay log — a step’s completion snapshot the dispatcher stored after DispatchOutcome::Pass.

The row’s identity is the 4-tuple (run_id, step_ref, input_hash, occurrence); the SQLite backend enforces this as a UNIQUE constraint. ctx_snapshot_json and step_output_json are the two payloads: the former is a full Ctx serde-JSON with operator dropped by the #[serde(skip)] on that field, and the latter is the DispatchOutcome::Pass value the worker produced (audit + the value the replay hit returns).

Fields

run_id: RunId

The Run this dispatch belonged to (issue #13 hierarchy).

step_ref: String

Blueprint step ref that was dispatched (TaskSpec.agent at the engine boundary).

input_hash: String

Deterministic hex-encoded SHA-256 hash of the resolved input value — see hash_input_value.

occurrence: u32

Zero-based counter for repeated dispatches of the same (run_id, step_ref, input_hash) triple within one Run.

ctx_snapshot_json: String

Serde-JSON of the whole Ctx at the moment the step passed. Ctx.operator is dropped by the #[serde(skip)] on that field — see this module’s doc.

step_output_json: String

Serde-JSON of the DispatchOutcome::Pass value.

created_at: u64

Unix epoch seconds — when this row was recorded.

Implementations

impl ReplayEntry

pub fn from_completion( run_id: RunId, step_ref: impl Into<String>, input_hash: impl Into<String>, occurrence: u32, ctx: &Ctx, step_output: &Value, ) -> Result<Self, ReplayStoreError>

Build a fresh entry from the dispatch-completion state, encoding ctx + step_output to their JSON representations and stamping created_at to now_unix(). Returns a ReplayStoreError::Encode if either serialization fails.

pub fn decode_step_output(&self) -> Result<Value, ReplayStoreError>

Decode the step_output_json back to a Value — used by the replay-hit path in Engine::dispatch_attempt_with_run_ctx to hand a DispatchOutcome::Pass back to the caller without touching the Adapter.

pub fn decode_ctx_snapshot(&self) -> Result<Ctx, ReplayStoreError>

Decode the ctx_snapshot_json back to a Ctx. Ctx.operator is not serialized (#[serde(skip)]), so the round-tripped value carries OperatorInfo::default() in that field.

Trait Implementations

impl Clone for ReplayEntry

fn clone(&self) -> ReplayEntry

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ReplayEntry

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for ReplayEntry

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for ReplayEntry

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

where __S: Serializer,

Serialize this value into the given Serde serializer.