Enum RunLogPayload 

pub enum RunLogPayload {
    RunStarted {
        ir_hash: Hash,
        lockfile_digest: Hash,
        params_snapshot: Value,
        supervise_policy: Option<SupervisePolicy>,
    },
    StepEntered {
        step_id: StepId,
        effect_hash: Hash,
        judge_hash: Hash,
        resolved_inputs: Value,
    },
    PreflightProbed {
        outcomes: Vec<AssertionOutcomeRecord>,
    },
    ActionIntent {
        call_id: String,
        args_snapshot: Value,
        chain_index: Option<u32>,
        channel: Option<ActChannel>,
        action_name: Option<ActionName>,
    },
    ActionSettled {
        call_id: String,
        outcome: ActionOutcome,
    },
    ObservationRecorded {
        observation: ObservationRecord,
    },
    AssertionEvaluated {
        outcome: AssertionOutcomeRecord,
    },
    VerdictRecorded {
        verdict: Verdict,
        localized: Vec<EvidenceRef>,
        localization_gaps: Vec<EvidenceGap>,
        remote_archival_error: Option<String>,
    },
    StepExited {
        state: StepState,
        output: Option<Value>,
        provider_state_summary: Option<ProviderStateSummary>,
        localized: Vec<EvidenceRef>,
        localization_gaps: Vec<EvidenceGap>,
    },
    CallFramePushed {
        frame: CallFrame,
        rebase: bool,
    },
    CallFramePopped {
        outputs: Option<Value>,
    },
    HandlerTriggered {
        hook: HandlerHook,
        trigger: u64,
        disposition: Option<String>,
    },
    HumanRequested {
        request_id: String,
        purpose: HumanPurpose,
        mode: Option<HumanMode>,
        prompt: String,
        presents: Value,
        decisions: Option<Vec<String>>,
        output_schema: Option<JsonSchemaDocument>,
        deadline_at_ms: Option<u64>,
    },
    HumanResponded {
        request_id: String,
        purpose: HumanPurpose,
        response: Value,
        actor: String,
    },
    RunSuspended {
        reason: Option<String>,
        provider_state_summary: Option<ProviderStateSummary>,
    },
    RunResumed {
        alignment_report: AlignmentReport,
        supervise_policy: Option<SupervisePolicy>,
        event_cursor: Option<EventCursor>,
    },
    RunFinished {
        verdict: Option<Verdict>,
        remote_archival_error: Option<String>,
    },
}

The closed 17-variant payload union (spine §6.1/A.4).

Variants

RunStarted

A run segment started.

Fields

ir_hash: Hash

Content hash of the executing IR.

lockfile_digest: Hash

Digest of the bound capability lockfile.

params_snapshot: Value

The run’s input parameters.

supervise_policy: Option<SupervisePolicy>

The segment’s supervision policy; explicitly null when unsupervised (R13 — recorded per segment, never inherited).

StepEntered

A step was scheduled and its inputs are frozen (appended after the ready-phase input snapshot completes, before preflight / actionIntent — spine §6.1 M1 note).

Fields

step_id: StepId

The entered step.

effect_hash: Hash

Effect-domain hash of the step at execution time (alignment input; the fold copies it into StepRecord.effectHash).

judge_hash: Hash

Judge-domain hash of the step at execution time (alignment input; the fold copies it into StepRecord.judgeHash).

resolved_inputs: Value

The ready-phase input snapshot: input expressions evaluated once and frozen, never re-evaluated on resume. Explicitly null for spans whose inputs were never resolved (blocked/skipped steps, or a failed argument evaluation).

PreflightProbed

Preflight probes were evaluated (pending incorporation of the payload shape).

Fields

outcomes: Vec<AssertionOutcomeRecord>

One outcome per probe assertion, in declaration order.

ActionIntent

The WAL entry written and fsynced before dispatching an action (spine §6.2 — the crash-safety anchor).

Fields

call_id: String

