pub enum RunEventKind {
Show 32 variants
SuperStepStart,
SuperStepEnd,
NodeInput,
NodeOutput,
ModelCall,
ToolCall,
RemoteCall,
WasmCall,
Interrupt,
Resume,
RoutingDecision,
CheckpointWritten,
EffectReceipt,
AgentSpawn,
AgentExit,
MailboxSend,
MailboxReceive,
SupervisionEvent,
CoordinationStart,
CoordinationEnd,
MemoryRead,
MemoryWrite,
MemoryForget,
CandidateCreated,
CandidateEvaluated,
CandidatePromoted,
CandidateRolledBack,
PolicyDecision,
CapsuleResolved,
CapsuleCall,
CapsuleDenied,
SigningKeyRotated,
}Expand description
What a RunEvent records. Closed set; replay and analysis code matches
exhaustively on it.
Variants§
SuperStepStart
A super-step began; input lists the activated node set.
SuperStepEnd
A super-step merged at the barrier; output carries the post-reducer channel values (the reducer result for the step).
NodeInput
A node invocation was scheduled; input is its (scoped) state snapshot.
NodeOutput
A node invocation finished; output is its partial updates plus any routing command, with the measured latency.
ModelCall
A chat-model call; input is the request (messages + tool schemas), output the response, with model identity, token usage, and cost where reported.
ToolCall
A tool invocation; input is the arguments, output the result.
RemoteCall
A remote-node call to a worker over the wire protocol; input is the
NodeTask, output the NodeTaskResponse payload.
WasmCall
A WASM guest-module invocation; input is the guest input, output the guest output.
Interrupt
A node suspended the run; input is the interrupt payload.
Resume
The run resumed from a checkpoint; input carries the checkpoint id and, when present, the resume value.
RoutingDecision
The routing phase selected the next active set; output describes the
planned invocations (including Send fan-outs).
CheckpointWritten
A checkpoint was persisted; output carries the checkpoint id, step, and journal head reference stamped into it.
EffectReceipt
An Idempotent effect’s own confirmation, journaled by the effect’s
recipient (R0.6 Durable Work): output carries the EffectReceipt —
the provider’s confirmation id plus the idempotency key the effect
ran under. Exact replay serves the receipt instead of re-sending the
effect: the same journaled-output rule model and tool calls follow,
extended across the crash boundary between a run and its durable
tasks.
AgentSpawn
An agent was spawned (R0.7 Agent Fabric): input carries the agent id,
its pinned crate::agents::CapabilityManifest, and the declared
crate::agents::StateScopes — the manifest’s scopes are journaled
with the spawn so later access checks replay against the same
declaration. Wave 1 lands the variant as an inert contract; the agent
host emits it.
AgentExit
An agent terminated (R0.7): output carries the terminal disposition (completed, failed, cancelled) and the final checkpoint reference. Wired in wave 2 for the cancellation tree: the server journals it into the agent’s supervision journal when an agent/team cancel actually touches work. Host-emitted terminal exits land with the agent host.
MailboxSend
A mailbox message was submitted to an agent’s mailbox (R0.7): output
carries the recipient (agent:{agent_id}), the message kind, and the
task id the queue assigned. The sender-side half of the mailbox
journal pair; the envelope’s parent links it into the team’s causal
tree. Wired in wave 3: the coordination runtime journals it into the
pattern’s journal for every member task it submits. Host-emitted
sends land with the agent host.
MailboxReceive
An agent’s activation began a turn on a mailbox message (R0.7): input carries the task id and idempotency key the turn is processing. The recipient-side half of the mailbox pair. Wired in wave 3 as the settlement observation: the coordination runtime journals it when a member task settles, with the terminal status and result — the pattern’s evidence half of the pair. Host-emitted turn begins land with the agent host.
SupervisionEvent
A supervision decision was made (R0.7 wave 2): output carries the
policy (permanent / transient / temporary), the triggering
failure’s EventStatus / error class, and the restart ordinal —
the journaled decision record that makes “no restart without a
journaled decision” auditable. Wired in wave 2: the server journals
it into the agent’s supervision journal on restart / escalate /
manual-restart decisions.
CoordinationStart
A coordination pattern (delegate / fan-out / race / quorum) began (R0.7 wave 3): output carries the pattern’s typed contract — members, thresholds, effect declarations. The team’s causal root for every event the pattern spawns. Wired in wave 3: the coordination runtime journals it on the pattern’s first drive, before any member task exists.
CoordinationEnd
A coordination pattern settled (R0.7 wave 3): output carries the result reference and the per-member dispositions (completed, failed, cancelled) — the fan-in evidence record. Wired in wave 3: the coordination runtime journals it exactly once, as the pattern’s terminal fact.
MemoryRead
A governed memory retrieval was performed (R0.8 Rusty Learn, wave 1):
input is the canonical request — the resolved
crate::memory::MemoryQuery (with as_of stamped through the
run’s clock) plus the crate::memory::ContextBudget — and output
is the journaled crate::memory::MemoryAssembly: the record ids
and their order, the packed records, and the token accounting.
Declared Effect::ReadOnly: exact replay serves the journaled
assembly instead of re-querying the store — the same
journaled-output rule model and tool calls follow, applied to the
memory seam so candidate evaluation is reproducible.
MemoryWrite
A governed memory write landed (R0.8 wave 1): an
Effect::Idempotent effect under the derived key
memory:{scope}:{memory_id} (see crate::memory::memory_effect_key),
so retried submissions converge. Input carries the effect key and the
memory id; output carries the stored
crate::memory::MemoryRecord with its provenance — the write’s
attribution is journaled, not implied.
MemoryForget
A memory record was forgotten (R0.8 wave 2): real deletion of
derived state, with the journaled tombstone as the erasure receipt.
An Effect::Idempotent effect under the derived key
memory_forget:{scope}:{memory_id} (see
crate::memory::memory_forget_effect_key), so retried erasures
converge. Input carries the effect key and the memory id; output
carries the crate::memory::MemoryForgetTombstone — the id, scope,
reason, and dependent invalidations, metadata by construction:
the tombstone has no content field, so the forgotten bytes cannot
leak through the receipt of their erasure. Corrections are not a
separate variant: they journal through MemoryWrite with the
correction’s attribution in the derived record’s provenance.
CandidateCreated
A learning candidate was created (R0.8 wave 3): a distiller’s
proposed change landed as an immutable, content-addressed
crate::learn::Candidate — identity is integrity, so two
distillations of the same change converge on one id and a tampered
candidate fails its own address. An Effect::Idempotent effect
under the derived key candidate:{candidate_id} (see
crate::learn::candidate_effect_key), so retried submissions
converge. Input carries the effect key and the candidate id; output
carries the candidate itself — the distiller’s identity and the
evidence span it read are journaled with it, not implied.
CandidateEvaluated
A candidate was evaluated against recorded evidence (R0.8 wave 3):
replay re-drove recorded runs with the candidate applied, the
experiment runner graded it over the versioned dataset, and the
comparison diffed it against the baseline. An
Effect::Idempotent effect under the derived key
evaluation:{candidate_id}:{dataset_version} (see
crate::learn::evaluation_effect_key): re-evaluation against the
same dataset version converges; a new dataset version is a new
evaluation. Output carries the journaled
crate::learn::CandidateEvaluation — the replay divergence
summary, the report pair, the dataset version, and the verdict.
The evaluation is evidence, not a log line.
CandidatePromoted
A candidate was promoted (R0.8 wave 3): the active-version pointer
for its production surface moved. An Effect::Idempotent effect
under the derived key promotion:{candidate_id} (see
crate::learn::promotion_effect_key) — retried promotions
converge, and recovery re-derives the same key. Output carries the
crate::learn::PromotionReceipt: the pointer’s previous value
and the promotion’s authority — the envelope version (the standing
approval) or the approval token’s approved_by for an
out-of-envelope promotion.
CandidateRolledBack
A promoted candidate was rolled back (R0.8 wave 3): the surface’s
active-version pointer re-pointed to the previous candidate.
Byte-exact because candidates are content-addressed and immutable —
the restored version is the one that previously served, not a
reconstruction. An Effect::Idempotent effect under the derived
key rollback:{surface}:{candidate_id} (see
crate::learn::rollback_effect_key). Output carries the
crate::learn::RollbackReceipt: from, to, and the causing
evidence. New runs bind the re-pointed version at admission;
in-flight runs keep the version their checkpoint header pins.
PolicyDecision
An executor policy decision was made and recorded (R0.8 wave 4): the
policy plane emitted a DecisionEvent at a decision point — v1
wires the retry classifier (crate::durable::classify_retry). An
Effect::Pure record: the decision was already applied by the
scheduler that emitted it; this event is the evidence of why, not a
command to apply it again. Output carries the journaled
DecisionEvent — features, the closed legal-action set, the
selected action, the propensity, and the policy version that decided.
CapsuleResolved
A run manifest’s capsule version pin was resolved to a content
address (R0.9 Rusty Capsules, wave 1): the server’s capsule registry
mapped (identity, version) →
crate::capsule::CapsuleId at admission and journaled the
resolution, so the full chain — header pin → journaled resolution →
receipt — reaches the manifest digest. An Effect::ReadOnly
record (a registry lookup): output carries the journaled
crate::capsule::CapsuleResolution — the pin name, the version
string, the resolved capsule id, and the build digest the registry
holds for it. A pin that resolves to a manifest failing its own
content address fails admission instead — tampering is an admission
error, never a journaled resolution.
CapsuleCall
A granted capsule capability was exercised (R0.9 wave 1): the guest
called a linked import and the host performed (or attempted) the
operation. The capsule rule’s “every use is journaled” half: output
carries the journaled crate::capsule::CapsuleUse — the capsule
id, the capability kind, the operation, and the request/response
summaries. The effect class is the operation’s own (a GET fetch
records Effect::ReadOnly; a writing method records
Effect::NonIdempotent), and a failed operation is journaled with
EventStatus::Error — a granted call that fails is still a use.
CapsuleDenied
A capsule capability attempt was refused (R0.9 wave 1): either the
guest probed an import its manifest’s grants never linked (the
structural denial — the import does not exist), or it called a
granted import outside the grant’s scope (a network grant naming
host A, a fetch attempted against host B). An Effect::Pure
record: nothing executed, so there is no external effect to
classify — the event is the evidence that nothing happened. Output
carries the journaled crate::capsule::CapsuleDenial — the
capsule id, the requested capability, and the manifest grant that
was absent (the grant that would have permitted the attempt), so
the denial is attributable to a declaration, not to a stack trace.
SigningKeyRotated
The deployment’s receipt signing key changed (R0.9 wave 3): a
rotation was performed (or a host with no local secret joined a
shared store) and the server journaled the new key id into the
deployment’s receipts journal — the run id
receipt-keys, not any tenant’s run. An Effect::Pure record:
the key operation is local key material, so there is no external
effect to classify — the event is the lineage evidence. Output
carries the journaled crate::receipt::SigningKeyRotation — the
previous key id (None on genesis), the new key id, its public
half, and the rotation instant — so “which key signed what, from
when” is a chained fact, and old receipts keep verifying against
the key history the journal attests.
Trait Implementations§
Source§impl Clone for RunEventKind
impl Clone for RunEventKind
Source§fn clone(&self) -> RunEventKind
fn clone(&self) -> RunEventKind
1.0.0 (const: unstable) · Source§fn clone_from(&mut self, source: &Self)
fn clone_from(&mut self, source: &Self)
source. Read more