A run
Source ExecutionDetailPage.tsx, RunGraphPanel.tsx, JunctionTimeline.tsx
/runs/{id}. One run of a train: a header with what it is and what can be done to it, the run drawn
on its train's chain, and tabs below. Read through operations.executionDetail,
operations.runGraph and the run's
links, and read again whenever a run changes.
Header
The train's short name, its state, Replay abandoned when it was queued to replay an earlier run's decisions and asked afresh because that replay could not be honoured, and Cancellation requested once a cancel was asked for.
| Field | Value |
|---|---|
| Train | The train's full name, linking its page |
| Duration, Started, Ended | "running" until it ends |
| Started by | Each of: the machine instance whose state invoked it, the manifest that scheduled it, the parent run, the queue entry it was dispatched from, the dead letter it retries. "Started directly" when none. |
| Running now | The junction an in-progress run is on |
A failed run shows its failure under the header: the reason, the junction it failed at, its failure class and its stack trace.
| Action | Offered | Does |
|---|---|---|
| Cancel | Pending or In progress, not yet cancelling | Requests cancellation; a running run stops at its next junction. A run a user's state-machine draft started is read-only to operators. |
| Requeue | Completed, Failed or Cancelled | Queues a new run with this run's saved input and opens its queue entry. When this run recorded decisions, the new run replays them. |
| Requeue, ask afresh | As Requeue, for a train that asks a decider | The new run asks its deciders again |
| Resume | The run has a saved input and the run graph says it can resume | Queues a run that skips to the step after this run's latest checkpoint and opens its queue entry |
Each asks for confirmation. A refusal shows the API's reason: a requeue needs the input saved
(SaveTrainParameters()), not truncated or masked, and a train this host still registers.
Run graph
The train's declared chain with this run on it,
drawn as a graph: each step a node coloured by where the run left it, a routing step's tracks and a
Parallel step's branches as branches.
| Colour | Means |
|---|---|
| Green | Completed |
| Blue | Running |
| Red | Failed |
| Amber | Cancelled, or interrupted (started and never recorded an end in a run that has ended) |
| Accent colour | Restored from a checkpoint (a step before the point a resumed run started at) |
| Grey | Not reached, skipped, or not recorded (an Extract, Seed or Resolve, or a checkpoint the run did not store) |
A failed run opens with its failed step selected. Selecting a node opens its panel, and the
selection is in the address (?step=), so a link can open a run at a step.
| In the panel | Shows |
|---|---|
| Kind and state | The step's kind (Junction, Short circuit, Parallel, Checkpoint and the rest) and its state |
| Node, On track, Runs, Takes, Gives | Its node id, the track it is on, the junction it runs, and its input and output types |
| Attempt | For a run of a manifest |
| Badges | checkpoint stored (its place, never its content), replayed (an answer came from an earlier run), decided at run time |
| Error | For a failed or cancelled step: its failure class and exception type, never its message |
| Steps recorded | Each recorded step the node covers, with its duration and attempt |
| Decisions | For a question or route: its key, the answer, the confidence, the decider, and whether it was replayed; "withheld" for a [TraxSensitive] answer |
| Resume from here | On a failed or cancelled run, on each step the resume check allows: queues a run that skips to this step, on what the checkpoint before it restores |
A step's own input and output are not recorded; the run's are under Input and output.
The graph is the chain as the host declares it now. When the chain changed after the run started, a note says so: a step can then sit where the run did not run it. Steps not on the graph lists recorded steps that match no node. A train with no graph on this host shows a message instead, and its steps are in the timeline.
Tabs
The open tab is in the address (?tab=).
| Tab | Shows |
|---|---|
| Timeline | One row per step the run took, a bar placed against the run's start and coloured by state; a running step extends to now. Selecting a row selects its node on the graph, and the graph's selection is lit here. Steps are recorded on a host that calls AddJunctionEvents(); at most the first 500 are shown. |
| Input and output | The run's input and output as JSON, when the host saves train parameters. A train can withhold its output. |
| Logs | The run's log entries, oldest first, filtered by level, category and message, as on Logs |
| Decisions | Each question the run asked: the question, the answer (or "Withheld"), who decided it and when, and flags for Replayed, Refused, Replay refused and a withheld track or answer. Details shows the shadow answers, routes, fingerprint and state hash. |
| Related | The run's id, external id, scheduled time, executor, manifest, parent run, machine instance, queue entry and dead letter; the run whose decisions it replays and whether the replay held; the run it resumes and where; its child runs; and the host that ran it (name, environment, instance id, labels) |