The caller-generated action id.

args_snapshot: Value

The evaluated arguments as they will be dispatched.

chain_index: Option<u32>

1-based position in binding.attempts (2026-07-18 incorporation, item ②): the dispatch-identity discriminant — the act-chain overlay and the crash-resume chain re-entry both key on it. Absent on pre-incorporation ledgers.

channel: Option<ActChannel>

The bound attempt’s locating channel, verbatim.

action_name: Option<ActionName>

The bound attempt’s provider-native action name, verbatim.

ActionSettled

An action reached its four-way terminal.

Fields

call_id: String

The action id this terminal belongs to.

outcome: ActionOutcome

The terminal outcome (never folded).

ObservationRecorded

An observation was captured and localized.

Fields

observation: ObservationRecord

The localized observation record.

AssertionEvaluated

One assertion finished evaluating along its verify chain.

Fields

outcome: AssertionOutcomeRecord

The evaluation outcome.

VerdictRecorded

A verdict was folded and recorded.

Fields

verdict: Verdict

The folded verdict.

localized: Vec<EvidenceRef>

Localized settlement/verdict/human-class evidence of THIS judgment (item ③, 2026-07-18; observation refs excluded — they ride observationRecorded). Empty on offline re-judgements (nothing is newly localized offline) and on pre-incorporation ledgers.

localization_gaps: Vec<EvidenceGap>

Typed localization failures of the same judgment — the honest-gap record (principle 4/R4).

remote_archival_error: Option<String>

The provider’s verdict.record write-back failure, when the remote archival attempt failed (04 §5: the failure never changes the local verdict — the RunLog is the sole truth — and is annotated in the report as “remote archival failed”).

StepExited

A step reached a terminal lifecycle state.

Fields

state: StepState

The terminal state.

output: Option<Value>

The projected step output, carried when the output projection completed (spine §6.1 M1 note); absent for exits without an output (blocked/skipped/aborted, error verdicts). A projected JSON null IS an output: it rides as "output": null and refolds as Some(Null), never as absence (I1: the resumed run binds what the live run bound).

provider_state_summary: Option<ProviderStateSummary>

The failure-instant session profile (07 §2.2, incorporated 2026-07-18): present when a fail/unknown verdict is in force at exit; absent otherwise, on aborted follow-up exits (an aborted terminal makes no semantic claim), and on ledgers recorded before incorporation. One-directional additive (R12): pre-field readers reject ledgers carrying it.

localized: Vec<EvidenceRef>

The settlement-evidence manifest of an UNVERIFIED exit (item ③ review fix): an assertion-less step records no verdict (R4), so its judgment manifest rides the exit instead — same merge rule, same honesty. Empty on verdict- bearing exits (the manifest rode verdictRecorded) and on pre-incorporation ledgers.

localization_gaps: Vec<EvidenceGap>

Typed localization failures of the same unverified exit.

CallFramePushed

A subflow call frame was pushed.

Fields

frame: CallFrame

The pushed frame.

rebase: bool

Live-frame RE-ENTRY under a repaired callee, not a new stack level (07 §5.2 call down-drill, case (a)): the resume descended back into a frame that was still open and the callee’s irHash moved, so frames must name the callee actually being executed (“frames 中该帧的 irHash 更新为新 callee irHash”). The fold updates that frame’s irHash in place and keeps everything else — above all its inputsSnapshot, which a new IR never re-evaluates (§5.2 corollary / §4.6).

Additive optional field (spine §6.1, the 2026-07-18 payload batch): absent on every pre-incorporation ledger, so a refold of an old run is byte-identical to what it always was.

CallFramePopped

A subflow call frame was popped (pending incorporation of the payload shape).

Fields

outputs: Option<Value>

The callee’s declared outputs, when it completed. Absent (not null) when there were none; a null output refolds as Some(Null).

HandlerTriggered

A handler hook fired.

Fields

hook: HandlerHook

Which hook fired.

trigger: u64

