pub enum RunEventKind {
Show 59 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,
ConfigResolved,
ConnectionRegistered,
ConnectionConsented,
ConnectionRefreshed,
ConnectionRevoked,
CredentialHandleIssued,
CredentialUse,
CredentialDenied,
ConnectionNeedsReauth,
ArtifactCommitted,
ArtifactPruned,
ArtifactRetentionReleased,
ArtifactUnavailable,
DeploymentResolved,
RevisionRegistered,
RevisionPromoted,
RevisionRolledBack,
EnvironmentDeclared,
EnvSecretSet,
EnvSecretRevoked,
EnvSecretDenied,
GateDecisionRecorded,
CanaryDeclared,
CanaryCleared,
ShadowRunStarted,
ShadowEffectRefused,
ShadowVerdict,
}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.
ConfigResolved
A registry artifact was resolved into a run at admission (R0.11
Extension Plane, wave 2): the run declared named configuration
artifacts at submission, and each one resolved through its
environment-tagged version pointer to the candidate the run then
pinned. An Effect::ReadOnly record (a registry lookup), the
RunEventKind::CapsuleResolved precedent applied to configuration. Output
carries the journaled crate::registry::ConfigResolution — the
artifact, the environment tag, the candidate id, the pointer slot
that admitted it (active or canary), and the digest the manifest
pins. This is the digest ↔ version join the manifest alone cannot
express: the manifest’s wire shape stays frozen (digests only),
and “which candidate produced this pin” reads from here — the
event sits in the signature-covered journal, so the audit walk
signed receipt → manifest pin → resolution event → candidate →
author is covered end to end.
ConnectionRegistered
A broker connection was registered (R0.11 Extension Plane, wave
3): a named, tenant-scoped binding of a provider account to its
consent scope set landed in the broker. Journaled into the
deployment’s broker evidence chain (the receipt-keys precedent
applied to a second control plane). An Effect::Pure record:
registration is local broker state, so the event is the lineage
evidence. Output carries the
crate::broker::ConnectionRecord — metadata by construction;
the credential bytes live only in the sealed store envelope and
can never appear here.
ConnectionConsented
A connection’s consent act was recorded (R0.11 wave 3): the
human’s grant at the provider, written down as the connection’s
new scope ceiling. An Effect::Pure record. Output carries the
journaled crate::broker::ConnectionConsent — the connection,
the subject, and the recorded scope set. Scope widening is only
ever this event: a new consent act, journaled; there is no silent
widening path.
ConnectionRefreshed
A connection’s token material rotated beneath an unchanged
consent set (R0.11 wave 3): a recorded credential rotation. An
Effect::Pure record. Output carries the journaled
crate::broker::ConnectionRefresh — the connection and the new
expiry, never the bytes. Rotation changes nothing a run pinned:
the pin names the connection id and the consent set, not the
secret of the moment.
ConnectionRevoked
A connection was revoked (R0.11 wave 3). The status flip and this
event commit together, and resolution reads live connection
state, so revocation takes effect at the next tool call — not the
next deploy. An Effect::Pure record. Output carries the
journaled crate::broker::ConnectionRevocation: the connection
and the grant that stopped holding.
CredentialHandleIssued
A credential handle was issued (R0.11 wave 3): a tool (or
capsule) declaring a credential need received a short-lived,
opaque handle — scope-narrowed against the consent ceiling at
issuance. An Effect::Pure record. Output carries the
journaled crate::broker::HandleIssuance — the full claims, so
the run’s evidence pins the connection id and the consent scope
set it resolved.
CredentialUse
A credential handle was resolved at use (R0.11 wave 3): the
broker checked live connection state, expiry, and scope coverage,
and handed the credential to the host-side connector. An
Effect::ReadOnly record (the resolution itself performs no
external effect — the authenticated call it enables is the
connector’s own evidence). Output carries the journaled
crate::broker::CredentialUse — handle, connection, scopes
checked — never bytes (the CapsuleCall precedent).
CredentialDenied
A handle issuance or resolution was refused (R0.11 wave 3):
revoked connection, expired handle, scope beyond the bound set,
needs_reauth, unknown handle or connection, or a broker that
could not perform the check. An Effect::Pure record: nothing
executed, so there is no external effect to classify — the event
is the evidence that nothing happened (the CapsuleDenied
precedent). Output carries the journaled
crate::broker::BrokerDenial, attributable to the connection
and the grant — never the bytes.
ConnectionNeedsReauth
A connection’s refresh path failed terminally and its status
flipped to needs_reauth (R0.11 wave 4): the provider’s
invalid_grant (or an expired refresh token) means a human must
record a new consent act before the connection serves again. The
flip and this event commit together, and calls fail closed with a
typed re-auth signal from the next use — never silent retries with
stale material, because a stale credential retried looks exactly
like an attack retried. An Effect::Pure record. Output carries
the journaled crate::broker::ConnectionReauthRequired — the
connection, the classified failure that decided the flip, and the
consent set that stopped being servable.
ArtifactCommitted
A run artifact was committed (R0.12 Operations Plane, wave 1): an
output the run produced — a generated file, image, audio, an
exported dataset — became a content-addressed, retainable object
in the artifact plane, committed from an SDK-declared output or
from a journaled PayloadRef::Artifact the producing node
opted into. An Effect::Pure record: the event is the
commitment, so the signed receipt’s head covers it transitively —
the audit walk is signed receipt → journal head → this event →
the producing crate::effects::EffectId → the effect’s
journaled record → the bytes behind the address. Output carries
the journaled crate::artifact::ArtifactCommitment — the
content address, the name and version index when named, the media
kind, the byte count, the producing effect id, and the declared
retention. The bytes never enter the journal; the journal carries
the reference and the commitment, and the plane carries the rest.
ArtifactPruned
The retention sweeper pruned an artifact’s bytes (R0.12
Operations Plane, wave 2): every record naming the address was
expired or released, and no verified signed receipt still covered
it. Journaled onto the deployment’s artifact evidence chain (the
run id run-artifacts, not any tenant’s run — the
receipt-keys / credential-broker precedent) before the
bytes are deleted, so a crash mid-sweep leaves the intention
auditable and the bytes recoverable. An Effect::Pure record:
the event is the evidence of the enforcement act. Output carries
the journaled crate::artifact::ArtifactPrune — the address,
the name when named, the cause, and the sweep instant.
ArtifactRetentionReleased
An operator released an artifact’s retention pin (R0.12 wave 2):
the explicit, attributed act that is the only path pruning an
address a live signed receipt covers or a pinned policy holds.
Shortening evidence retention is a governance decision with a
name on it, never a sweeper optimization, so the act journals
onto the deployment’s artifact evidence chain before any byte
moves. An Effect::Pure record. Output carries the journaled
crate::artifact::ArtifactRelease — the address, the tenant
and name, the operator identity, the optional reason, and the
release instant.
A read found a live artifact record whose bytes are gone (R0.12
wave 2): the typed miss (410 artifact_unavailable) a retention
audit reads as the difference between “no such artifact” and “the
record exists, the bytes do not” — and the shape an exact replay
against pruned bytes fails closed with. Journaled onto the
deployment’s artifact evidence chain (best-effort; the read’s
typed answer is the contract, the event is the evidence) so the
miss is attributable without rewriting the producing run’s
receipt-covered journal. An Effect::Pure record. Output
carries the journaled crate::artifact::ArtifactUnavailability
— the address, the tenant and name, the surface that missed, and
the observation instant.
DeploymentResolved
A run was admitted under a deployment revision (R0.12 Operations
Plane, wave 3): the run declared an environment at submission, and
the environment’s deployment pointer bound a revision for it (the
full-traffic active, or the canary when the seeded draw
admitted). An Effect::ReadOnly record (a pointer lookup), the
RunEventKind::ConfigResolved precedent lifted from
configuration to deployments. Output carries the journaled
crate::deploy::DeploymentResolved — the environment, the bound
revision_id, the pointer slot, and the pin-set digest. This is
the audit walk’s hinge: signed receipt → journal head → this event
→ the content-addressed revision → the frozen pin set → the
candidates and their authors, every hop signature-covered. A
pointer serving nothing binds nothing — the run fails admission
instead (there is no implicit “latest”), so the journaled event
only ever names a revision that served.
RevisionRegistered
A deployment revision was registered (R0.12 wave 3): an immutable,
content-addressed declaration of what may serve landed in the
control plane. Journaled onto the deployment evidence chain (the
run id deployment-control — the receipt-keys /
credential-broker precedent for a third control plane), never a
run’s journal: a deployment transition is not any run’s event.
An Effect::Pure record: registration is local control-plane
state, so the event is the lineage evidence. Output carries the
journaled crate::deploy::RevisionRegistration — the tenant and
the revision, whose own fields carry the author and the frozen
pin set.
RevisionPromoted
A revision was promoted into an environment (R0.12 wave 3): the
environment’s deployment pointer moved active and cleared any
canary — a full promotion supersedes the experiment it graduated
from. The journaled transition and the pointer move commit in one
transaction (the learn store’s rule: a crash cannot leave a
promoted revision whose pointer never moved). An Effect::Pure
record on the deployment evidence chain. Output carries the
journaled crate::deploy::RevisionPromotion — the environment,
the promoted revision, the displaced previous (the rollback
path’s whole story), the author, and the instant.
RevisionRolledBack
A serving revision was rolled back (R0.12 wave 3): the
environment’s pointer re-pointed active to the previously
serving revision — byte-exact, because the restored revision is
the immutable record that served before, re-derived from the
chain’s own transition history, never a reconstruction. An
Effect::Pure record on the deployment evidence chain. Output
carries the journaled crate::deploy::RevisionRollback — the
environment, from, to, the cause, and the author. New runs bind
the re-pointed revision at admission; in-flight runs keep the
revision their journaled resolution names.
EnvironmentDeclared
An environment was declared (R0.12 wave 3): an R0.11 promotion
tag became a first-class record — the name, the gate and approval
declarations that will govern promotions into it (wired in
wave 4), and the creation metadata. An Effect::Pure record on
the deployment evidence chain, so an audit reads the declaration
in force when a promotion happened, not a later edit. Output
carries the journaled crate::deploy::EnvironmentDeclaration.
EnvSecretSet
An environment-scoped secret was set or rotated (R0.12 wave 3):
custody, not brokerage — a static value envelope-encrypted at
rest under the deployment master key, stored as ciphertext on
both backends, rotated by replacement beneath the stable scoped
name. An Effect::Pure record on the deployment evidence
chain, metadata by construction: output carries the journaled
crate::deploy::EnvSecretAct — the record, never the bytes;
rotated_at marks a rotation beneath the stable name.
EnvSecretRevoked
An environment-scoped secret was revoked by deletion (R0.12
wave 3): the only revocation path — there is no disable flag to
forget, and the tombstone is the evidence the scope once held a
value. An Effect::Pure record on the deployment evidence
chain. Output carries the journaled
crate::deploy::EnvSecretRevocation — the scoped name, the
revoker, and the instant.
EnvSecretDenied
An environment-secret resolution was refused on scope (R0.12
wave 3): the request asked for a scope outside the environment
the requester holds — the CapsuleDenied discipline (attributable
to a declaration, not a stack trace) applied to environment scope.
An Effect::Pure record: nothing resolved, so there is no
external effect to classify — the event is the evidence that
nothing happened. Output carries the journaled
crate::deploy::EnvSecretDenial, naming the scope requested
and the scope the holder holds.
GateDecisionRecorded
A release gate evaluated a promotion into a gated environment
(R0.12 wave 4): the decision journals before the pointer move
it governs, allowed or refused — a gate whose refusals leave no
evidence is a gate an audit cannot distinguish from never having
run. An Effect::Pure record on the deployment evidence chain.
Output carries the journaled crate::deploy::GateDecisionRecord:
policy, dataset version, every check observed, and the verdict.
CanaryDeclared
A canary was declared on an environment’s pointer (R0.12 wave 4):
one revision bound to a declared fraction of new runs while the
active revision serves the rest. An Effect::Pure record on the
deployment evidence chain. Output carries the journaled
crate::deploy::CanaryDeclaration — the binding and its author,
so the seeded draw an audit replays has a declared origin.
CanaryCleared
A canary was cleared from an environment’s pointer (R0.12 wave
4): the experiment ended without graduating (graduation is a
promotion, which clears the slot itself). An Effect::Pure
record on the deployment evidence chain. Output carries the
journaled crate::deploy::CanaryClearance, naming the revision
the slot held — the clearance is evidence about a specific
binding, not a bare “slot emptied”.
ShadowRunStarted
A shadow run started against a recorded source run (R0.12 wave
4): the twin of the source under a candidate revision, executed
against the shadow admission boundary. An Effect::Pure record
in the shadow run’s own journal. Output carries the journaled
crate::deploy::ShadowRunStarted — naming the source run and
pinning role: shadow, so the twin-pair discipline is data the
journal carries, not a comment.
ShadowEffectRefused
A shadow run’s admission boundary refused an effect above
read-only (R0.12 wave 4): the refusal is the shadow’s reason to
exist — proof the candidate cannot touch the world — so it
journals served-or-not with the request it refused. An
Effect::Pure record in the shadow run’s journal: nothing
executed, so there is no external effect to classify. Output
carries the journaled crate::effects::ShadowRefusal.
ShadowVerdict
A shadow run completed and its verdict journaled (R0.12 wave 4):
refusals, how many were served from the recorded world, and which
recorded calls the candidate never requested — the divergence
evidence. An Effect::Pure record in the shadow run’s journal.
Output carries the journaled crate::deploy::ShadowVerdict.