One-based trigger count toward maxTriggers.

disposition: Option<String>

The consulted binding’s declared disposition head (closed: retry|continue|escalate|abort|repair, 03 §1.8) — what the hook resolved TO, known at emission. Absent on pre-incorporation ledgers.

HumanRequested

A human interaction was requested (fsynced before notifying any channel, spine §6.8/§6.9). M2 incorporation of the 06 §2.1 request shape: mode, decisions, outputSchema and the absolute deadlineAtMs watermark are carried by the event itself, so the store arbitration and the lazy timeout settlement need no source other than the ledger.

Fields

request_id: String

The request id a response must pair with.

purpose: HumanPurpose

Step vs supervision gate (R13).

mode: Option<HumanMode>

Interaction mode. Required semantics when purpose is step; absent for supervision gates, which carry no mode (06 §2.1).

prompt: String

The prompt shown to the human (auto-generated gate description for supervision requests).

presents: Value

The evidence/values presented, materialized once at ready — the resolvedInputs snapshot discipline (06 §2.3).

decisions: Option<Vec<String>>

Enumerated options: confirm carries exactly two labels (position-mapped to pass/fail); judge a subset of the three-valued vocabulary (06 §2.2).

output_schema: Option<JsonSchemaDocument>

Input contract for provideInput responses; the store arbitration validates against it (06 §4.3 rule 3).

deadline_at_ms: Option<u64>

Absolute response deadline (ms since epoch), converted from timeoutMs at request creation — the lazy-settlement watermark (06 §5.3). Absent for supervision requests (no deadline, spine §6.9).

HumanResponded

A human response was arbitrated and recorded (pending incorporation of the payload shape).

Fields

request_id: String

The paired request id.

purpose: HumanPurpose

Step vs supervision gate (R13).

response: Value

The response payload (mode/decision-shaped, arbitrated by the store single writer).

actor: String

Who responded.

RunSuspended

The run segment was suspended.

Fields

reason: Option<String>

Optional human-readable reason. Structured forms the runner writes today: stop requested (cooperative stop token), awaiting human response (requestId <id>), a blocked reason’s display, and the breakpoint stops stopped at breakpoint --stop-at <canonical path> / stopped at breakpoint --stop-after <canonical path> (the matched step instance’s canonical run path, spine §9). Free text otherwise.

provider_state_summary: Option<ProviderStateSummary>

The suspension-instant session profile (07 §2.2): captured whenever a live session exists at the write site; same compat posture as on stepExited.

RunResumed

A run segment resumed from a checkpoint.

Fields

alignment_report: AlignmentReport

The alignment report of this resume (spine §6.7-A).

supervise_policy: Option<SupervisePolicy>

The segment’s supervision policy; explicitly null when unsupervised (R13 — per segment, never inherited).

event_cursor: Option<EventCursor>

The new generation’s reseeded cursor (07 §4.5, incorporated 2026-07-18): sessionId is the lineage extension, taken via currentCursor() after the reconcile decisions and before this append. Absent when the RPC failed at capture — and on ledgers recorded before incorporation (one-directional additive, R12).

RunFinished

The run finished.

Fields

verdict: Option<Verdict>

The folded flow verdict, when one was produced.

remote_archival_error: Option<String>

The flow verdict’s verdict.record write-back failure (04 §5 — see RunLogPayload::VerdictRecorded).

Implementations

impl RunLogPayload

pub const EVENT_TYPES: [&'static str; 17]

All seventeen wire discriminants (spine §6.1 closed set).

pub fn event_type(&self) -> &'static str

The wire discriminant (type) of this payload.

Trait Implementations

impl Clone for RunLogPayload

fn clone(&self) -> RunLogPayload

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for RunLogPayload

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for RunLogPayload

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl JsonSchema for RunLogPayload

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 RunLogPayload

fn eq(&self, other: &RunLogPayload) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl Serialize for RunLogPayload

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 RunLogPayload