diff --git a/.agents/skills/testing-pilot-corpora-gate/SKILL.md b/.agents/skills/testing-pilot-corpora-gate/SKILL.md
index f9ee0145ce..1fe1064bfb 100644
--- a/.agents/skills/testing-pilot-corpora-gate/SKILL.md
+++ b/.agents/skills/testing-pilot-corpora-gate/SKILL.md
@@ -183,7 +183,7 @@ gate's own helpers are package-private but reusable (`pilotCorporaGate.files(t)`
 
 `actionlint`, `shellcheck`, `python3 scripts/check-doc-links.py`, `gofmt`, `go vet`,
 `go run -C tools ./cmd/pilot-diff` (validators pre-downloaded; ~4min, prints e.g.
-the headline the committed baseline holds — `389 file(s), 359 fully agreeing; 45 agreed
+the headline the committed baseline holds — `390 file(s), 360 fully agreeing; 45 agreed
 diagnostic(s), 44 only ours, 92 only the pilot's` at the `2026-08` pin, so read it from
 `docs/project/pilot-differential-baseline.json` rather than from this line)
 and `make lint` (staticcheck+gosec, ~2min) all work. There is **no** `yamllint` and **no**
diff --git a/.agents/skills/testing-pilot-differential/SKILL.md b/.agents/skills/testing-pilot-differential/SKILL.md
index 673089e10e..29bdab142b 100644
--- a/.agents/skills/testing-pilot-differential/SKILL.md
+++ b/.agents/skills/testing-pilot-differential/SKILL.md
@@ -24,7 +24,7 @@ GNU-format diagnostics **relative to `--root`**. Consequences for testing:
 - Measured at the `2026-08` pin after the view concern framing round retired the six view-body
   `frame` `syntax` rows (bare parameters already at their effective range `[0..*]`, so the
   adjudicated `Behaviors.kerml:14` multiplicity warning is gone while the `[1]` `RocketEquation`
-  inputs keep its warning at `delta-v-budget.sysml:93`): `389 file(s), 359 fully agreeing; 45 agreed,
+  inputs keep its warning at `delta-v-budget.sysml:93`): `390 file(s), 360 fully agreeing; 45 agreed,
   44 only ours, 92 only the pilot's`, JSON totals `openSysMLDiagnostics 90 / pilotDiagnostics 138 /
   severityMismatch 1`; the two only-ours rows the multiplicity rule added are the expected `action-step-multiplicity-not-fixed`
   warnings on `training/18. Action Performance/Action Performance Example.sysml:10` and
@@ -148,7 +148,7 @@ warning (the `[1]` `RocketEquation` inputs still produce the warning at
 `delta-v-budget.sysml:93`), is current: the action-step multiplicity rule adds the two expected
 `action-step-multiplicity-not-fixed` warnings on `takePhoto[*]` in the training corpus and
 `takePicture[*]` in `Camera Example/Camera.sysml`, and the view concern framing round retired the
-six view-body `frame` `syntax` rows on `examples`; a live run gives `389 file(s), 359 fully
+six view-body `frame` `syntax` rows on `examples`; a live run gives `390 file(s), 360 fully
 agreeing; 45 agreed, 44 only ours, 92 only the pilot's`, byte-identical to the committed baseline, and
 `docs/project/pilot-differential.md`'s "Results" table matches. The prior rebaseline, when the
 Legend of the Red Dragon example left for its own repository, gave
diff --git a/.agents/skills/testing-pilot-execution-referee/SKILL.md b/.agents/skills/testing-pilot-execution-referee/SKILL.md
index e0446dbd79..840e601209 100644
--- a/.agents/skills/testing-pilot-execution-referee/SKILL.md
+++ b/.agents/skills/testing-pilot-execution-referee/SKILL.md
@@ -150,7 +150,7 @@ pilot answers the representation's own. See
   `pilot-exec-diff: <file>:<line>: model no/such/model.sysml: stat <abs>: no
   such file or directory`.
 - **Additivity.** `go run -C tools ./cmd/pilot-diff` must still print the headline the
-  committed baseline holds (`389 file(s), 359 fully agreeing; 45 agreed
+  committed baseline holds (`390 file(s), 360 fully agreeing; 45 agreed
   diagnostic(s), 44 only ours, 92 only the pilot's` at the `2026-08` pin — read it from the baseline JSON, not from this line, since each
   fix round moves it) and `jq -S` diff clean against
   `docs/project/pilot-differential-baseline.json`; `git status --porcelain`
diff --git a/.agents/skills/testing-pilot-xpect/SKILL.md b/.agents/skills/testing-pilot-xpect/SKILL.md
index 60c0cd9db6..a88187967c 100644
--- a/.agents/skills/testing-pilot-xpect/SKILL.md
+++ b/.agents/skills/testing-pilot-xpect/SKILL.md
@@ -423,7 +423,7 @@ census in `w5c_census_test.go` is live two ways: perturb one pinned triple (e.g.
 ## Regression neighbour
 
 `go run -C tools ./cmd/pilot-diff` (~1m12s) must still print the headline the *committed* baseline holds —
-at the `2026-08` pin that is `389 file(s), 359 fully agreeing; 45 agreed diagnostic(s), 44
+at the `2026-08` pin that is `390 file(s), 360 fully agreeing; 45 agreed diagnostic(s), 44
 only ours, 92 only the pilot's`. Read the number out of
 `docs/project/pilot-differential-baseline.json` rather than trusting this line, since a landing fix
 round moves it. When the baseline is itself stale (it was at `19a3ce03`, holding 273 / 281 / 317), a
diff --git a/README.md b/README.md
index 4e0c44b7cb..b041c6de6b 100644
--- a/README.md
+++ b/README.md
@@ -338,11 +338,11 @@ The project is under active development, with the core infrastructure operationa
 <!-- doc-counts:begin refereed-figures -->
 **Measured against the pinned reference** (`PILOT_TAG=2026-08`, artifact `0.62.0`). Every number below is generated by `make docs-counts` from the committed baselines and gated; none of them is typed in by hand.
 
-- **Corpus agreement:** 359 of 389 files agree diagnostic-by-diagnostic; 44 diagnostics are ours alone and 92 the reference's alone, and the first number must be read by root: the aggregate includes candidate conformance differences, intentional execution-scope warnings on reference corpora and diagnostics from our own examples ([differential](docs/project/pilot-differential.md), `go run -C tools ./cmd/pilot-diff`).
+- **Corpus agreement:** 360 of 390 files agree diagnostic-by-diagnostic; 44 diagnostics are ours alone and 92 the reference's alone, and the first number must be read by root: the aggregate includes candidate conformance differences, intentional execution-scope warnings on reference corpora and diagnostics from our own examples ([differential](docs/project/pilot-differential.md), `go run -C tools ./cmd/pilot-diff`).
 - **Declared-diagnostic silence:** of the 512 declared `errors` rows in the reference's own Xpect suites, we report nothing for 0. 245 we report word-for-word; 248 wording-only and 7 location-only differences are agreement in substance and are not counted as gaps; 0 more we report as a warning and 2 elsewhere in the file ([Xpect oracle](docs/project/pilot-xpect.md), `go run -C tools ./cmd/pilot-xpect`).
 - **Scope agreement:** 230 of 230 declared scope assertions match exactly (same source).
 - **Permissiveness gaps:** of 313 invalid models we wrote ourselves, the reference rejects 4 that we accept by default, and 300 both reject; 4 further cases agree only when we are asked strictly. We authored every one of these cases ourselves, so the denominator measures the reach of our own corpus and not our conformance; agreement reached only under an opt-in strict mode is weaker evidence than agreement by default ([rejection oracle](docs/project/pilot-rejection.md), `go run -C tools ./cmd/pilot-reject`).
-- **Declared errata:** the registry declares 12 defect(s) in the published reference material — 4 with a specification-derived correction, 8 documented without one, since no intended reading can be inferred ([OMG issues](docs/project/omg-issues.md), `tools/oracle/errata`). Every figure above is as published and stays the conformance statement; running the same oracles over the corrected text instead reports 360 of 389 files agreeing, 43 diagnostics ours alone and 92 the reference's alone, 0 declared rows we are silent on, and 0 of 313 authored cases the reference alone rejects. The corrected figures are diagnostic only: an erratum never reclassifies a divergence category, and the published corpus is never edited.
+- **Declared errata:** the registry declares 12 defect(s) in the published reference material — 4 with a specification-derived correction, 8 documented without one, since no intended reading can be inferred ([OMG issues](docs/project/omg-issues.md), `tools/oracle/errata`). Every figure above is as published and stays the conformance statement; running the same oracles over the corrected text instead reports 361 of 390 files agreeing, 43 diagnostics ours alone and 92 the reference's alone, 0 declared rows we are silent on, and 0 of 313 authored cases the reference alone rejects. The corrected figures are diagnostic only: an erratum never reclassifies a divergence category, and the published corpus is never edited.
 - **Self-assessed surface:** the action, state-machine and classifier-behavior rows have no external referee at all — the four refereed figures above cannot see them, because the pinned artifact evaluates expressions but executes neither actions nor state machines. [Spec compliance](docs/project/spec-compliance.md) counts them.
 
 What these numbers cannot show: the OMG corpora are demonstrations rather than an official conformance suite; the differential is one-directional, comparing the diagnostics the two implementations report on the same files; the Xpect suites are the pilot authors' test intent rather than a certification oracle; and none of these is a percentage of the specification — no global compliance figure is claimed anywhere.
@@ -354,7 +354,7 @@ What these numbers cannot show: the OMG corpora are demonstrations rather than a
 **Test coverage:** top-level `Test` functions (counted from the `_test.go` files, as `go test ./...` runs them) covering parsers, semantics, runtime (actions, states, instances, operators, validation), behind golden ASTs, negatives, execution conformance cases, golden traces, runtime robustness cases and gRPC conformance and robustness cases. The figures are counted from the tree when the documentation site is built into the test inventory of [spec compliance](docs/project/spec-compliance.md), never committed, so a branch adding a test does not rewrite this page. A test skips only for want of something the run did not provide, and says what: the held-image round trip declines a conformance case that creates no instance, a few gate on a PDF or Mermaid toolchain, a pinned pilot artifact, the PSSM suite, a locale, a case-insensitive filesystem or a live Flexo stack, and the OMG corpus gates skip until the corpora are downloaded unless asked to fail.
 **Parser coverage:** 110/110 bundled library files parse cleanly — the 94 official SysML v2 standard library files and the 16 non-normative OpenSysML extensions: `OpenSysML Libraries/AnalysisRecords.sysml`, `DiagramLayout.sysml`, `DocumentQueries.sysml`, `IdentityMetadata.sysml`, `MOSA.sysml`, `MigrationMetadata.sysml`, `OOSEM.sysml`, `OpenSysMLMathFunctions.kerml`, `OpenSysMLRenderings.sysml`, `RandomFunctions.kerml`, `Simulation.sysml`, `StateActivity.kerml`, `StateMachines.sysml`, `StateSpaceIntegration.sysml`, `Stochastic.sysml` and `SysMLValidation.sysml`. Conformance verified by [stdlib_conformance_test.go](internal/workspace/libs/stdlib_conformance_test.go). Grammar reference: [OMG Xtext grammar](https://github.com/Systems-Modeling/SysML-v2-Pilot-Implementation/tree/master/org.omg.kerml.xtext/src/org/omg/kerml/xtext).
 **Behavioral execution:** Calc/constraint/requirement/satisfy functional. Action/state executors handle nested invocation, control flow keywords, loop and conditional statements and the send statement (<!-- doc-counts:begin conformance-passing -->every conformance case passing<!-- doc-counts:end conformance-passing -->). Coverage is self-assessed against the specification text and the normative library: the pinned OMG pilot implementation evaluates expressions but does not execute actions or state machines headlessly, so no external implementation currently adjudicates these rows. See [spec compliance](docs/project/spec-compliance.md).
-**Reference differential:** 389 files compared diagnostic-by-diagnostic against the pinned OMG pilot implementation (`2026-08`), 359 in full agreement; every divergence is enumerated and adjudicated in [the differential](docs/project/pilot-differential.md), reproducible with `go run -C tools ./cmd/pilot-diff`.
+**Reference differential:** 390 files compared diagnostic-by-diagnostic against the pinned OMG pilot implementation (`2026-08`), 360 in full agreement; every divergence is enumerated and adjudicated in [the differential](docs/project/pilot-differential.md), reproducible with `go run -C tools ./cmd/pilot-diff`.
 **Rejection oracle:** the reverse direction — do we reject what the reference rejects? 313 hand-written invalid models validated by both implementations, 304 rejected by both, 0 the pinned pilot rejects and we accept; the remainder only we reject — the control-node succession rules the pinned pilot leaves unimplemented and a non-Boolean succession guard it accepts once the standard library types it — and every permissiveness gap is enumerated with a reproducer and likely root cause in [the rejection oracle](docs/project/pilot-rejection.md), reproducible with `go run -C tools ./cmd/pilot-reject`. We wrote every case, so the count measures our coverage of the rejection surface, not our conformance — a sample, not a proof.
 **Training examples:** 100/100 files report no semantic errors, gated by `tests/corpus/testdata/training_examples_expected.txt`; the gate does not count execution-scope warnings. Download with `./scripts/download-training-examples.sh` (from the [OMG training directory](https://github.com/Systems-Modeling/SysML-v2-Pilot-Implementation/tree/master/sysml/src/training)). See [training examples](docs/project/training-examples.md) for analysis.
 **Semantic layer:** a complete implementation of runtime operators, feature chains and validation rules. See [examples/semantic-layer/](examples/semantic-layer/) for a full demonstration.
diff --git a/api/proto/sysml.pb.go b/api/proto/sysml.pb.go
index f9ac777a28..923bdfa538 100644
--- a/api/proto/sysml.pb.go
+++ b/api/proto/sysml.pb.go
@@ -10968,7 +10968,7 @@ func (x *DocumentState) GetEnclosing() []string {
 // session's trace, in the order the run made it.
 type DocumentEvent struct {
 	state protoimpl.MessageState `protogen:"open.v1"`
-	// "accept", "send", "transition", "entry", "exit", "do", "choice" or "guard".
+	// "accept", "send", "transition", "entry", "exit", "do", "choice", "guard" or "terminate".
 	Kind string `protobuf:"bytes,1,opt,name=kind,proto3" json:"kind,omitempty"`
 	// The clock's instant when the record was made: a quantity in the clock's
 	// unit when the library reduces one, else a bare real of clock units.
diff --git a/api/proto/sysml.proto b/api/proto/sysml.proto
index 29646ff204..00fd3a4a37 100644
--- a/api/proto/sysml.proto
+++ b/api/proto/sysml.proto
@@ -2213,7 +2213,7 @@ message DocumentState {
 // DocumentEvent is one row an `Events` query answered: one record of the
 // session's trace, in the order the run made it.
 message DocumentEvent {
-  // "accept", "send", "transition", "entry", "exit", "do", "choice" or "guard".
+  // "accept", "send", "transition", "entry", "exit", "do", "choice", "guard" or "terminate".
   string kind = 1;
   // The clock's instant when the record was made: a quantity in the clock's
   // unit when the library reduces one, else a bare real of clock units.
diff --git a/changes/unreleased/run-trace-renderings.added.md b/changes/unreleased/run-trace-renderings.added.md
new file mode 100644
index 0000000000..715cf0c51d
--- /dev/null
+++ b/changes/unreleased/run-trace-renderings.added.md
@@ -0,0 +1,2 @@
+- **Render recorded runs as timelines and message sequences.** The CLI and REPL can write a behavior's state occupancy and ordered messages as text, Mermaid or PlantUML without adding model-view vocabulary. Source links connect sequence participants to their type declarations and PlantUML timeline lanes and single-state spans to their declarations.
+- A terminated machine's `terminate` event also appears in state-run traces.
diff --git a/client/java/opensysml-client/src/main/java/org/openmbee/opensysml/DocumentValue.java b/client/java/opensysml-client/src/main/java/org/openmbee/opensysml/DocumentValue.java
index 0b5022bf6d..79868c4593 100644
--- a/client/java/opensysml-client/src/main/java/org/openmbee/opensysml/DocumentValue.java
+++ b/client/java/opensysml-client/src/main/java/org/openmbee/opensysml/DocumentValue.java
@@ -264,7 +264,7 @@ record DocumentState(
    * binding one is refused.
    *
    * @param kind {@code "accept"}, {@code "send"}, {@code "transition"}, {@code "entry"}, {@code
-   *     "exit"}, {@code "do"}, {@code "choice"} or {@code "guard"}
+   *     "exit"}, {@code "do"}, {@code "choice"}, {@code "guard"} or {@code "terminate"}
    * @param time the instant the record was written at, in the runtime clock's unit — a {@link
    *     QuantityValue} when the clock carries a unit, a plain number otherwise
    * @param text the record as the trace prints it
diff --git a/client/java/opensysml-client/src/main/java/org/openmbee/opensysml/proto/DocumentEvent.java b/client/java/opensysml-client/src/main/java/org/openmbee/opensysml/proto/DocumentEvent.java
index 1bb66066e7..aab8b03cf0 100644
--- a/client/java/opensysml-client/src/main/java/org/openmbee/opensysml/proto/DocumentEvent.java
+++ b/client/java/opensysml-client/src/main/java/org/openmbee/opensysml/proto/DocumentEvent.java
@@ -66,7 +66,7 @@ private DocumentEvent() {
   private volatile java.lang.Object kind_ = "";
   /**
    * <pre>
-   * "accept", "send", "transition", "entry", "exit", "do", "choice" or "guard".
+   * "accept", "send", "transition", "entry", "exit", "do", "choice", "guard" or "terminate".
    * </pre>
    *
    * <code>string kind = 1 [json_name = "kind"];</code>
@@ -87,7 +87,7 @@ public java.lang.String getKind() {
   }
   /**
    * <pre>
-   * "accept", "send", "transition", "entry", "exit", "do", "choice" or "guard".
+   * "accept", "send", "transition", "entry", "exit", "do", "choice", "guard" or "terminate".
    * </pre>
    *
    * <code>string kind = 1 [json_name = "kind"];</code>
@@ -1321,7 +1321,7 @@ public Builder mergeFrom(
     private java.lang.Object kind_ = "";
     /**
      * <pre>
-     * "accept", "send", "transition", "entry", "exit", "do", "choice" or "guard".
+     * "accept", "send", "transition", "entry", "exit", "do", "choice", "guard" or "terminate".
      * </pre>
      *
      * <code>string kind = 1 [json_name = "kind"];</code>
@@ -1341,7 +1341,7 @@ public java.lang.String getKind() {
     }
     /**
      * <pre>
-     * "accept", "send", "transition", "entry", "exit", "do", "choice" or "guard".
+     * "accept", "send", "transition", "entry", "exit", "do", "choice", "guard" or "terminate".
      * </pre>
      *
      * <code>string kind = 1 [json_name = "kind"];</code>
@@ -1362,7 +1362,7 @@ public java.lang.String getKind() {
     }
     /**
      * <pre>
-     * "accept", "send", "transition", "entry", "exit", "do", "choice" or "guard".
+     * "accept", "send", "transition", "entry", "exit", "do", "choice", "guard" or "terminate".
      * </pre>
      *
      * <code>string kind = 1 [json_name = "kind"];</code>
@@ -1379,7 +1379,7 @@ public Builder setKind(
     }
     /**
      * <pre>
-     * "accept", "send", "transition", "entry", "exit", "do", "choice" or "guard".
+     * "accept", "send", "transition", "entry", "exit", "do", "choice", "guard" or "terminate".
      * </pre>
      *
      * <code>string kind = 1 [json_name = "kind"];</code>
@@ -1393,7 +1393,7 @@ public Builder clearKind() {
     }
     /**
      * <pre>
-     * "accept", "send", "transition", "entry", "exit", "do", "choice" or "guard".
+     * "accept", "send", "transition", "entry", "exit", "do", "choice", "guard" or "terminate".
      * </pre>
      *
      * <code>string kind = 1 [json_name = "kind"];</code>
diff --git a/client/java/opensysml-client/src/main/java/org/openmbee/opensysml/proto/DocumentEventOrBuilder.java b/client/java/opensysml-client/src/main/java/org/openmbee/opensysml/proto/DocumentEventOrBuilder.java
index 12d84f0aa0..14e3f1cb95 100644
--- a/client/java/opensysml-client/src/main/java/org/openmbee/opensysml/proto/DocumentEventOrBuilder.java
+++ b/client/java/opensysml-client/src/main/java/org/openmbee/opensysml/proto/DocumentEventOrBuilder.java
@@ -12,7 +12,7 @@ public interface DocumentEventOrBuilder extends
 
   /**
    * <pre>
-   * "accept", "send", "transition", "entry", "exit", "do", "choice" or "guard".
+   * "accept", "send", "transition", "entry", "exit", "do", "choice", "guard" or "terminate".
    * </pre>
    *
    * <code>string kind = 1 [json_name = "kind"];</code>
@@ -21,7 +21,7 @@ public interface DocumentEventOrBuilder extends
   java.lang.String getKind();
   /**
    * <pre>
-   * "accept", "send", "transition", "entry", "exit", "do", "choice" or "guard".
+   * "accept", "send", "transition", "entry", "exit", "do", "choice", "guard" or "terminate".
    * </pre>
    *
    * <code>string kind = 1 [json_name = "kind"];</code>
diff --git a/client/node/src/core/document.ts b/client/node/src/core/document.ts
index 5b2f63330c..35f69a3c90 100644
--- a/client/node/src/core/document.ts
+++ b/client/node/src/core/document.ts
@@ -190,7 +190,7 @@ export class DocumentState {
 
 /** A row an `Events` query answered: one record of a session's trace. Answered only. */
 export class DocumentEvent {
-  /** "accept", "send", "transition", "entry", "exit", "do", "choice" or "guard". */
+  /** "accept", "send", "transition", "entry", "exit", "do", "choice", "guard" or "terminate". */
   readonly kind: string;
   /** The instant the record was written at: a quantity, an int or a real. */
   readonly time: DocumentValue;
diff --git a/client/node/src/generated/sysml_pb.ts b/client/node/src/generated/sysml_pb.ts
index d943d6d93c..483b377fbb 100644
--- a/client/node/src/generated/sysml_pb.ts
+++ b/client/node/src/generated/sysml_pb.ts
@@ -6161,7 +6161,7 @@ export const DocumentStateSchema: GenMessage<DocumentState> = /*@__PURE__*/
  */
 export type DocumentEvent = Message<"sysml.DocumentEvent"> & {
   /**
-   * "accept", "send", "transition", "entry", "exit", "do", "choice" or "guard".
+   * "accept", "send", "transition", "entry", "exit", "do", "choice", "guard" or "terminate".
    *
    * @generated from field: string kind = 1;
    */
diff --git a/client/opensysml/documents.go b/client/opensysml/documents.go
index 3bcff3c860..9dba3cfdf1 100644
--- a/client/opensysml/documents.go
+++ b/client/opensysml/documents.go
@@ -100,8 +100,8 @@ type DocumentState struct {
 // DocumentEvent is a row an `Events` query answered: one record of a session's
 // trace. It is answered, never bound.
 type DocumentEvent struct {
-	// Kind is "accept", "send", "transition", "entry", "exit", "do", "choice"
-	// or "guard".
+	// Kind is "accept", "send", "transition", "entry", "exit", "do", "choice",
+	// "guard" or "terminate".
 	Kind string
 	// Time is the run's clock when the record was made: a Quantity when the
 	// clock carries a unit, a Real otherwise.
diff --git a/client/python/opensysml/document.py b/client/python/opensysml/document.py
index 5a133fcd74..f51aa9b2c6 100644
--- a/client/python/opensysml/document.py
+++ b/client/python/opensysml/document.py
@@ -159,7 +159,7 @@ class DocumentEvent:
 
     Attributes:
         kind: ``"accept"``, ``"send"``, ``"transition"``, ``"entry"``,
-            ``"exit"``, ``"do"``, ``"choice"`` or ``"guard"``
+            ``"exit"``, ``"do"``, ``"choice"``, ``"guard"`` or ``"terminate"``
         time: The instant the record was written at, in the runtime clock's
             unit — a :class:`~opensysml.values.Quantity` when the clock carries
             one, a plain number otherwise
diff --git a/client/rust/conformance/sysml.descriptor.binpb b/client/rust/conformance/sysml.descriptor.binpb
index 5d35d17b23..d7e8c23e92 100644
Binary files a/client/rust/conformance/sysml.descriptor.binpb and b/client/rust/conformance/sysml.descriptor.binpb differ
diff --git a/client/rust/opensysml/src/proto/sysml/sysml.rs b/client/rust/opensysml/src/proto/sysml/sysml.rs
index cb17005a5c..186cfcbc59 100644
--- a/client/rust/opensysml/src/proto/sysml/sysml.rs
+++ b/client/rust/opensysml/src/proto/sysml/sysml.rs
@@ -2759,7 +2759,7 @@ pub struct DocumentState {
 /// session's trace, in the order the run made it.
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct DocumentEvent {
-    /// "accept", "send", "transition", "entry", "exit", "do", "choice" or "guard".
+    /// "accept", "send", "transition", "entry", "exit", "do", "choice", "guard" or "terminate".
     #[prost(string, tag="1")]
     pub kind: ::prost::alloc::string::String,
     /// The clock's instant when the record was made: a quantity in the clock's
diff --git a/cmd/sysml/check.go b/cmd/sysml/check.go
index e9f38c1cf5..8d285b9d1c 100644
--- a/cmd/sysml/check.go
+++ b/cmd/sysml/check.go
@@ -602,6 +602,9 @@ func runChecks(files []string, exprs []string, c checks) int {
 	}
 
 	sess := newSession()
+	if len(renderRuns) > 0 {
+		sess.SetRecording(true)
+	}
 	sess.SetCheckDiverge(c.checker.diverge)
 	sess.SetCheckProperties(c.checker.properties)
 	sess.SetCheckInputs(c.checker.inputs)
@@ -789,7 +792,7 @@ func runChecks(files []string, exprs []string, c checks) int {
 			rep.verdict(v)
 		}
 		c.runQueries(sess, rep)
-		return rep.finish()
+		return finishRunCheck(rep, sess)
 	}
 	for _, value := range c.actions {
 		name, performer := repl.SplitBehavior(value)
@@ -805,7 +808,7 @@ func runChecks(files []string, exprs []string, c checks) int {
 	}
 	c.runQueries(sess, rep)
 
-	return rep.finish()
+	return finishRunCheck(rep, sess)
 }
 
 // runQueries executes each -run-query after the behaviors named have run, so a
diff --git a/cmd/sysml/main.go b/cmd/sysml/main.go
index 2c172343b6..685609f7fe 100644
--- a/cmd/sysml/main.go
+++ b/cmd/sysml/main.go
@@ -106,6 +106,7 @@ var (
 	debugMode        bool
 	quietMode        bool
 	traceMode        bool
+	renderRuns       stringSlice
 	schedule         schedulePolicy
 	listEngines      bool
 	probeEngines     bool
@@ -395,7 +396,18 @@ func runCLI() int {
 	// Get positional arguments (files to load)
 	args := flag.Args()
 
-	if renderForm != "" && renderView == "" && renderAllDir == "" {
+	if flagGiven("render-run") {
+		if message := runRenderModeMisuse(); message != "" {
+			fmt.Fprintln(os.Stderr, errPrefix, message)
+			return 2
+		}
+		if _, err := runRenderTargetsFromFlags(); err != nil {
+			fmt.Fprintln(os.Stderr, errPrefix, err)
+			return 2
+		}
+	}
+
+	if renderForm != "" && renderView == "" && renderAllDir == "" && len(renderRuns) == 0 {
 		fmt.Fprintln(os.Stderr, "sysml: -render-form is the form -render or -render-all writes; name the view to render with -render or a directory with -render-all")
 		return 2
 	}
@@ -407,8 +419,8 @@ func runCLI() int {
 		fmt.Fprintln(os.Stderr, "sysml: -render-overlay is what -render or -render-all draws over a requirement rendering's structure; name the view to render with -render or a directory with -render-all")
 		return 2
 	}
-	if renderLink != "" && renderView == "" && renderAllDir == "" && renderDoc == "" && renderDocsDir == "" {
-		fmt.Fprintln(os.Stderr, "sysml: -render-link links rendered elements to their source; name what to render with -render, -render-all, -render-document or -render-documents")
+	if renderLink != "" && renderView == "" && renderAllDir == "" && renderDoc == "" && renderDocsDir == "" && len(renderRuns) == 0 {
+		fmt.Fprintln(os.Stderr, "sysml: -render-link links rendered elements to their source; name what to render with -render, -render-all, -render-document, -render-documents or -render-run")
 		return 2
 	}
 	if renderPorts != "" && renderView == "" && renderAllDir == "" {
diff --git a/cmd/sysml/render_run.go b/cmd/sysml/render_run.go
new file mode 100644
index 0000000000..a51cf4cc8f
--- /dev/null
+++ b/cmd/sysml/render_run.go
@@ -0,0 +1,177 @@
+package main
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+	"slices"
+	"strings"
+
+	"github.com/Open-MBEE/OpenSysML/internal/exec/runtrace"
+	"github.com/Open-MBEE/OpenSysML/internal/frontend/repl"
+	"github.com/Open-MBEE/OpenSysML/internal/ir/view"
+)
+
+type runRenderTarget struct {
+	kind runtrace.Kind
+	path string
+	form view.Form
+}
+
+func runRenderModeMisuse() string {
+	switch {
+	case len(renderRuns) == 0:
+		return "-render-run needs a value of the form <timeline|sequence>=<path>"
+	case modelChecks.jsonOut && renderRunWritesStdout():
+		return "-render-run cannot write to stdout with -json; name a file for the rendering"
+	case flagGiven("compare-results"):
+		return "-render-run cannot be combined with -compare-results"
+	case len(modelChecks.actions) == 0 && len(modelChecks.states) == 0 && !modelChecks.advance.given:
+		return "-render-run needs -action, -state or -advance to record a behavior run"
+	case schedule.text == "explore":
+		return "-render-run cannot render -schedule explore; render one declared or replayed run"
+	case engine.text == "check" || engine.text == "smt" || engine.text == "all":
+		return "-render-run cannot render -engine check, smt or all; run one behavior schedule"
+	case modelChecks.runs.given || flagGiven("runs"):
+		return "-render-run cannot be combined with -runs"
+	case len(modelChecks.sweeps) > 0 || modelChecks.samples.given || flagGiven("sweep") || flagGiven("samples"):
+		return "-render-run cannot be combined with -sweep or -samples"
+	case len(modelChecks.records) > 0 || flagGiven("record-run"):
+		return "-render-run cannot be combined with -record-run"
+	case flagGiven("render") || renderView != "" || flagGiven("render-all") || renderAllDir != "":
+		return "-render-run cannot be combined with -render or -render-all"
+	case flagGiven("render-document") || renderDoc != "" || flagGiven("render-documents") || renderDocsDir != "":
+		return "-render-run cannot be combined with -render-document or -render-documents"
+	case flagGiven("convert") || convertFormat != "" || flagGiven("migrate") || migrateFormat != "":
+		return "-render-run cannot be combined with -convert or -migrate"
+	case flagGiven("query") || queryText != "":
+		return "-render-run cannot be combined with -query"
+	case outputPath != "":
+		return "-render-run names each output path; do not combine it with -output"
+	case renderPalette != "" || renderStyle != "" || renderPorts != "" || renderUnplaced != "":
+		return "-render-palette, -render-style, -render-ports and -render-unplaced apply to model renderings, not -render-run"
+	}
+	return ""
+}
+
+func renderRunWritesStdout() bool {
+	for _, value := range renderRuns {
+		_, path, ok := strings.Cut(value, "=")
+		if ok && path == "-" {
+			return true
+		}
+	}
+	return false
+}
+
+func runRenderTargetsFromFlags() ([]runRenderTarget, error) {
+	targets := make([]runRenderTarget, 0, len(renderRuns))
+	for _, value := range renderRuns {
+		kindText, path, ok := strings.Cut(value, "=")
+		if !ok || kindText == "" || path == "" {
+			return nil, fmt.Errorf("-render-run takes <timeline|sequence>=<path>, not %q", value)
+		}
+		kind, ok := runtrace.ParseKind(kindText)
+		if !ok {
+			return nil, fmt.Errorf("unknown -render-run kind %q; want %s", kindText, strings.Join(runRenderKindNames(), ", "))
+		}
+		form := view.Form(renderForm)
+		if renderForm == "" {
+			if path == "-" {
+				form = view.FormText
+			} else {
+				var found bool
+				form, found = runRenderFormFromPath(path)
+				if !found {
+					return nil, fmt.Errorf("-render-run path %q has no recognized form extension; use -render-form text, mermaid or plantuml", path)
+				}
+			}
+		} else if !slices.Contains(view.Forms(), form) {
+			return nil, fmt.Errorf("unknown rendering form %q; -render-form takes %s", renderForm, formList())
+		}
+		probe := &view.Rendering{Kind: runRenderViewKind(kind), Run: true}
+		if _, err := probe.WriteWith(form, view.Options{Links: view.Links{Template: renderLink}}); err != nil {
+			return nil, fmt.Errorf("-render-run %s: %w", kind, err)
+		}
+		targets = append(targets, runRenderTarget{kind: kind, path: path, form: form})
+	}
+	return targets, nil
+}
+
+func runRenderKindNames() []string {
+	kinds := runtrace.Kinds()
+	names := make([]string, len(kinds))
+	for i, kind := range kinds {
+		names[i] = string(kind)
+	}
+	return names
+}
+
+func runRenderViewKind(kind runtrace.Kind) view.Kind {
+	if kind == runtrace.KindTimeline {
+		return view.KindTimeline
+	}
+	return view.KindSequence
+}
+
+func runRenderFormFromPath(path string) (view.Form, bool) {
+	switch strings.ToLower(filepath.Ext(path)) {
+	case ".mmd", ".mermaid":
+		return view.FormMermaid, true
+	case ".puml", ".plantuml":
+		return view.FormPlantUML, true
+	case ".txt":
+		return view.FormText, true
+	case ".dot", ".gv":
+		return view.FormDot, true
+	default:
+		return "", false
+	}
+}
+
+func finishRunCheck(rep *reporter, sess *repl.Session) int {
+	status := rep.finish()
+	if len(renderRuns) == 0 {
+		return status
+	}
+	targets, err := runRenderTargetsFromFlags()
+	if err != nil {
+		fmt.Fprintln(os.Stderr, errPrefix, err)
+		return 2
+	}
+	var sites view.Sites
+	if renderLink != "" {
+		sites, err = sess.ViewSites()
+		if err != nil {
+			fmt.Fprintln(os.Stderr, errPrefix, err)
+			return 2
+		}
+	}
+	for _, target := range targets {
+		rendering, err := sess.RunTraceRendering(target.kind)
+		if err != nil {
+			fmt.Fprintln(os.Stderr, errPrefix, err)
+			return 2
+		}
+		artifact, err := rendering.WriteWith(target.form, view.Options{
+			Width: artifactWidth(target.path, terminalWidth()),
+			Links: view.Links{Template: renderLink, Sites: sites},
+		})
+		if err != nil {
+			fmt.Fprintln(os.Stderr, errPrefix, err)
+			return 2
+		}
+		name := "run " + string(target.kind)
+		reportRenderNoticesFrom(rendering, name)
+		if target.path == "-" {
+			if err := writeArtifact(artifact, target.form); err != nil {
+				fmt.Fprintln(os.Stderr, errPrefix, err)
+				return 2
+			}
+		} else if err := writeArtifactFile(target.path, artifact, target.form); err != nil {
+			fmt.Fprintln(os.Stderr, errPrefix, err)
+			return 2
+		}
+	}
+	return status
+}
diff --git a/cmd/sysml/render_run_test.go b/cmd/sysml/render_run_test.go
new file mode 100644
index 0000000000..b82245bf39
--- /dev/null
+++ b/cmd/sysml/render_run_test.go
@@ -0,0 +1,246 @@
+package main
+
+import (
+	"os"
+	"path/filepath"
+	"sort"
+	"strings"
+	"testing"
+)
+
+func TestRenderRunExampleMatchesGoldens(t *testing.T) {
+	data, err := os.ReadFile(filepath.Join("..", "..", "examples", "run-timeline", "run-timeline.sysml"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	binary := buildCLI(t)
+	dir := t.TempDir()
+	outputs := map[string]string{
+		"example-timeline.text.golden":     filepath.Join(dir, "timeline.txt"),
+		"example-timeline.mermaid.golden":  filepath.Join(dir, "timeline.mmd"),
+		"example-timeline.plantuml.golden": filepath.Join(dir, "timeline.puml"),
+		"example-sequence.text.golden":     filepath.Join(dir, "sequence.txt"),
+		"example-sequence.mermaid.golden":  filepath.Join(dir, "sequence.mmd"),
+		"example-sequence.plantuml.golden": filepath.Join(dir, "sequence.puml"),
+	}
+	args := []string{
+		"-instantiate", "RunTimeline::mission",
+		"-state", "RunTimeline::Controller::modes RunTimeline::mission.controller",
+		"-state", "RunTimeline::Instrument::modes RunTimeline::mission.instrument",
+		"-advance", "6",
+	}
+	keys := make([]string, 0, len(outputs))
+	for golden := range outputs {
+		keys = append(keys, golden)
+	}
+	sort.Strings(keys)
+	for _, golden := range keys {
+		path := outputs[golden]
+		kind := "timeline"
+		if strings.Contains(golden, "sequence") {
+			kind = "sequence"
+		}
+		args = append(args, "-render-run", kind+"="+path)
+	}
+	got := check(t, binary, string(data), args...)
+	if got.status != 0 {
+		t.Fatalf("exit status = %d\n%s", got.status, got.output())
+	}
+	for _, golden := range keys {
+		path := outputs[golden]
+		actual, err := os.ReadFile(path) // #nosec G304 -- the path is created by the test.
+		if err != nil {
+			t.Fatal(err)
+		}
+		goldenPath := filepath.Join("..", "..", "internal", "exec", "runtrace", "testdata", golden)
+		want, err := os.ReadFile(goldenPath)
+		if err != nil {
+			t.Fatal(err)
+		}
+		if string(actual) != string(want) {
+			t.Errorf("%s differs from %s", path, goldenPath)
+		}
+	}
+}
+
+func TestRenderRunWritesEachFormAfterTheVerdict(t *testing.T) {
+	binary := buildCLI(t)
+	dir := t.TempDir()
+	timelinePath := filepath.Join(dir, "timeline.txt")
+	sequencePath := filepath.Join(dir, "sequence.mmd")
+	got := check(t, binary, behaviorModel,
+		"-state", "Mission::Cycle", "-advance", "15",
+		"-render-run", "timeline="+timelinePath,
+		"-render-run", "sequence="+sequencePath,
+	)
+	if got.status != 0 {
+		t.Fatalf("exit status = %d\n%s", got.status, got.output())
+	}
+	if !strings.Contains(got.stdout, `Started state machine executor for "Mission::Cycle"`) {
+		t.Errorf("the run verdict is missing from stdout:\n%s", got.stdout)
+	}
+	if strings.Contains(got.stdout, "[trace]") {
+		t.Errorf("silent recording printed trace lines:\n%s", got.stdout)
+	}
+	timeline, err := os.ReadFile(timelinePath) // #nosec G304 -- this path is created by the test.
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !strings.Contains(string(timeline), "run - timeline rendering") ||
+		!strings.Contains(string(timeline), "working") {
+		t.Errorf("timeline output is missing the run's state occupancy:\n%s", timeline)
+	}
+	sequence, err := os.ReadFile(sequencePath) // #nosec G304 -- this path is created by the test.
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !strings.Contains(string(sequence), "sequenceDiagram") ||
+		!strings.Contains(string(sequence), "the run recorded no message") {
+		t.Errorf("sequence output is missing its empty-run rendering:\n%s", sequence)
+	}
+	if !strings.Contains(got.stderr, "wrote "+timelinePath) || !strings.Contains(got.stderr, "wrote "+sequencePath) {
+		t.Errorf("stderr does not report both artifacts:\n%s", got.stderr)
+	}
+}
+
+func TestRenderRunLinksTimelineAndSequence(t *testing.T) {
+	data, err := os.ReadFile(filepath.Join("..", "..", "examples", "run-timeline", "run-timeline.sysml"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	binary := buildCLI(t)
+	dir := t.TempDir()
+	timelinePath := filepath.Join(dir, "timeline.puml")
+	sequencePath := filepath.Join(dir, "sequence.mmd")
+	got := check(t, binary, string(data),
+		"-instantiate", "RunTimeline::mission",
+		"-state", "RunTimeline::Controller::modes RunTimeline::mission.controller",
+		"-state", "RunTimeline::Instrument::modes RunTimeline::mission.instrument",
+		"-advance", "6",
+		"-render-link", "https://example.test/src/{file}#L{line}",
+		"-render-run", "timeline="+timelinePath,
+		"-render-run", "sequence="+sequencePath,
+	)
+	if got.status != 0 {
+		t.Fatalf("exit status = %d\n%s", got.status, got.output())
+	}
+	timeline, err := os.ReadFile(timelinePath) // #nosec G304 -- this path is created by the test.
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !strings.Contains(string(timeline), `[[https://example.test/src/`) ||
+		!strings.Contains(string(timeline), `#L`) ||
+		!strings.Contains(string(timeline), `RunTimeline::mission.controller.modes`) {
+		t.Errorf("linked timeline is missing source links or visible labels:\n%s", timeline)
+	}
+	sequence, err := os.ReadFile(sequencePath) // #nosec G304 -- this path is created by the test.
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !strings.Contains(string(sequence), "link n0: Source @ https://example.test/src/") ||
+		!strings.Contains(string(sequence), "RunTimeline::mission.controller") {
+		t.Errorf("linked sequence is missing participant links or visible labels:\n%s", sequence)
+	}
+}
+
+func TestRenderRunRejectsInvalidLinkBeforeWriting(t *testing.T) {
+	binary := buildCLI(t)
+	path := filepath.Join(t.TempDir(), "timeline.puml")
+	got := check(t, binary, behaviorModel,
+		"-state", "Mission::Cycle", "-advance", "1",
+		"-render-link", "https://example.test/{unknown}",
+		"-render-run", "timeline="+path,
+	)
+	if got.status != 2 || !strings.Contains(got.stderr, "unknown link template placeholder {unknown}") {
+		t.Fatalf("status = %d, want invalid-link refusal:\n%s", got.status, got.output())
+	}
+	if _, err := os.Stat(path); !os.IsNotExist(err) {
+		t.Errorf("rendering output path exists after invalid-link refusal: stat error = %v", err)
+	}
+}
+
+func TestRenderRunWritesStdoutWithoutLosingTheVerdict(t *testing.T) {
+	binary := buildCLI(t)
+	got := check(t, binary, behaviorModel,
+		"-state", "Mission::Cycle", "-advance", "1",
+		"-render-run", "timeline=-",
+	)
+	if got.status != 0 {
+		t.Fatalf("exit status = %d\n%s", got.status, got.output())
+	}
+	for _, want := range []string{`Started state machine executor for "Mission::Cycle"`, "run - timeline rendering", "waiting"} {
+		if !strings.Contains(got.stdout, want) {
+			t.Errorf("stdout is missing %q:\n%s", want, got.stdout)
+		}
+	}
+	if strings.Contains(got.stdout, "[trace]") {
+		t.Errorf("silent recording printed trace lines:\n%s", got.stdout)
+	}
+}
+
+func TestRenderRunRefusesJSONStdoutAndCompareResults(t *testing.T) {
+	binary := buildCLI(t)
+	dir := t.TempDir()
+	cases := []struct {
+		name string
+		args []string
+		want string
+		path string
+	}{
+		{
+			name: "JSON stdout",
+			args: []string{
+				"-state", "Mission::Cycle", "-advance", "1", "-json",
+				"-render-run", "timeline=" + filepath.Join(dir, "timeline.txt"),
+				"-render-run", "sequence=-",
+			},
+			want: "-render-run cannot write to stdout with -json; name a file for the rendering",
+			path: filepath.Join(dir, "timeline.txt"),
+		},
+		{
+			name: "compare results",
+			args: []string{
+				"-state", "Mission::Cycle", "-advance", "1",
+				"-compare-results", filepath.Join(dir, "missing.json"),
+				"-render-run", "timeline=" + filepath.Join(dir, "timeline.txt"),
+			},
+			want: "-render-run cannot be combined with -compare-results",
+			path: filepath.Join(dir, "timeline.txt"),
+		},
+	}
+	for _, tc := range cases {
+		t.Run(tc.name, func(t *testing.T) {
+			got := check(t, binary, behaviorModel, tc.args...)
+			if got.status != 2 || !strings.Contains(got.stderr, tc.want) {
+				t.Errorf("status = %d, want 2 with %q:\n%s", got.status, tc.want, got.output())
+			}
+			if _, err := os.Stat(tc.path); !os.IsNotExist(err) {
+				t.Errorf("rendering output path exists after refusal: stat error = %v", err)
+			}
+		})
+	}
+}
+
+func TestRenderRunRejectsUnsupportedModesAndForms(t *testing.T) {
+	binary := buildCLI(t)
+	cases := []struct {
+		name string
+		args []string
+		want string
+	}{
+		{"no behavior", []string{"-render-run", "timeline=run.txt"}, "needs -action, -state or -advance"},
+		{"unknown kind", []string{"-state", "Mission::Cycle", "-render-run", "other=run.txt"}, "unknown -render-run kind"},
+		{"unknown extension", []string{"-state", "Mission::Cycle", "-render-run", "timeline=run.svg"}, "use -render-form"},
+		{"dot refused", []string{"-state", "Mission::Cycle", "-render-run", "timeline=run.dot"}, "not written as dot"},
+		{"model rendering conflict", []string{"-state", "Mission::Cycle", "-render-run", "timeline=run.txt", "-render", "Demo::view"}, "cannot be combined with -render"},
+		{"query conflict", []string{"-state", "Mission::Cycle", "-render-run", "timeline=run.txt", "-query", "sysml:name=*"}, "cannot be combined with -query"},
+	}
+	for _, tc := range cases {
+		t.Run(tc.name, func(t *testing.T) {
+			got := check(t, binary, behaviorModel, tc.args...)
+			if got.status != 2 || !strings.Contains(got.stderr, tc.want) {
+				t.Errorf("status = %d, want 2 with %q:\n%s", got.status, tc.want, got.output())
+			}
+		})
+	}
+}
diff --git a/cmd/sysml/usage.go b/cmd/sysml/usage.go
index 36a9161aeb..a050f40e25 100644
--- a/cmd/sysml/usage.go
+++ b/cmd/sysml/usage.go
@@ -682,7 +682,7 @@ func registerFlags(fs *flag.FlagSet) {
 	fs.StringVar(&renderAllDir, "render-all", "", "Render every declared view into this directory")
 	fs.StringVar(&renderForm, "render-form", "", "Form -render or -render-all writes: text, mermaid, markdown, dot, plantuml, d2, csv or tsv (csv and tsv for a table or matrix); D2 writes tree, interconnection, state, action, sequence, requirement, definition and package renderings, not case or mixed; default from the destination for -render, each kind's machine form for -render-all")
 	fs.StringVar(&renderPalette, "render-palette", "", "Palette the dot, mermaid, plantuml or d2 form fills nodes from, by keyword family: okabe-ito, tol-bright, tol-muted, tol-light, brewer-set2, brewer-dark2, viridis or cividis; default black and white")
-	fs.StringVar(&renderLink, "render-link", "", "Link template for rendered elements: {file} is the path as loaded; use absolute paths for vscode:// or file:// links. Placeholders: {file}, {line}, {col}, {qname}, {id}")
+	fs.StringVar(&renderLink, "render-link", "", "Source link template for -render, -render-all, -render-document, -render-documents and -render-run. Placeholders: {file}, {line}, {col}, {qname}, {id}; {file} is the path as loaded (use absolute paths for vscode:// or file:// links)")
 	fs.StringVar(&renderStyle, "render-style", "", "Drawing style of the dot or mermaid form: pilot (default), the Pilot visualizer's black and white, or cameo, the look of Cameo Systems Modeler; applies to -render, -render-all and document diagrams")
 	fs.StringVar(&renderPorts, "render-ports", "", "How much of a part's ports -render or -render-all draws on an interconnection or mixed rendering: minimal (default), the ports its interconnection edges end at, each a small square on the part's border named beside it, or full, every port, labelled name : Type")
 	fs.StringVar(&renderOverlay, "render-overlay", "", "What -render or -render-all draws over a requirement rendering's structure: verdicts runs the verification cases verifying each requirement and colours and labels it by their verdicts; default none, a purely structural drawing")
@@ -697,6 +697,7 @@ func registerFlags(fs *flag.FlagSet) {
 	fs.BoolVar(&debugMode, "debug", false, "Report every diagnostic over the whole session buffer, with the pass that produced it")
 	fs.BoolVar(&quietMode, "quiet", false, "Report errors only, suppressing warnings")
 	fs.BoolVar(&traceMode, "trace", false, "Report each execution step: expression evaluation, calc invocation, action tokens, state transitions")
+	fs.Var(&renderRuns, "render-run", "Render the trace of a run as timeline or sequence into path (`-` is stdout); form comes from -render-form or the path extension")
 	fs.BoolVar(&memStats, "memstats", false, "Report on stderr what the run cost: wall time, memory allocated, memory taken from the OS")
 
 	fs.Var(&deprecatedFlag{instead: "-to has been replaced by -convert, as `sysml model.sysml -convert ttl`"}, "to", "Replaced by -convert, which names the output format")
@@ -858,6 +859,7 @@ func optionGroups() []usage.OptionGroup {
 			usage.Opt("debug", ""),
 			usage.Opt("quiet", ""),
 			usage.Opt("trace", ""),
+			usage.Opt("render-run", "<kind>=<path>"),
 			usage.Opt("cpuprofile", fileArg),
 			usage.Opt("memprofile", fileArg),
 			usage.Opt("memstats", ""),
diff --git a/docs/internals/architecture.md b/docs/internals/architecture.md
index 449cdbc9d1..e2fb38afe0 100644
--- a/docs/internals/architecture.md
+++ b/docs/internals/architecture.md
@@ -841,11 +841,11 @@ Every behavioral feature must have:
 <!-- doc-counts:begin refereed-figures -->
 **Measured against the pinned reference** (`PILOT_TAG=2026-08`, artifact `0.62.0`). Every number below is generated by `make docs-counts` from the committed baselines and gated; none of them is typed in by hand.
 
-- **Corpus agreement:** 359 of 389 files agree diagnostic-by-diagnostic; 44 diagnostics are ours alone and 92 the reference's alone, and the first number must be read by root: the aggregate includes candidate conformance differences, intentional execution-scope warnings on reference corpora and diagnostics from our own examples ([differential](../project/pilot-differential.md), `go run -C tools ./cmd/pilot-diff`).
+- **Corpus agreement:** 360 of 390 files agree diagnostic-by-diagnostic; 44 diagnostics are ours alone and 92 the reference's alone, and the first number must be read by root: the aggregate includes candidate conformance differences, intentional execution-scope warnings on reference corpora and diagnostics from our own examples ([differential](../project/pilot-differential.md), `go run -C tools ./cmd/pilot-diff`).
 - **Declared-diagnostic silence:** of the 512 declared `errors` rows in the reference's own Xpect suites, we report nothing for 0. 245 we report word-for-word; 248 wording-only and 7 location-only differences are agreement in substance and are not counted as gaps; 0 more we report as a warning and 2 elsewhere in the file ([Xpect oracle](../project/pilot-xpect.md), `go run -C tools ./cmd/pilot-xpect`).
 - **Scope agreement:** 230 of 230 declared scope assertions match exactly (same source).
 - **Permissiveness gaps:** of 313 invalid models we wrote ourselves, the reference rejects 4 that we accept by default, and 300 both reject; 4 further cases agree only when we are asked strictly. We authored every one of these cases ourselves, so the denominator measures the reach of our own corpus and not our conformance; agreement reached only under an opt-in strict mode is weaker evidence than agreement by default ([rejection oracle](../project/pilot-rejection.md), `go run -C tools ./cmd/pilot-reject`).
-- **Declared errata:** the registry declares 12 defect(s) in the published reference material — 4 with a specification-derived correction, 8 documented without one, since no intended reading can be inferred ([OMG issues](../project/omg-issues.md), `tools/oracle/errata`). Every figure above is as published and stays the conformance statement; running the same oracles over the corrected text instead reports 360 of 389 files agreeing, 43 diagnostics ours alone and 92 the reference's alone, 0 declared rows we are silent on, and 0 of 313 authored cases the reference alone rejects. The corrected figures are diagnostic only: an erratum never reclassifies a divergence category, and the published corpus is never edited.
+- **Declared errata:** the registry declares 12 defect(s) in the published reference material — 4 with a specification-derived correction, 8 documented without one, since no intended reading can be inferred ([OMG issues](../project/omg-issues.md), `tools/oracle/errata`). Every figure above is as published and stays the conformance statement; running the same oracles over the corrected text instead reports 361 of 390 files agreeing, 43 diagnostics ours alone and 92 the reference's alone, 0 declared rows we are silent on, and 0 of 313 authored cases the reference alone rejects. The corrected figures are diagnostic only: an erratum never reclassifies a divergence category, and the published corpus is never edited.
 - **Self-assessed surface:** the action, state-machine and classifier-behavior rows have no external referee at all — the four refereed figures above cannot see them, because the pinned artifact evaluates expressions but executes neither actions nor state machines. [Spec compliance](../project/spec-compliance.md) counts them.
 
 What these numbers cannot show: the OMG corpora are demonstrations rather than an official conformance suite; the differential is one-directional, comparing the diagnostics the two implementations report on the same files; the Xpect suites are the pilot authors' test intent rather than a certification oracle; and none of these is a percentage of the specification — no global compliance figure is claimed anywhere.
diff --git a/docs/internals/design/observing-a-run.md b/docs/internals/design/observing-a-run.md
index 2d682940c1..b570bb1319 100644
--- a/docs/internals/design/observing-a-run.md
+++ b/docs/internals/design/observing-a-run.md
@@ -60,12 +60,13 @@ element, and the values.
 
 - **The trace is already an event stream, not a log.** `TraceRecord` (`internal/exec/runtime/trace.go`)
   carries a `TraceKind` — `transition`, `entry`, `exit`, `do`, `accept`, `send`, `choice`,
-  `guard`, and `line` for the printed-only records — a `TraceOrigin` (the clock instant, the
-  object whose behavior made it, that behavior), the state or the transition's `From`/`To`, the
-  event and its typed `Payload`, and the `Target` of a send. `NewEventRecorder` already keeps the
-  stream for queries (`DocumentQueries`, the checker's state stream) without printing it; the
-  REPL's `%trace on` and the CLI's `-trace` print it. Every kind a listener needs to fire on is
-  already recorded at the point it happens; what is missing is a *sink other than the slice*.
+  `guard`, `terminate`, and `line` for the printed-only records — a `TraceOrigin` (the clock
+  instant, the object whose behavior made it, that behavior), the state or the transition's
+  `From`/`To`, the event and its typed `Payload`, and the `Target` of a send. `NewEventRecorder`
+  already keeps the stream for queries (`DocumentQueries`, the checker's state stream) without
+  printing it; the REPL's `%trace on` and the CLI's `-trace` print it. Every kind a listener needs
+  to fire on is already recorded at the point it happens; what is missing is a *sink other than the
+  slice*.
 - **The configuration is already a fact the executor answers.** `StateExecutor.ActiveStates()`
   and `ActiveLeaves()` give the active-state set with its region structure (a composite with
   regions is active with one leaf per region — [orthogonal regions](orthogonal-regions.md));
diff --git a/docs/manual/query-cookbook.md b/docs/manual/query-cookbook.md
index a8adf35f22..172f04611e 100644
--- a/docs/manual/query-cookbook.md
+++ b/docs/manual/query-cookbook.md
@@ -1823,7 +1823,8 @@ sysml> %run-query Accepted root=spareDome
 
 `kind` names the records to keep — `accept`, `send`, `transition`, `entry`,
 `exit`, `do`, `choice` (a due order or region order the run drew, with
-`alternatives` and `taken`) or `guard` (one it could not evaluate), several
+`alternatives` and `taken`), `guard` (one it could not evaluate) or `terminate`
+(a state machine's performance ending), several
 separated by commas, `all` by default — and a `source` left out reads every
 object's records. `since` and `before` take a duration or a bare number of
 the clock's seconds; a bound that is not a duration (`1 [m]`), or an interval
diff --git a/docs/project/pilot-differential-baseline.json b/docs/project/pilot-differential-baseline.json
index 51abc63919..dbcb189b12 100644
--- a/docs/project/pilot-differential-baseline.json
+++ b/docs/project/pilot-differential-baseline.json
@@ -61,8 +61,8 @@
         "name": "examples",
         "dir": "examples",
         "origin": "ours",
-        "files": 51,
-        "digest": "sha256:0f6842f811dfd7a78b6218b8183fb8f43410a45b909b10ef9a6c4db14d8d6831"
+        "files": 52,
+        "digest": "sha256:363fc56b49d358d4146b7f7393eec10c67cbf0b7f90d553c1fa7e7c3951982d9"
       },
       {
         "name": "probes",
@@ -79,11 +79,11 @@
         "digest": "sha256:7899f774dc78406305374ab88f654965b502e10fdc6cc8085eec7a16226b8996"
       }
     ],
-    "recorded": "2026-10-06"
+    "recorded": "2026-10-07"
   },
   "totals": {
-    "files": 389,
-    "filesFullyAgreeing": 359,
+    "files": 390,
+    "filesFullyAgreeing": 360,
     "agreement": 45,
     "severityMismatch": 1,
     "openSysMLOnly": 44,
@@ -931,8 +931,8 @@
       "name": "examples",
       "dir": "examples",
       "totals": {
-        "files": 51,
-        "filesFullyAgreeing": 45,
+        "files": 52,
+        "filesFullyAgreeing": 46,
         "agreement": 0,
         "severityMismatch": 0,
         "openSysMLOnly": 7,
@@ -1777,8 +1777,8 @@
       }
     ],
     "totals": {
-      "files": 389,
-      "filesFullyAgreeing": 360,
+      "files": 390,
+      "filesFullyAgreeing": 361,
       "agreement": 45,
       "severityMismatch": 1,
       "openSysMLOnly": 43,
diff --git a/docs/project/pilot-differential.md b/docs/project/pilot-differential.md
index e7884bdaab..eee918fc35 100644
--- a/docs/project/pilot-differential.md
+++ b/docs/project/pilot-differential.md
@@ -241,7 +241,7 @@ nor double-counted as two independent disagreements.
 
 ---
 
-## Results (pilot `2026-08`, 389 files)
+## Results (pilot `2026-08`, 390 files)
 
 | Root | Files | Fully agreeing | Ours | Pilot | Agreed | Severity-only | Only ours | Only pilot |
 |---|---:|---:|---:|---:|---:|---:|---:|---:|
@@ -250,9 +250,9 @@ nor double-counted as two independent disagreements.
 | `examples/pilot-corpora/sysml-validation` | 56 | 56 | 0 | 0 | 0 | 0 | 0 | 0 |
 | `examples/pilot-corpora/kerml-examples` | 58 | 56 | 9 | 0 | 0 | 0 | 9 | 0 |
 | `tests/testdata` | 21 | 11 | 55 | 77 | 45 | 1 | 9 | 31 |
-| `examples` | 51 | 45 | 7 | 61 | 0 | 0 | 7 | 61 |
+| `examples` | 52 | 46 | 7 | 61 | 0 | 0 | 7 | 61 |
 | `tools/referee/diff/testdata` (probes) | 4 | 1 | 6 | 0 | 0 | 0 | 6 | 0 |
-| **Total** | **389** | **359** | **90** | **138** | **45** | **1** | **44** | **92** |
+| **Total** | **390** | **360** | **90** | **138** | **45** | **1** | **44** | **92** |
 
 **Read the `only ours` total by root, never as one number.** Step 2 removes nine resolver false
 positives from the reference's **own** corpora: `pilot-examples` 16 → **7** and
@@ -1184,7 +1184,7 @@ page's history.
 
 | Count | Now |
 |---|---:|
-| overall: fully agreeing / only ours / our diagnostics | **359 / 44 / 90** |
+| overall: fully agreeing / only ours / our diagnostics | **360 / 44 / 90** |
 | only pilot | **92** |
 | pilot diagnostics | **138** |
 | severity-only | **1** |
diff --git a/docs/project/roadmap.md b/docs/project/roadmap.md
index cf4fafbb58..6c512fe5fa 100644
--- a/docs/project/roadmap.md
+++ b/docs/project/roadmap.md
@@ -1935,9 +1935,10 @@ the inverse — the held objects whose machine is in the named state, by leaf, b
 by dotted path — over the same population `all T` and `Objects` read (X5, Q2). `Events(source,
 kind, since, before)` answers **event rows**: the trace in the order the run made it — accepts,
 sends, transitions, state entry, exit and do steps, `choice` draws with their alternatives and the
-one taken (region order and due order among them), unevaluable guards — each with its instant on
-`Context.Clock()` (A5), its object and machine, the states it touches, its payload and the line
-`-trace` prints; `kind` keeps one or several kinds and `[since, before)` is inclusive at the start,
+one taken (region order and due order among them), unevaluable guards and state-machine
+termination — each with its instant on `Context.Clock()` (A5), its object and machine, the states it
+touches, its payload and the line `-trace` prints; `kind` keeps one or several kinds and
+`[since, before)` is inclusive at the start,
 exclusive at the end, in the clock's unit or as a duration. The representation queried is the one
 the runtime records: `runtime.TraceRecorder` keeps a typed `TraceRecord` per event and the printer
 writes `-trace`'s lines from those records, so the two cannot disagree and the printed trace is
diff --git a/docs/project/spec-compliance.md b/docs/project/spec-compliance.md
index 9fa290c48d..a3edb37ab8 100644
--- a/docs/project/spec-compliance.md
+++ b/docs/project/spec-compliance.md
@@ -2657,6 +2657,15 @@ boundaries; the landed Track E behavior is recorded in the execution rows and th
 | `trace_test.go` | Golden trace test infrastructure | ~200 |
 | `trace_calc_test.go` | Trace determinism and canonical rendering unit tests | ~180 |
 
+### Run renderings
+
+| Run output | Implementation | Tests | Status |
+|---|---|---|---|
+| State occupancy over clock time, per object machine, with transitions and choice/guard marks; parallel leaves are keyed by state and region, colliding labels use the shortest distinguishing state path or region, termination closes occupancy, and the 200-span cap retains stable lane prefixes ending no later than each lane's first dropped instant while preserving earlier ends across inactive gaps | `internal/exec/runtrace/timeline.go` `Timeline`, `stateKey`, `applyTimelineLimit`; `internal/ir/view/run_timeline.go` text, Mermaid and PlantUML writers | `internal/exec/runtrace/runtrace_test.go`; parallel-region, termination and capped run-rendering goldens under `internal/exec/runtrace/testdata/` | ✅ Implemented and tested |
+| Ordered sends and accepts between objects, including unmatched and environment messages; nonzero message serials pair exactly, while serial-zero traces retain FIFO event/target pairing | `internal/exec/runtrace/sequence.go` `Sequence`; `internal/exec/runtime/trace.go` `TraceRecord.Message` | `internal/exec/runtrace/runtrace_test.go`; serial-pairing and existing run-rendering goldens under `internal/exec/runtrace/testdata/` | ✅ Implemented and tested |
+| State trace records retain the written state path and innermost orthogonal region; termination records retain their printed line while exposing the ending instant as an `Events(kind = "terminate")` row | `internal/exec/runtime/trace.go` `TraceRecord`, `TraceTerminate`; `internal/exec/runtime/state_executor.go` `StateExecutor.RegionOf`, `StateExecutor.terminateMachine`; `internal/doc/queryexec/events.go` `eventKinds`; `internal/exec/runtrace/timeline.go` | `internal/exec/runtime/trace_records_test.go` `TestStateTraceRecordsCarryWrittenPathsAndInnermostRegions`; runtrace termination fixture and golden | ✅ Implemented and tested |
+| Located declarations flow from state-entry/exit records into run views: PlantUML timeline lanes link to machine declarations and single-state spans to state declarations; run sequence participants link to their instance types, while parallel spans and Mermaid gantt timelines remain unlinked | `internal/exec/runtime/state_executor.go` `stateSourceOrigin`; `internal/exec/runtime/trace.go` `TraceRecord.Source`; `internal/exec/runtrace/timeline.go`, `sequence.go`; `internal/ir/view/run_timeline.go`, `links.go` | linked run-rendering goldens under `internal/exec/runtrace/testdata/`; `internal/ir/view/run_timeline_test.go`; CLI and REPL run-rendering link tests | ✅ Implemented and tested |
+
 ### Runtime bounds: every limit a model can reach
 
 A run is bounded, and a bound that silently changed a result would be the worst outcome, so each
@@ -3186,7 +3195,7 @@ It does not mutate the workspace or re-derive a parallel semantic representation
 | `Except(source, exclude)` and `Union(source, other)` are ordered set operations over rows: `Except` keeps the source rows absent from `exclude` once each in source order, `Union` emits the source rows then the rows of `other` not yet present, each row once; identity is the semantic identity traversal deduplicates by — `symbols.KeyOf` for a model element, the instance for a held object, for a verdict its assertion with the object it was checked on (its path when no object is held), for a state its object, machine and state path, and for an event its record's place in the trace; `Union` refuses inputs whose projected columns differ (`ErrorInvalidArgument`) | `queryexec/setops.go` `executor.evaluateExcept`, `executor.evaluateUnion`, `setKeyOf`, `sameColumns` | `queryexec/setops_test.go:TestExecuteSetOperationsOverElements`, `:TestExecuteSetOperationsComposeCoverage`, `:TestExecuteSetOperationsKeepProjectedColumns`, `:TestExecuteSetOperationsOverSessionObjects`, `:TestExecuteSetOperationsOverVerdicts`, `:TestExecuteSetOperationsOverStatesAndEvents` | ✅ Implemented |
 | `States(source)` answers the state each session object's machine is in **now**, as **state rows**: one per active leaf across every orthogonal region, the object as `object`/`path` (the `ValueObject` the source row was), `machine` the exhibited usage, `name` the leaf, `statePath` its dotted path under the machine (`on.run`; a synthesized region owner of a `parallel` state is left out), `region` the orthogonal region the leaf runs in and `enclosing` the active composite states above it, the row standing for the state declaration so its own properties read too. `InState(name)` is the inverse: the held objects, each once, whose machine is in the named leaf or composite state, by simple name or dotted path, as object rows. Both read the session's held roots as `Objects` does (`ErrorNoRuntime` without a session), refuse an object exhibiting no state machine (`ErrorNoStateMachine`), a source row that is no object (`ErrorNotAnObject`) and a state no held machine declares (`ErrorUnknownState`); they read `StateExecutor.ActiveStates` and move no clock | `queryplan/plan.go` `OperationStates`, `OperationInState`; `queryplan/compiler.go` (`DocumentQueries::States`, `InState`); `queryexec/value.go` `ValueState`; `queryexec/state.go` `State`, `StateValue`, `Value.State`; `queryexec/states.go` `executor.evaluateStates`, `executor.evaluateInState`, `executor.objectArgument`, `stateMachinesOf`, `activeState`, `regionName`, `machineName`, `stateSymbol`, `stateNamed`, `machineDeclaresState`, `executor.statePropertyValues`; `queryexec/errors.go` `ErrorNoStateMachine`, `ErrorUnknownState`, `ErrorStateRow`; `runtime/state_executor.go` `StateExecutor.ActiveStates`, `EnclosingStates`, `StatePath`; `libs/stdlib/OpenSysML Libraries/DocumentQueries.sysml` `States`, `InState`, `State` | `queryexec/states_test.go:TestExecuteStatesListsEveryActiveLeaf`, `:TestExecuteStateRowsThroughRowOperations`, `:TestExecuteInStateFindsObjectsByLeafOrEnclosingState`, `:TestExecuteStatesRefusals`; `repl/docquery_states_test.go:TestRunQueryStatesOverSession`; `repl/cookbook_states_test.go:TestCookbookStateAndEventRecipes` | ✅ Implemented |
 | A terminated state machine holds no active configuration, so `States` answers no row for its object and `InState` matches nothing, while a machine that reached `done` reports it as the final state; a `States` or `Events` `source` bound to an object the run destroyed is refused with `ErrorObjectDestroyed` naming the object and the activation mark of its destruction, rather than answering a stale row or surfacing an unevaluable-feature failure; a destroyed object leaves the population — `Objects`, `InState` and element-derived sources skip it and its label still resolves for `Events` rows, while a source naming only destroyed objects is the same refusal | `runtime/lifetimes.go` `Context.Destroyed`; `queryexec/objects.go` `executor.eachSessionObject`, `executor.evaluateObjects`; `queryexec/states.go` `executor.evaluateInState`, `executor.objectArgument`, `executor.objectsDeclaredBy`, `executor.objectDestroyedError`; `queryexec/errors.go` `ErrorObjectDestroyed` | `queryexec/robustness_state_event_queries_test.go:TestQueryRobustnessStateEventQueries`; `runtime/robustness_state_event_queries_test.go:TestRuntimeRobustnessStateEventQueries`; `grpc/robustness_docquery_states_events_test.go:TestGRPCRobustnessDocumentQueryStatesEvents` | ✅ Faithful |
-| The trace is a typed relation the printer writes from: `TraceRecorder` keeps a `TraceRecord` per accept, send, transition, state entry, exit and do step, `choice` draw (the alternatives and the one taken, due order and region order included) and unevaluable guard, each with its `TraceOrigin` — the clock's instant, the object and the behavior — beside the free-text lines the other tracers write, and `Entries()` prints every record through `TraceRecord.Line`, so `-trace`/`%trace` output is byte-for-byte what it was and cannot drift from the record; `%trace off` and `Clear` discard it. `Events(source = null, kind = "all", since = null, before = null)` reads the records in the order the run made them as **event rows**: `kind`, `time` (the origin's instant as a quantity in the clock's unit), `object`/`path`/`machine`, `state`/`from`/`to`, `target` (a send's addressee), `event`, `payload` (`name = value` per field), `alternatives`/`taken` (a choice) and `text` (the printed line); `source` keeps the records of the objects behind its rows (every object's when left out), `kind` one or several comma-separated kinds, and `[since, before)` — inclusive start, exclusive end — a bare number in the clock's unit or a duration converted through `Context.ClockMagnitude`. Refused: a session recording no trace (`ErrorNoTrace`), a kind the record has not (`ErrorInvalidArgument`), a bound that is no instant — a non-duration quantity, a clock carrying no unit — or a `before` at or before `since` (`ErrorInvalidInterval`), and `OwnedElements`, `Descendants`, `Ancestors`, `RelatedElements`, `States`, `Verdicts` and `Events` themselves over a state or event row (`ErrorStateRow`, `ErrorEventRow`); `WhereFeature`, `OrderBy`, `Project` and `Column` read the state and event properties before the element's own, and `WhereName`/`WhereType` the state declaration or the object's type | `runtime/trace.go` `TraceKind`, `TraceOrigin`, `TraceRecord`, `TraceRecord.Line`, `TraceRecorder.Records`, `TraceRecorder.Entries`, `RecordAccept`, `RecordSend`, `RecordStateTransition`, `RecordStateEntry`, `RecordStateExit`, `RecordDoStep`, `RecordNote`; `runtime/context.go` `Context.ClockMagnitude`; `queryplan/plan.go` `OperationEvents`; `queryexec/value.go` `ValueEvent`; `queryexec/event.go` `Event`, `EventValue`, `Value.Event`; `queryexec/events.go` `executor.evaluateEvents`, `executor.eventKindArgument`, `executor.instantArgument`, `eventKinds`; `queryexec/errors.go` `ErrorNoTrace`, `ErrorInvalidInterval`, `ErrorEventRow`; `repl/trace.go` (the session's recorder); `cmd/sysml/check.go` `checks.runQueries` (queries run after `-state`/`-action` and `-advance`); `libs/stdlib/OpenSysML Libraries/DocumentQueries.sysml` `Events`, `Event` | `runtime/trace_test.go:TestExecutionTrace` (goldens unchanged); `queryexec/events_test.go:TestExecuteEventsReadsTheTraceInOrder`, `:TestExecuteEventsByKind`, `:TestExecuteEventsIntervalIsClosedOpen`, `:TestExecuteEventRowsThroughRowOperations`, `:TestExecuteEventsRefusals`; `repl/docquery_states_test.go:TestRunQueryEventsOverSession`; `cmd/sysml/run_query_test.go:TestRunQueryOverStatesAndTrace` | ✅ Implemented |
+| The trace is a typed relation the printer writes from: `TraceRecorder` keeps a `TraceRecord` per accept, send, transition, state entry, exit and do step, `choice` draw (the alternatives and the one taken, due order and region order included), unevaluable guard and state-machine termination, each with its `TraceOrigin` — the clock's instant, the object and the behavior — beside the free-text lines the other tracers write, and `Entries()` prints every record through `TraceRecord.Line`, so `-trace`/`%trace` output is byte-for-byte what it was and cannot drift from the record; `%trace off` and `Clear` discard it. `Events(source = null, kind = "all", since = null, before = null)` reads the records in the order the run made them as **event rows**: `kind`, `time` (the origin's instant as a quantity in the clock's unit), `object`/`path`/`machine`, `state`/`from`/`to`, `target` (a send's addressee), `event`, `payload` (`name = value` per field), `alternatives`/`taken` (a choice) and `text` (the printed line); `source` keeps the records of the objects behind its rows (every object's when left out), `kind` one or several comma-separated kinds, and `[since, before)` — inclusive start, exclusive end — a bare number in the clock's unit or a duration converted through `Context.ClockMagnitude`. Refused: a session recording no trace (`ErrorNoTrace`), a kind the record has not (`ErrorInvalidArgument`), a bound that is no instant — a non-duration quantity, a clock carrying no unit — or a `before` at or before `since` (`ErrorInvalidInterval`), and `OwnedElements`, `Descendants`, `Ancestors`, `RelatedElements`, `States`, `Verdicts` and `Events` themselves over a state or event row (`ErrorStateRow`, `ErrorEventRow`); `WhereFeature`, `OrderBy`, `Project` and `Column` read the state and event properties before the element's own, and `WhereName`/`WhereType` the state declaration or the object's type | `runtime/trace.go` `TraceKind`, `TraceOrigin`, `TraceRecord`, `TraceRecord.Line`, `TraceRecorder.Records`, `TraceRecorder.Entries`, `RecordAccept`, `RecordSend`, `RecordStateTransition`, `RecordStateEntry`, `RecordStateExit`, `RecordDoStep`, `RecordNote`; `runtime/context.go` `Context.ClockMagnitude`; `queryplan/plan.go` `OperationEvents`; `queryexec/value.go` `ValueEvent`; `queryexec/event.go` `Event`, `EventValue`, `Value.Event`; `queryexec/events.go` `executor.evaluateEvents`, `executor.eventKindArgument`, `executor.instantArgument`, `eventKinds`; `queryexec/errors.go` `ErrorNoTrace`, `ErrorInvalidInterval`, `ErrorEventRow`; `repl/trace.go` (the session's recorder); `cmd/sysml/check.go` `checks.runQueries` (queries run after `-state`/`-action` and `-advance`); `libs/stdlib/OpenSysML Libraries/DocumentQueries.sysml` `Events`, `Event` | `runtime/trace_test.go:TestExecutionTrace` (goldens unchanged); `queryexec/events_test.go:TestExecuteEventsReadsTheTraceInOrder`, `:TestExecuteEventsByKind`, `:TestExecuteEventsIntervalIsClosedOpen`, `:TestExecuteEventRowsThroughRowOperations`, `:TestExecuteEventsRefusals`; `repl/docquery_states_test.go:TestRunQueryEventsOverSession`; `cmd/sysml/run_query_test.go:TestRunQueryOverStatesAndTrace` | ✅ Implemented |
 | A state or event row renders everywhere a query result does: `%run-query`/`-run-query` print a state row as `<object>.<machine> in <statePath>` and an event row as `t=<instant> <object>.<machine>: <text>`; a document cell is that text in Markdown and PDF, and in HTML a `span.sysml-state` with `data-machine`, `data-state`, `data-region` or a `span.sysml-event` with `data-event-kind`, `data-time`, each with the object's `data-object`; `RunDocumentQuery` answers the `state` and `event` arms of `DocumentValue` (`DocumentState`: `object`, `machine`, `name`, `path`, `region`, `enclosing`, `state`, `text`; `DocumentEvent`: `kind`, `time`, `object`, `machine`, `state`, `from`, `to`, `target`, `event`, `payload`, `alternatives`, `taken`, `text`) over the held population, whose run is traced from the first `Instantiate` into a recorder keeping the most recent `OPENSYSML_GRPC_MAX_HELD_EVENTS` records (default 100,000; an `Events` interval reaching a dropped record is a `trace-truncated` error, `FAILED_PRECONDITION`), and refuses either bound as a parameter with `INVALID_ARGUMENT`; the Go and Python clients decode them as `DocumentState`/`DocumentEvent` on the row and in cells and refuse to bind one, Node, Java and Rust carry the regenerated stubs | `repl/docquery.go` `formatQueryValue`; `docir/evaluate.go`; `docrender/markdown.go`, `docrender/html.go` (the PDF backend hands the HTML-input engines the HTML backend's page); `grpc/docquery.go` `documentState`, `documentEvent`, `boundValue`; `grpc/objects.go` `Service.objects` (the traced population); `api/proto/sysml.proto` `DocumentState`, `DocumentEvent`; `client/opensysml/documents.go` `DocumentState`, `DocumentEvent`, `Row.State`, `Row.Event`; `client/python/opensysml/document.py` `DocumentState`, `DocumentEvent`, `DocumentRow.state`, `DocumentRow.event`; `tools/cmd/conformance/pkgclient.go` `cellToProto`/`cellFromProto` | `docrender/states_test.go:TestMarkdownStateReportGolden` (`testdata/state_report.golden.md`), `:TestHTMLStateReport`; `docpdf/docpdf_test.go:TestRenderStateReportPage`; `docpdf/integration_test.go:TestRenderStateReportWithInstalledEngines` (real engines, skipped when absent); `repl/docquery_states_test.go`; `cmd/sysml/run_query_test.go:TestRunQueryOverStatesAndTrace`; gRPC conformance `document_query_states`, `document_query_in_state`, `document_query_events`; `client/opensysml/states_test.go:TestRunDocumentQueryAnswersStateAndEventRows`, `:TestStateAndEventRowsAreNotBound`; `client/python/tests/test_document.py::test_a_state_row_decodes_to_the_object_and_its_state`, `::test_an_event_row_decodes_to_the_trace_record`, `::test_a_state_or_event_binding_is_refused` | ✅ Implemented |
 | A relationship-derived column traverses from each row's element — an object row's declaration, the assertion of a verdict row, the state or behavior a state or event row is of — with the breadth-first traversal `RelatedElements` uses (every relationship kind and direction it accepts, bounded by `maxDepth`, deduplicated by semantic identity, ordered as reached, charged to the shared visit budget); `list` yields the related elements as one multi-valued cell (an empty cell when none), `count` an integer and `any` a boolean that stops at the first element reached, and the cells are read downstream by name — `WhereFeature` and `OrderBy` over a projected column read its cells (an element compares and orders as its qualified name, under the text operators), a document table groups by it, and `%run-query`, Markdown, HTML and `RunDocumentQuery` carry every value as they carry a multi-valued `documentation` cell. An unknown relationship kind, an invalid direction and an exhausted budget are the typed failures `RelatedElements` raises, naming the column; a row no element declares (an event posted from outside the run) is a typed `undeclared-row` failure naming the column and the row | `queryexec/related_column.go` `relatedColumn`, `relatedColumnOf`, `executor.evaluateRelatedCell`, `columnScoped`; `queryexec/related.go` `executor.validateRelationship`, `executor.traverseRelated`; `queryexec/where_related.go` `executor.hasRelated`; `queryexec/computed.go` `computedColumns`, `executor.evaluateColumnCell`; `queryexec/operations.go` `projectedColumn`, `executor.featureValues`, `compareValue`, `executor.compareOrdered`; `queryexec/errors.go`; `docplan/compiler.go` `columnNames` | `queryexec/related_column_test.go:TestExecuteRelatedColumnsBuildATraceabilityMatrix`, `:TestExecuteRelatedColumnFollowsDepthAndDirection`, `:TestExecuteRelatedColumnReportsItsColumnInErrors`, `:TestExecuteRelatedColumnLeavesTableConstructionUncharged`, `:TestExecuteRelatedColumnAnyStopsAtTheFirstElement`, `:TestExecuteRelatedColumnsFilterAndOrderDownstream`, `:TestExecuteRelatedColumnElementsCompareByQualifiedName`, `:TestExecuteRelatedColumnTraversesFromAnObjectsDeclaration`, `:TestExecuteRelatedColumnRefusesARowNoElementDeclares`; `grpc/related_column_test.go:TestRunDocumentQueryCarriesRelatedColumns`; `docplan/runs_test.go:TestCompileGroupedTableSeesRelatedColumns` | ✅ Implemented |
 
diff --git a/docs/project/view-rendering-forms.md b/docs/project/view-rendering-forms.md
index 3b2c8bc9c3..a086f2d08b 100644
--- a/docs/project/view-rendering-forms.md
+++ b/docs/project/view-rendering-forms.md
@@ -1010,6 +1010,10 @@ origins and bundled library declarations — is not linked.
 | D2 | Nodes, containers, pseudostate glyphs, edges and sequence lifelines and messages carry `link: "url"` after their `class`, which D2 draws as an SVG anchor for every one of them. Pins are not linked: a port's link is its owner's. |
 | Mermaid state diagram | Simple states are linked; composite states are not. |
 | Mermaid sequence diagram | Participants receive `link` statements; messages are not linked. Mermaid CLI 11.16.0 drops participant URL fragments in SVG. |
+| Run timeline, PlantUML | A lane links to its state-machine declaration; a span links only when it represents one state. Parallel spans with several active states are unlinked. |
+| Run timeline, Mermaid gantt | No links: `click`/`href` directives do not produce anchors in Mermaid CLI's SVG output. |
+| Run sequence, Mermaid and PlantUML | Object participants link to the declaration of their instance type. The environment participant and messages are unlinked because trace records have no message source site. |
+| Run text | No links; labels remain the recorded paths and states. |
 
 The writers emit no link syntax when links are disabled or no site is available.
 
@@ -1131,6 +1135,8 @@ refuse D2:
 | --- | --- | --- |
 | CLI | `-render <view> -render-form mermaid\|dot\|plantuml\|d2`; `-render-all <dir>` writes `.mmd`, `.dot`, `.puml` or `.d2`; `-render-palette <name>` fills nodes in each form where applicable | [`docs/reference/cli.md`](../reference/cli.md#rendering-a-view) |
 | REPL | `%render <view> mermaid\|dot\|plantuml\|d2 [palette] [pilot\|cameo]`; `%help` names the options; form, palette and style complete where accepted | [`docs/reference/repl-commands.md`](../reference/repl-commands.md#rendering-a-view) |
+| CLI run output | `-render-run timeline=<path>` or `sequence=<path>` writes text, Mermaid or PlantUML; `-render-link` links PlantUML timeline lanes and single-state spans and sequence participants; DOT is refused | [`docs/reference/cli.md`](../reference/cli.md#rendering-a-run) |
+| REPL run output | `%render-run timeline\|sequence [text\|mermaid\|plantuml\|dot] [link=<template>]` renders the recorded run without changing the session; links follow the CLI run-rendering rules | [`docs/reference/repl-commands.md`](../reference/repl-commands.md#rendering-a-run) |
 | LSP | `"form": "mermaid"`, `"dot"`, `"plantuml"` or `"d2"` and `"palette": "<name>"` on `opensysml/render`; `Rendering.Fills` carries each node's fill and border for clients drawing their own SVG | [`docs/reference/lsp.md`](../reference/lsp.md) |
 | VS Code | `SysML: Export Diagram` picks among the forms the server lists under its `openSysmlRenderForms` capability (the documented six for a server without it, which predates `csv` and `tsv`), sends the pick as `form`, and saves `.dot`, `.puml` or `.d2` (`.mmd`, `.md`, `.csv`, `.tsv`, `.txt` for the others) | [`docs/guide/08-editors.md`](../guide/08-editors.md#exporting-a-diagram) |
 | CLI, REPL, LSP, documents | `-render-style pilot\|cameo` beside `-render-palette`; `%render <view> mermaid [palette] [pilot\|cameo]`; `"style": "cameo"` on `opensysml/render` and the `openSysmlRenderStyles` capability; `docrender.MarkdownOptions.Style`/`HTMLOptions.Style` and `docpdf.Options.Style`. Unsupported style details receive a `not represented: style …` notice; an unknown name is a typed `*view.UnknownDrawingStyleError` | [`docs/reference/cli.md`](../reference/cli.md#rendering-a-view), [`docs/reference/repl-commands.md`](../reference/repl-commands.md#rendering-a-view), [`docs/reference/lsp.md`](../reference/lsp.md) |
@@ -1146,8 +1152,53 @@ render-form field — `RenderDocument` alone, to Markdown — so the wire contra
 and did not change. A view-render RPC added later would take the form as a string, as
 `-render-form` does.
 
+## Run renderings
+
+Run renderings describe a recorded execution, not a model view. A timeline is a new
+`view.KindTimeline`: no existing kind carries occupancy over time, and `KindState` is a graph of
+declared states rather than the states an object held during one run. A run sequence reuses
+`KindSequence` and its existing writers because both are lifelines with ordered messages.
+
+The timeline forms are text, Mermaid and PlantUML. Mermaid uses a compact Gantt chart with a
+shared time axis; Mermaid's `timeline` grammar groups categorical periods and has neither
+durations nor a shared time axis. PlantUML uses `concise` lifelines because parallel state
+configurations are free text rather than a fixed ordered state axis that `robust` requires. DOT
+is refused for both run kinds: it has no time axis, and the existing sequence writer also refuses
+DOT. With source links enabled, PlantUML timeline lanes link to machine declarations and spans
+link only when exactly one state is active; Mermaid gantt remains byte-identical because its
+`click` directives do not create anchors in Mermaid CLI SVGs. Run sequence links belong to object
+participants' type declarations, not messages or the environment participant.
+
+Each rendering is capped at 200 spans or messages for readability and to keep renderer input
+within practical text-size limits. Timelines select spans in stable time order, with lane order
+breaking ties, and retain only a prefix of each lane; a lane's last retained span ends no later than
+its first dropped span's start, preserving any earlier end across an inactive gap. Later state
+changes and messages are reported in a `not represented:` notice.
+Parallel-region state identity includes both the state path and region path, so same-named states in
+sibling regions remain separate leaves; colliding leaf names are disambiguated by the shortest
+trailing part of their paths, falling back to region paths when necessary. A termination record
+closes the lane's occupancy at that instant and adds a `terminate` mark without changing the
+legacy printed trace line.
+
+Sequence renderings pair nonzero message serials exactly. Serial-zero records retain the legacy
+FIFO pairing by event and target, using only serial-zero sends. When a recorder itself dropped
+earlier events, the rendering starts from the first kept state entry and reports that senders or
+acceptors of earlier messages may be missing.
+
+Run renderings are not embedded in documents. Document backends do not run behaviors:
+`-render-document` refuses `-state` and `-advance`, and a document `Diagram` kind selects a model
+rendering. Use `-render-run` or `%render-run` after executing the behavior instead. The LSP has
+no live run and therefore does not offer run rendering.
+
 ## Test contract
 
+- `internal/exec/runtrace`: text, Mermaid and PlantUML goldens for both run kinds; empty, capped,
+  truncated, guard, unmatched and broadcast-message cases; choice marks, self-transitions and
+  DOT refusal. `internal/ir/view/run_timeline_test.go` checks that timeline form support does not
+  make it a model view kind or a pseudo-view.
+- `cmd/sysml/render_run_test.go` and `internal/frontend/repl/run_render_test.go`: CLI artifact
+  output and incompatible modes, source links and invalid templates, and REPL output,
+  missing-trace handling, form refusal, link parsing and completion.
 - `internal/ir/view/general_test.go`: which filter shapes select which graph and which keep the
   tree (`@`/`@@`, `or`, the library's own lists, precedence, inherited filters, a filtered
   `expose`, relationships alone, `and`, `not`, user metadata, a mixture); an unresolved
diff --git a/docs/reference/cli.md b/docs/reference/cli.md
index 223890bad6..90c287b0d1 100644
--- a/docs/reference/cli.md
+++ b/docs/reference/cli.md
@@ -236,6 +236,7 @@ the same member-path parser as `Project` and `OrderBy`.
 | `--enable-lint <code>` | | Report the named opt-in [lint](diagnostics.md), off by default, in the diagnostics: `rounded-real-literal`; comma-separated or repeated. `--disable-lint` wins over it, and an unknown code is a usage error |
 | `--no-record-cache` | | Parse every file loaded and hold it loaded, reading no interface record from the record cache and writing none: what a run does where `OPENSYSML_RECORD_CACHE=0`. By default a file whose bytes, library, conformance mode and record format match a record in the cache is held as that record — its scopes and symbols without its tree, and the diagnostics its analysis found — and a file analyzed by `-validate`, `-satisfy` or another load writes its record for the next run; see [Interface records](../internals/interface-records.md) |
 | `--trace` | | Report each execution step: expression evaluation, calc invocation, action tokens, state transitions, each `choice` the executor made among alternatives the library leaves unordered, naming the alternatives and the one taken, and each `unevaluable guard` it read only to report one and could not evaluate ([Choice points](../guide/06-behavior.md)). Under `-schedule explore` the table is printed first, then the trace of one witness run per distinct outcome, each under a `trace of outcome <n>'s witness (run <r>):` heading ([Exploring every linearization](#exploring-every-linearization)) |
+| `--render-run <kind>=<path>` | | Repeatable; write a recorded run's `timeline` or `sequence` as text, Mermaid or PlantUML. The extension `.txt`, `.mmd`/`.mermaid` or `.puml`/`.plantuml` selects a form; use `-render-form` for another extension. `-render-link` links PlantUML timeline lanes and single-state spans and sequence object participants; Mermaid gantt and messages remain unlinked. DOT is refused. Requires `-state`, `-action` or `-advance` and cannot be combined with model/document rendering or schedule exploration |
 | `--convert <format>` | | Convert the model instead of running it: `sysml`, `kerml`, `ttl`, `turtle`, `rdf`, `api-json` or `json`. `ttl` writes the RDF graph in Turtle, `api-json` the same graph as the API's JSON element objects; both are [experimental](rdf-mapping.md#status-experimental) and every run that converts either says so on stderr (see [the RDF mapping](rdf-mapping.md)). The model argument may be a Flexo MMS project branch URL — `http(s)://host[:port][/base]/projects/{project}/branches/{branch}` or `flexo://{project}/{branch}` — both naming the endpoint `FLEXO_SYSMLV2_URL` configures — which is read as its head commit's RDF graph; see [Reading and pushing a repository branch](#reading-and-pushing-a-repository-branch) |
 | `--migrate <format>` | | Migrate a SysML v1 model — UML XMI, an Eclipse UML2 `.uml` file or a MagicDraw/Cameo `.mdzip` archive — to SysML v2 instead of running it, writing `sysml`, `kerml`, `ttl`, `turtle` or `rdf`. A migration is ledgered, not lossless: every v1 element is **mapped**, **approximated**, **unmapped** or **skipped**, and the run says so in a one-line summary, or element by element with `-migration-report`. The input is named by its `.xmi`, `.uml` or `.mdzip` extension or by `--from`; v2 input is refused with a pointer at `--convert`, and `--convert` on a v1 model is refused with a pointer here, since a migration is not a conversion (experimental; see [SysML v1 migration](sysml-v1-migration.md)) |
 | `--from <format>` | | Input format for `--convert` or `--migrate`: the `--convert` formats, `xmi`/`uml`/`mdzip` for a SysML v1 model to `--migrate`, or `fmu` for a Functional Mock-up Unit to import as a `calc def` evaluated through the `tool:fmi` engine (experimental; default: from the input's extension; `.xmi`, `.uml`, `.mdzip` and `.fmu` are recognized) — see [SysML v1 migration](sysml-v1-migration.md) and [FMI models (FMUs)](fmi.md) |
@@ -246,7 +247,7 @@ the same member-path parser as `Project` and `OrderBy`.
 | `--render-all <dir>` | | Render every declared view into the directory, one artifact per view |
 | `--render-form <form>` | | Form `--render` or `--render-all` writes: `text`, `mermaid`, `markdown`, `dot`, `plantuml`, `d2`, `csv` or `tsv` (default: destination-dependent for `--render`, each kind's machine-readable form for `--render-all`). D2 writes `tree`, `interconnection`, `state`, `action`, `sequence`, `requirement`, `definition` and `package` renderings; case and mixed views refuse it with a typed error |
 | `--render-palette <name>` | | Palette the `dot`, `mermaid`, `plantuml` or `d2` form of `--render` or `--render-all` fills nodes with, by keyword family: `okabe-ito`, `tol-bright`, `tol-muted`, `tol-light`, `brewer-set2`, `brewer-dark2`, `viridis` or `cividis`; black and white when absent. Mermaid sequence diagrams cannot fill individual participants; text and Markdown ignore palettes. An unknown name is refused with the names there are (see [Rendering a view](#rendering-a-view)) |
-| `--render-link <template>` | | Link nodes and edges back to their source in rendered diagrams. Templates accept `{file}`, `{line}`, `{col}`, `{qname}` and `{id}`; `{file}` is the path as loaded, so pass absolute paths for `vscode://` or `file://` links. Applies to `--render`, `--render-all` and document diagrams; without one of those render targets it is refused |
+| `--render-link <template>` | | Link nodes and edges back to their source in rendered diagrams. Templates accept `{file}`, `{line}`, `{col}`, `{qname}` and `{id}`; `{file}` is the path as loaded, so pass absolute paths for `vscode://` or `file://` links. Applies to `--render`, `--render-all`, document diagrams and `--render-run`; without one of those render targets it is refused |
 | `--render-style <style>` | | Drawing style the `dot` or `mermaid` form of `--render`, `--render-all`, `--render-document` and `--render-documents` draws in: `pilot` (the default), the Pilot visualizer's Standard B&W, or `cameo`, the look of Cameo Systems Modeler — a diagram frame with a header tab, 11 pt Arial, gradient fills in Cameo's colours, a state's `do / Activity` compartment and the UML pseudo-state symbols. Mermaid draws supported Cameo details but flattens gradients and omits the frame and header tab; unsupported details are noted. PlantUML and D2 note the style as not represented; text and Markdown ignore it. An unknown name is refused with the two there are; without something to render it is refused likewise (see [Rendering a view](#rendering-a-view)) |
 | `--render-ports <display>` | | How much of a part's ports an interconnection or mixed rendering of `--render` or `--render-all` draws: `minimal` (the default), the ports its interconnection edges or mixed connectors end at, each a small square on the part's border named beside it, or `full`, every port a part has, labelled `name : Type`. An unknown name is refused with the two there are |
 | `--render-overlay <overlay>` | | What `--render` or `--render-all` draws over a requirement rendering: `verdicts` runs the verification cases verifying each requirement and labels and colours it by their verdicts. Refused on another kind, by name when unknown, and without something to render (see [Rendering a view](#rendering-a-view)) |
@@ -510,6 +511,31 @@ sysml -e "x" -e "y" file.sysml
 sysml -e "result" file1.sysml file2.sysml
 ```
 
+## Rendering a run
+
+`-render-run <kind>=<path>` writes the trace of a behavior run as a timeline or message sequence.
+Run it with `-state`, `-action` or `-advance`; the trace is recorded silently unless `-trace`
+also asks to print it. Repeat the flag for both renderings:
+
+```bash
+sysml examples/run-timeline/run-timeline.sysml \
+  -instantiate RunTimeline::mission \
+  -state "RunTimeline::Controller::modes RunTimeline::mission.controller" \
+  -state "RunTimeline::Instrument::modes RunTimeline::mission.instrument" \
+  -advance 6 \
+  -render-run timeline=timeline.mmd \
+  -render-run sequence=sequence.puml
+```
+
+The output extension selects text (`.txt`), Mermaid (`.mmd`, `.mermaid`) or PlantUML
+(`.puml`, `.plantuml`); `-render-form` can select a form for another extension. DOT is not
+available for run output. A run rendering cannot be combined with a model or document rendering,
+query, schedule exploration or multi-run analysis. Run output cannot be written to standard output
+with `-json`; name a file for each rendering instead. `-render-run` cannot be combined with
+`-compare-results`. `-render-link` links sequence object participants to their type declarations,
+and PlantUML timeline lanes and single-state spans to their declarations. Mermaid gantt and run
+messages are not linked.
+
 ## Rendering a view
 
 `-render <view>` renders one view of the model and exits. Every file named on the command line is
@@ -802,7 +828,8 @@ cannot fill individual participants. Text and Markdown ignore palettes. A name t
 status 2 and the names there are; `-render-palette` without `-render` or `-render-all` is refused
 likewise.
 
-`-render-link <template>` gives linkable diagram nodes and edges URLs to their source. A template
+`-render-link <template>` gives linkable diagram nodes and edges URLs to their source, and also
+links run sequence object participants and PlantUML timeline lanes and single-state spans. A template
 may contain `{file}`, `{line}`, `{col}`, `{qname}` and `{id}`. Substituted values are UTF-8
 percent-encoded; URL delimiters written literally in the template remain literal. `{file}` is the
 path as loaded, not a path resolved against the rendering's output directory: use absolute input
diff --git a/docs/reference/repl-commands.md b/docs/reference/repl-commands.md
index 7aa0dbb856..8d8e64a421 100644
--- a/docs/reference/repl-commands.md
+++ b/docs/reference/repl-commands.md
@@ -70,6 +70,7 @@ into the parts it holds (`car.fl.hub`, `#3.fl`, `car.wheels[2]`).
 | `%builtins` | List the library functions the runtime implements directly (`sqrt`, `abs`, `max`, `floor`, `x->isEmpty()`, `x->sum()` …), each with the package an `import` must name for its bare name to resolve; the qualified name (`RealFunctions::sqrt(2.0)`) resolves anywhere |
 | `%view <name>` | Show what a view exposes: its own `expose` relationships plus the protected ones of the views it specializes, the views nested in it (each with its own exposed set), and its conformance to every viewpoint it satisfies. Conformance is a verdict of `conforms`, `violated` or `unevaluable` per viewpoint and per framed concern, with the reason, the exposed element a concern's condition failed for, and `(from <view>)` where the `satisfy` is inherited. Asking about an element that is not a view says so |
 | `%render <name> [form [palette] [style] [ports] [overlay] [link=<template>]]` | Render a view's exposed set in the kind its `render` member states: a containment tree with nested views as subtrees, an interconnection diagram of the exposed parts and their connections, a state machine's states and transitions, an action's nodes and successions, case-family nodes and their actors, subjects, objectives and relationships, a mixed canvas combining structural, behavioral and case content, or a table of exposed elements and what they declare. A view without a `render` member renders as a tree. Output is indented text by default or the machine-readable form of the kind: Mermaid with `mermaid`, Markdown with `markdown`, CSV or TSV with `csv` or `tsv`; notices follow under `not represented:`. `dot` writes Graphviz DOT, `plantuml` writes PlantUML and `d2` writes D2, the last two including sequences, D2 refusing case and mixed renderings. Mermaid, DOT, PlantUML and D2 each accept the documented palettes. `mermaid [palette] pilot|cameo` and `dot [palette] pilot|cameo` select the Pilot or Cameo style (for example, `mermaid [palette] cameo` or `dot [palette] cameo`); PlantUML and D2 report the style as not represented. A GeneralView whose filters select a requirement, definition and usage, package, or case view renders as that graph ([which filters](../project/view-rendering-forms.md#generalview-graphs)), and `verdicts` after the form runs the verification cases verifying each requirement a requirement graph draws and labels and colours it by their verdicts, refused on another kind. `link=<template>` links diagram elements to their source and accepts `{file}`, `{line}`, `{col}`, `{qname}` and `{id}`; `{file}` is the path as loaded. A form the kind cannot use is refused with its supported form. The command is read-only and leaves `%action`/`%state` debugging sessions running. Empty views and unsupported kinds or elements are reported rather than substituted or dropped |
+| `%render-run <timeline\|sequence> [text\|mermaid\|plantuml\|dot] [link=<template>]` | Render the current session's recorded run as state occupancy over time or as ordered messages; text is the default. Requires `%trace on` before the run, accepts Mermaid or PlantUML, and refuses DOT. `link=<template>` links sequence object participants and PlantUML timeline lanes and single-state spans; Mermaid gantt and messages remain unlinked. It leaves the session and its trace unchanged |
 | **Instantiation & Inspection** | |
 | `%instantiate <name>` | Create an object of a part definition and start the behaviors its type exhibits or performs. Each object runs its own machine, initialized after its feature values are built and run until it is quiescent. A second `%instantiate` of the same name creates a new object, and the name then refers to that one. A later submission keeps the object's identity but restarts its behaviors from their initial states, and says so |
 | `%features <object> [all\|depth <n>] [json]` | Show what an object holds for each feature of its type. The object is named, addressed by id, or reached by a path: `%features car`, `%features #3`, `%features car.fl.hub`, `%features car.wheels[2]`. A feature with no value reads `<unset>`. States and actions hold no value, so they are listed after the values under a `Behaviors:` heading with what the object is doing with each: the current active state of a machine it exhibits (the state `%current` reports), the execution state of an action it performs, `not running` for a state or action it neither exhibits nor performs, or, for a named transition, the step it declares (`toggle: transition, modes.closed → modes.opened`). A behavior a redefinition renamed (`exhibit state fancyModes :>> modes`) is one execution under two names, and both rows report it. The values a running behavior owns — the attributes of the machine's own occurrence, an action's parameters and outputs — are listed under its row (`modes: exhibited state machine, current state running` followed by `count = 1`), apart from the performer's own values, and are bounded like any nested object. Reading a feature value builds the objects it holds, so the listing is bounded by default — 200 lines, nesting 8 deep — and a listing cut short says which form shows the rest. `all` lifts both bounds and reads the whole tree out; `depth <n>` bounds nesting at `n` levels and lifts the size bound, naming what it did not expand (`machine : Machine (not expanded: depth 1)`). `json` writes the object and everything reachable from it as one document in the shape the API's `Instantiate` returns (`instance`, `instances`, `diagnostics`), bounded by default at 1000 objects, with a graph cut short reported as a `warning` diagnostic. `all`/`depth` and `json` combine (`%features ctx all json`); `all` and `depth` together, a missing or negative depth, and an unknown word are errors naming the usage |
@@ -117,6 +118,23 @@ into the parts it holds (`car.fl.hub`, `#3.fl`, `car.wheels[2]`).
 | `Ctrl-C` | Discard the line being typed, and any continuation buffered before it; at an empty `sysml>` prompt, exit REPL |
 | `Ctrl-D` | Exit REPL |
 
+### Rendering a run
+
+Start a behavior with `%state` or `%action`, or advance an active run, then use `%render-run`:
+
+```text
+%render-run timeline
+%render-run sequence mermaid
+%render-run timeline plantuml link=https://example.test/src/{file}#L{line}
+```
+
+The command reads the current trace and clock without changing either. Enable `%trace on` before
+the run to record it; accepted forms are text, Mermaid and PlantUML. `link=<template>` follows the
+CLI's `-render-link` placeholders. It links sequence object participants to their type declarations,
+and PlantUML timeline lanes and single-state spans to their declarations. Mermaid gantt timelines
+and messages are not linked.
+Tab completes the run kind, a form or the `link=` option; it does not complete the URL template.
+
 The five solving commands (`%check`, `%explain`, `%solve`, `%configure`, `%optimize`) follow the
 design of the `ConstraintSolverService` in OpenMBEE's [HMF](https://github.com/hivecore-dev/hmf)
 (Apache 2.0); see [Acknowledgements](../../README.md#acknowledgements). `%check` asks a solver
diff --git a/examples/README.md b/examples/README.md
index 958ec94f29..7ca1c1c2ec 100644
--- a/examples/README.md
+++ b/examples/README.md
@@ -27,6 +27,7 @@ Each of these is a model and a walkthrough of the commands that exercise it.
 | Model | Walkthrough | What it demonstrates |
 | --- | --- | --- |
 | [runtime-showcase/](runtime-showcase/) | [runtime-showcase/README.md](runtime-showcase/README.md) | what only running a model answers: a recursive mass rollup over a materialized launch vehicle, a delta-v budget with units carried through to an analysis verdict, a reliability product asserted of two missions, a mission action branching on its budget and a clocked state machine — each with one well-formed construct that fails at runtime with the reason named — a spacecraft downlink whose ground station and spacecraft run on one clock through an interface, with orthogonal regions, timed do actions and a schedule choice, and the same failures found in the published Apollo 11 model |
+| [run-timeline/](run-timeline/) | [run-timeline/README.md](run-timeline/README.md) | render a recorded run of two object state machines as state timelines and a message sequence, including timed transitions and a parallel-region scheduling choice |
 | [disposal-robot-demo/robot.sysml](disposal-robot-demo/robot.sysml) | [disposal-robot-demo/README.md](disposal-robot-demo/README.md) | one bomb-disposal robot, end to end: structure, calculations, an action with a fork/join, a branch and a nested flow, a hierarchical state machine an object exhibits, assignment through a feature chain, the solver commands, the view renderings, and [the same questions from Python](disposal-robot-demo/robot_demo.py) |
 | [disposal-team-demo/team.sysml](disposal-team-demo/team.sysml) | [disposal-team-demo/README.md](disposal-team-demo/README.md) | the team around that robot, written for what the robot demo does not reach: quantities with units, `select` and `reduce` over a fleet, a message crossing the connector two parts are joined by, an occurrence with a snapshot and a timeslice, and a requirement, use case, verification case and analysis case over the same subject |
 | [relay-probe-demo/mission.sysml](relay-probe-demo/mission.sysml) | [relay-probe-demo/README.md](relay-probe-demo/README.md) | one individual probe across its mission phases: event occurrences ordered in time, snapshots and a timeslice of one individual, occurrences with multiplicity, a calculation reading across two snapshots, a requirement whose subject is a snapshot, and a beacon inside a timeslice sending telemetry through its probe's own port |
diff --git a/examples/run-timeline/README.md b/examples/run-timeline/README.md
new file mode 100644
index 0000000000..622a527b86
--- /dev/null
+++ b/examples/run-timeline/README.md
@@ -0,0 +1,22 @@
+# Run timeline and message sequence
+
+This example runs two sibling object state machines on one clock. The controller's
+parallel communication and power regions make a deterministic scheduling choice.
+It sends payload-bearing `Ping` messages to the instrument, which answers with
+`Ack` messages over the connected ports. Both renderings are built
+from the recorded run, not from model views.
+
+From the repository root:
+
+```bash
+sysml examples/run-timeline/run-timeline.sysml \
+  -instantiate RunTimeline::mission \
+  -state "RunTimeline::Controller::modes RunTimeline::mission.controller" \
+  -state "RunTimeline::Instrument::modes RunTimeline::mission.instrument" \
+  -advance 6 \
+  -render-run timeline=timeline.mmd \
+  -render-run sequence=sequence.puml
+```
+
+Use `.txt`, `.mmd`/`.mermaid`, or `.puml`/`.plantuml` for text, Mermaid, or
+PlantUML output. Run renderings do not accept DOT.
diff --git a/examples/run-timeline/run-timeline.sysml b/examples/run-timeline/run-timeline.sysml
new file mode 100644
index 0000000000..d5acc2aa31
--- /dev/null
+++ b/examples/run-timeline/run-timeline.sysml
@@ -0,0 +1,71 @@
+package RunTimeline {
+    private import ScalarValues::*;
+    private import SI::*;
+
+    item def Ping {
+        attribute seq : Integer;
+    }
+
+    item def Ack {
+        attribute seq : Integer;
+    }
+
+    port def ControllerLink {
+        out item ping : Ping;
+        in item ack : Ack;
+    }
+
+    port def InstrumentLink {
+        in item ping : Ping;
+        out item ack : Ack;
+    }
+
+    part def Controller {
+        port link : ControllerLink;
+
+        exhibit state modes parallel {
+            state communication {
+                entry; then waiting;
+                state waiting;
+                state sending {
+                    entry send new Ping(seq = 1) via link;
+                }
+                state acknowledged;
+
+                transition first waiting accept after 1 [s] then sending;
+                transition first sending accept Ack via link then acknowledged;
+                transition first acknowledged accept after 1 [s] then waiting;
+            }
+
+            state power {
+                entry; then charged;
+                state charged;
+            }
+        }
+    }
+
+    part def Instrument {
+        port link : InstrumentLink;
+
+        exhibit state modes {
+            entry; then waiting;
+            state waiting;
+            state acknowledged;
+
+            transition first waiting
+                accept ping : Ping via link
+                do send new Ack(seq = ping.seq) via link
+                then acknowledged;
+            transition first acknowledged accept after 1.5 [s] then waiting;
+        }
+    }
+
+    part def Mission {
+        part controller : Controller;
+        part instrument : Instrument;
+
+        connect controller.link to instrument.link;
+    }
+
+    part mission : Mission;
+}
diff --git a/internal/doc/queryexec/event.go b/internal/doc/queryexec/event.go
index f2bbcd4df1..00e787ba57 100644
--- a/internal/doc/queryexec/event.go
+++ b/internal/doc/queryexec/event.go
@@ -25,7 +25,7 @@ type Event struct {
 }
 
 // Kind names the record's kind as its `kind` property does: `accept`, `send`,
-// `transition`, `entry`, `exit`, `do`, `choice`, `guard`.
+// `transition`, `entry`, `exit`, `do`, `choice`, `guard`, `terminate`.
 func (ev Event) Kind() string { return ev.record.Kind.String() }
 
 // At is the clock instant the record was made at, in clock units.
@@ -50,7 +50,7 @@ func (ev Event) Machine() string { return ev.machine }
 
 // Payload is an accept's or send's payload, `name = value` per parameter in
 // name order, in the runtime's notation.
-func (ev Event) Payload() []string { return payloadTexts(ev.record) }
+func (ev Event) Payload() []string { return ev.record.PayloadTexts() }
 
 // Alternatives are a choice's alternatives as offered, nil for any other record.
 func (ev Event) Alternatives() []string {
diff --git a/internal/doc/queryexec/events.go b/internal/doc/queryexec/events.go
index cbb2e28648..47eb52da21 100644
--- a/internal/doc/queryexec/events.go
+++ b/internal/doc/queryexec/events.go
@@ -3,7 +3,6 @@ package queryexec
 import (
 	"fmt"
 	"math"
-	"sort"
 	"strconv"
 	"strings"
 
@@ -41,6 +40,7 @@ var eventKinds = map[string]runtime.TraceKind{
 	"do":         runtime.TraceDo,
 	"choice":     runtime.TraceChoice,
 	"guard":      runtime.TraceGuard,
+	"terminate":  runtime.TraceTerminate,
 }
 
 // EventsFromTrace converts documented trace records into rows in run order.
@@ -74,7 +74,7 @@ func eventFromRecord(ctx *runtime.Context, labels sessionLabelMap, record runtim
 		time:    instantValue(ctx, at),
 		object:  object,
 		label:   labels.label(object),
-		machine: eventMachine(record),
+		machine: record.Machine(),
 		target:  labels.label(record.Target),
 		index:   index,
 	}
@@ -325,7 +325,7 @@ func (e *executor) eventPropertyValues(row Value, property string) ([]Value, boo
 		return text(eventName(record)), true, nil
 	case propertyPayload:
 		out := make([]Value, 0, len(record.Payload))
-		for _, cell := range payloadTexts(record) {
+		for _, cell := range record.PayloadTexts() {
 			out = append(out, valueAt(StringValue(cell), origin))
 		}
 		return out, true, nil
@@ -347,26 +347,6 @@ func (e *executor) eventPropertyValues(row Value, property string) ([]Value, boo
 	return e.propertyValues(ElementValue(record.Origin.Behavior), property)
 }
 
-// eventMachine names the behavior a record came from as its object exhibits it,
-// or as declared when it is anonymous or the record has no object.
-func eventMachine(record runtime.TraceRecord) string {
-	behavior := record.Origin.Behavior
-	if behavior == nil {
-		return ""
-	}
-	if record.Origin.Object != nil {
-		for _, b := range record.Origin.Object.Behaviors() {
-			if b.Symbol == behavior || (b.State != nil && b.State.StateMachineSymbol() == behavior) {
-				if b.Name != "" {
-					return b.Name
-				}
-				break
-			}
-		}
-	}
-	return behavior.Name
-}
-
 // eventName is what a record is about: the event accepted or sent, the state
 // entered, exited or run, a transition's target, the choice kind or the guarded alternative.
 func eventName(record runtime.TraceRecord) string {
@@ -388,18 +368,3 @@ func eventName(record runtime.TraceRecord) string {
 	}
 	return ""
 }
-
-// payloadTexts renders an accept's or send's payload, one `name = value`
-// entry per parameter in name order, in the runtime's notation.
-func payloadTexts(record runtime.TraceRecord) []string {
-	names := make([]string, 0, len(record.Payload))
-	for name := range record.Payload {
-		names = append(names, name)
-	}
-	sort.Strings(names)
-	out := make([]string, 0, len(names))
-	for _, name := range names {
-		out = append(out, name+" = "+runtime.FormatValue(record.Payload[name]))
-	}
-	return out
-}
diff --git a/internal/doc/queryexec/events_test.go b/internal/doc/queryexec/events_test.go
index c466ab44a3..fe970ed8e6 100644
--- a/internal/doc/queryexec/events_test.go
+++ b/internal/doc/queryexec/events_test.go
@@ -324,6 +324,12 @@ func TestExecuteEventsByKind(t *testing.T) {
 	}
 }
 
+func TestEventKindsIncludeTerminate(t *testing.T) {
+	if got, ok := eventKinds["terminate"]; !ok || got != runtime.TraceTerminate {
+		t.Fatalf("terminate event kind = %q, %t; want %q", got, ok, runtime.TraceTerminate)
+	}
+}
+
 // The interval is [since, before): kept at since, dropped at before; bounds are
 // durations in any unit of time or bare clock seconds, either left open.
 func TestExecuteEventsIntervalIsClosedOpen(t *testing.T) {
diff --git a/internal/doc/queryexec/states.go b/internal/doc/queryexec/states.go
index 63a66ef0d7..7c690ee652 100644
--- a/internal/doc/queryexec/states.go
+++ b/internal/doc/queryexec/states.go
@@ -221,7 +221,7 @@ func activeState(inst *runtime.Instance, label string, machine *runtime.ObjectBe
 		symbol:    stateSymbol(exec.Graph(), leaf),
 		name:      leaf.Name,
 		path:      exec.StatePath(leaf),
-		region:    regionName(exec.Graph(), leaf),
+		region:    regionName(exec, leaf),
 		enclosing: names,
 		behavior:  machine.Symbol,
 	}
@@ -229,14 +229,9 @@ func activeState(inst *runtime.Instance, label string, machine *runtime.ObjectBe
 
 // regionName names the innermost orthogonal region state stands in, its own or an
 // ancestor's, "" for a state outside every region.
-func regionName(graph *lower.StateGraph, state *ast.StateNode) string {
-	for current := state; current != nil; current = graph.ParentState[current] {
-		if region := graph.RegionOf[current]; region != nil {
-			return region.Name
-		}
-		if region := graph.HiddenRegionOf[current]; region != nil {
-			return region.Name
-		}
+func regionName(exec *runtime.StateExecutor, state *ast.StateNode) string {
+	if region := exec.RegionOf(state); region != nil {
+		return region.Name
 	}
 	return ""
 }
diff --git a/internal/exec/runtime/action_executor.go b/internal/exec/runtime/action_executor.go
index 9f7b5f9a3d..cfe6bdc23e 100644
--- a/internal/exec/runtime/action_executor.go
+++ b/internal/exec/runtime/action_executor.go
@@ -2662,7 +2662,7 @@ func (e *ActionExecutor) awaitSignal(token *Token, accept lower.Accept, usage *a
 	token.Wait = nil
 	if tr := e.trace(); tr != nil {
 		tr.RecordAccept(TraceOrigin{At: e.ctx.clock.now, Object: e.self, Behavior: e.action},
-			acceptedEventName(msg), msg.Payload)
+			msg.Serial, acceptedEventName(msg), msg.Payload)
 	}
 	if accept.ParamName == "" {
 		return nil, true, nil
diff --git a/internal/exec/runtime/context.go b/internal/exec/runtime/context.go
index 51dd6386f3..44a2ff4ecf 100644
--- a/internal/exec/runtime/context.go
+++ b/internal/exec/runtime/context.go
@@ -276,7 +276,8 @@ type Context struct {
 
 	// messages are the signals in flight, oldest first. The bus is context-wide,
 	// so a message one behavior sends can be accepted in another.
-	messages []Message
+	messages      []Message
+	messageSerial uint64
 	// bus counts what changed the messages in flight; writes counts the feature
 	// values written or restored. A machine's poll of the bus is memoized on them.
 	bus    busSerials
diff --git a/internal/exec/runtime/held_image.go b/internal/exec/runtime/held_image.go
index c257504fb9..02fc144b87 100644
--- a/internal/exec/runtime/held_image.go
+++ b/internal/exec/runtime/held_image.go
@@ -585,7 +585,10 @@ func (img *HeldImage) Materialize(dst *Context) error {
 	if err := img.clockFree(dst); err != nil {
 		return err
 	}
-	m := &materializing{dst: dst, img: img, made: make(map[int64]*Instance, len(img.objects))}
+	m := &materializing{
+		dst: dst, img: img, made: make(map[int64]*Instance, len(img.objects)),
+		nextMessageSerial: dst.messageSerial, messageSerials: make(map[uint64]uint64),
+	}
 	mark := dst.materializeMark()
 	if err := m.run(); err != nil {
 		mark.rollBack(dst)
@@ -691,11 +694,13 @@ func (mark materializeMark) rollBack(ctx *Context) {
 
 // materializing builds one context's objects for an image.
 type materializing struct {
-	dst      *Context
-	img      *HeldImage
-	made     map[int64]*Instance
-	runs     []*runState
-	recorded []sharedKey
+	dst               *Context
+	img               *HeldImage
+	made              map[int64]*Instance
+	runs              []*runState
+	recorded          []sharedKey
+	nextMessageSerial uint64
+	messageSerials    map[uint64]uint64
 }
 
 // bring answers the object made here for an imaged identity.
@@ -793,6 +798,7 @@ func (m *materializing) run() error {
 	}
 	// Nothing below fails: what names the objects made is installed once they all stand.
 	dst.messages = append(dst.messages, messages...)
+	dst.messageSerial = m.nextMessageSerial
 	dst.bus.posts += uint64(len(messages))
 	dst.workChanged()
 	for sym, ids := range img.occurrences {
@@ -959,6 +965,15 @@ func (m *materializing) runState(run imagedRun) *runState {
 // message is a message as dst carries it.
 func (m *materializing) message(msg Message) (Message, error) {
 	out := msg
+	if msg.Serial != 0 {
+		serial, ok := m.messageSerials[msg.Serial]
+		if !ok {
+			m.nextMessageSerial++
+			serial = m.nextMessageSerial
+			m.messageSerials[msg.Serial] = serial
+		}
+		out.Serial = serial
+	}
 	var err error
 	if out.Payload, err = m.values(msg.Payload); err != nil {
 		return Message{}, err
diff --git a/internal/exec/runtime/held_image_test.go b/internal/exec/runtime/held_image_test.go
index b63e4f1d50..3185ab3005 100644
--- a/internal/exec/runtime/held_image_test.go
+++ b/internal/exec/runtime/held_image_test.go
@@ -79,6 +79,45 @@ func imageInto(t *testing.T, ctx *Context, objects ...*Instance) *Context {
 	return dst
 }
 
+func TestHeldImageImportRemapsMessageSerialsBeforeAccept(t *testing.T) {
+	_, ctx, bulb := lampBulb(t)
+	ctx.PostMessage(Message{Object: bulb.ID, SignalType: "Ping"})
+	ctx.messages = append(ctx.messages, Message{Object: bulb.ID, SignalType: "Ping"})
+	img, err := ctx.Image(bulb)
+	if err != nil {
+		t.Fatalf("Image: %v", err)
+	}
+
+	trace := NewTraceRecorder()
+	dst := NewContext(ctx.Model(), 10000)
+	dst.SetTrace(trace)
+	dst.PostMessage(Message{SignalType: "Ping"})
+	if records := trace.Records(); len(records) != 1 || records[0].Kind != TraceSend || records[0].Message != 1 {
+		t.Fatalf("destination trace = %+v, want a send of serial 1", records)
+	}
+	if err := img.Materialize(dst); err != nil {
+		t.Fatalf("Materialize: %v", err)
+	}
+
+	messages := dst.PendingMessages()
+	if len(messages) != 3 || messages[0].Serial != 1 || messages[1].Serial != 2 || messages[2].Serial != 0 {
+		t.Fatalf("messages = %+v, want destination serial 1, imported serial 2, and imported serial 0", messages)
+	}
+	accepted, ok := dst.TakeMessage(func(msg Message) bool { return msg.Serial == 2 })
+	if !ok {
+		t.Fatal("could not take the imported message")
+	}
+	trace.RecordAccept(TraceOrigin{}, accepted.Serial, accepted.SignalType, nil)
+	records := trace.Records()
+	if len(records) != 2 || records[0].Message != 1 || records[1].Kind != TraceAccept || records[1].Message != 2 {
+		t.Fatalf("trace records = %+v, want send serial 1 and accept serial 2", records)
+	}
+	dst.PostMessage(Message{SignalType: "Pong"})
+	if got := dst.PendingMessages()[len(dst.PendingMessages())-1].Serial; got != 3 {
+		t.Errorf("next message serial = %d, want 3", got)
+	}
+}
+
 // A held entry survives a portable image: the copy remains at the same entry
 // boundary and finishes with the same result as the source.
 func TestHeldImageCarriesAnEntryBoundary(t *testing.T) {
diff --git a/internal/exec/runtime/occurrence_terminate.go b/internal/exec/runtime/occurrence_terminate.go
index 0eed943acc..ccfcfb9f23 100644
--- a/internal/exec/runtime/occurrence_terminate.go
+++ b/internal/exec/runtime/occurrence_terminate.go
@@ -178,7 +178,7 @@ func (e *StateExecutor) endTerminated() {
 	}
 	abandoned := e.abandonMachine()
 	if e.trace() != nil {
-		e.trace().RecordStateEndedWithOccurrence(symbolText(e.stateMachine), abandoned)
+		e.trace().RecordStateEndedWithOccurrence(e.traceOrigin(), symbolText(e.stateMachine), abandoned)
 	}
 	e.state = StateTerminated
 	e.ctx.endPerformanceLife(e.occurrence)
diff --git a/internal/exec/runtime/signal.go b/internal/exec/runtime/signal.go
index 8d7d718d62..09a447e1ea 100644
--- a/internal/exec/runtime/signal.go
+++ b/internal/exec/runtime/signal.go
@@ -34,6 +34,8 @@ import (
 // none. A binding connector makes a boundary port and an inner port one object,
 // so an accept on either port takes a message that reached the other.
 type Message struct {
+	// Serial is the bus's number for the message, unique within a context's run; 0 for none.
+	Serial     uint64
 	SignalType string
 	// Signal is the definition SignalType resolved to when the send was built,
 	// nil where the message's type is known only as a name. An accept matches it
@@ -112,6 +114,8 @@ func (ctx *Context) postFrom(msg Message, from *Instance, behavior *symbols.Symb
 	if msg.Delivery == DeliverAnyone {
 		msg.Delivery = deliveryOf(msg)
 	}
+	ctx.messageSerial++
+	msg.Serial = ctx.messageSerial
 	ctx.messages = append(ctx.messages, msg)
 	ctx.bus.posts++
 	ctx.workChanged()
diff --git a/internal/exec/runtime/signal_test.go b/internal/exec/runtime/signal_test.go
index 62b6e05ebb..26925fc248 100644
--- a/internal/exec/runtime/signal_test.go
+++ b/internal/exec/runtime/signal_test.go
@@ -12,6 +12,51 @@ import (
 	"github.com/Open-MBEE/OpenSysML/internal/syntax/ast"
 )
 
+func TestMessageSerialsStayMonotonicAcrossSnapshotRestore(t *testing.T) {
+	_, _, ctx := buildRuntimeWithLibraries(t, "<test>", parseAndBuild(t, "package P {}"))
+	trace := NewTraceRecorder()
+	ctx.SetTrace(trace)
+	ctx.PostMessage(Message{SignalType: "Ping"})
+	snapshot, err := ctx.Snapshot()
+	if err != nil {
+		t.Fatalf("snapshot: %v", err)
+	}
+	defer snapshot.Release()
+
+	ctx.PostMessage(Message{SignalType: "Ping"})
+	snapshot.Restore()
+	ctx.PostMessage(Message{SignalType: "Ping"})
+
+	messages := ctx.PendingMessages()
+	if len(messages) != 2 || messages[0].Serial != 1 || messages[1].Serial != 3 {
+		t.Fatalf("pending messages = %+v, want serials 1 and 3", messages)
+	}
+	records := trace.Records()
+	if len(records) != 2 || records[0].Message != 1 || records[1].Message != 3 {
+		t.Fatalf("send records = %+v, want serials 1 and 3", records)
+	}
+}
+
+func TestMessageSerialsStayMonotonicAcrossJournalRollback(t *testing.T) {
+	_, _, ctx := buildRuntimeWithLibraries(t, "<test>", parseAndBuild(t, "package P {}"))
+	trace := NewTraceRecorder()
+	ctx.SetTrace(trace)
+	ctx.PostMessage(Message{SignalType: "Ping"})
+	_, rollback := ctx.beginJournal()
+	ctx.PostMessage(Message{SignalType: "Ping"})
+	rollback()
+	ctx.PostMessage(Message{SignalType: "Ping"})
+
+	messages := ctx.PendingMessages()
+	if len(messages) != 2 || messages[0].Serial != 1 || messages[1].Serial != 3 {
+		t.Fatalf("pending messages = %+v, want serials 1 and 3", messages)
+	}
+	records := trace.Records()
+	if len(records) != 2 || records[0].Message != 1 || records[1].Message != 3 {
+		t.Fatalf("send records = %+v, want serials 1 and 3", records)
+	}
+}
+
 // A message built outside a send carries its payload by feature name: a feature
 // redefined under another name is one slot, reported when two entries name it
 // rather than resolved by map order, and an entry naming no feature is refused.
diff --git a/internal/exec/runtime/state_executor.go b/internal/exec/runtime/state_executor.go
index 404913d3e3..4f98e770f8 100644
--- a/internal/exec/runtime/state_executor.go
+++ b/internal/exec/runtime/state_executor.go
@@ -816,9 +816,9 @@ func (e *StateExecutor) recordAccept(event Event, mark int, at float64) {
 	origin := TraceOrigin{At: at, Object: e.self, Behavior: e.stateMachine}
 	switch payload := event.Payload.(type) {
 	case Message:
-		tr.RecordAcceptAt(mark, origin, acceptedEventName(payload), payload.Payload)
+		tr.RecordAcceptAt(mark, origin, payload.Serial, acceptedEventName(payload), payload.Payload)
 	case Call:
-		tr.RecordAcceptAt(mark, origin, payload.Operation, payload.Args)
+		tr.RecordAcceptAt(mark, origin, 0, payload.Operation, payload.Args)
 	}
 }
 
@@ -2394,7 +2394,7 @@ func (e *StateExecutor) terminateMachine(fromName string, trigger ast.Node, stop
 	}
 	abandoned := e.abandonMachine()
 	if e.trace() != nil {
-		e.trace().RecordStateTerminate(name, abandoned)
+		e.trace().RecordStateTerminate(e.traceOrigin(), name, abandoned)
 	}
 	e.state = StateTerminated
 	e.ctx.endPerformanceLife(e.occurrence)
@@ -4103,7 +4103,7 @@ func (e *StateExecutor) stepDoAction(act *doAction, goOn func(*doRun) (*doRun, e
 
 	e.moved = true
 	if e.trace() != nil {
-		e.trace().RecordDoStep(e.traceOrigin(), act.state.Name)
+		e.trace().RecordDoStep(e.traceOrigin(), act.state.Name, e.StatePath(act.state), e.RegionPath(act.state))
 	}
 	if run == nil {
 		act.pending = act.pending[1:]
@@ -5244,8 +5244,11 @@ func (e *StateExecutor) performEntry(state *ast.StateNode) error {
 		e.stateVisits = append(e.stateVisits, state.Name)
 
 		// Record trace
-		if e.trace() != nil {
-			e.trace().RecordStateEntry(e.traceOrigin(), state.Name, len(e.behaviorsOf(state).Entry) > 0)
+		if trace := e.trace(); trace != nil {
+			trace.RecordStateEntryWithSource(
+				e.traceOrigin(), state.Name, e.StatePath(state), e.RegionPath(state),
+				len(e.behaviorsOf(state).Entry) > 0, e.stateSourceOrigin(state),
+			)
 		}
 	}
 
@@ -5372,7 +5375,10 @@ func (e *StateExecutor) exitState(state *ast.StateNode) error {
 
 	// Record trace
 	if !e.graph.HiddenStates[state] && e.trace() != nil {
-		e.trace().RecordStateExit(e.traceOrigin(), state.Name, len(e.behaviorsOf(state).Exit) > 0)
+		e.trace().RecordStateExitWithSource(
+			e.traceOrigin(), state.Name, e.StatePath(state), e.RegionPath(state),
+			len(e.behaviorsOf(state).Exit) > 0, e.stateSourceOrigin(state),
+		)
 	}
 
 	// Execute exit actions
@@ -5595,6 +5601,50 @@ func (e *StateExecutor) StatePath(state *ast.StateNode) string {
 	return strings.Join(append(parts, state.Name), ".")
 }
 
+func (e *StateExecutor) stateSourceOrigin(state *ast.StateNode) symbols.Origin {
+	doc := e.graph.DocOf(state)
+	if doc == "" && e.stateMachine != nil {
+		doc = e.stateMachine.DocName
+	}
+	return symbols.NodeOrigin(doc, state)
+}
+
+// RegionOf returns the innermost orthogonal region a state stands in, or nil
+// when the state is outside every region.
+func (e *StateExecutor) RegionOf(state *ast.StateNode) *ast.StateRegion {
+	for current := state; current != nil; current = e.graph.ParentState[current] {
+		if region := e.graph.RegionOf[current]; region != nil {
+			return region
+		}
+		if region := e.graph.HiddenRegionOf[current]; region != nil {
+			return region
+		}
+	}
+	return nil
+}
+
+// RegionPath qualifies the innermost region by the written states enclosing it.
+func (e *StateExecutor) RegionPath(state *ast.StateNode) string {
+	region := e.RegionOf(state)
+	if region == nil {
+		return ""
+	}
+	owner := e.graph.RegionOwner[region]
+	parts := make([]string, 0)
+	if owner != nil {
+		for _, enclosing := range e.EnclosingStates(owner) {
+			parts = append(parts, enclosing.Name)
+		}
+		if !e.graph.HiddenStates[owner] && owner.Name != "" {
+			parts = append(parts, owner.Name)
+		}
+	}
+	if region.Name != "" {
+		parts = append(parts, region.Name)
+	}
+	return strings.Join(parts, ".")
+}
+
 // trace returns the recorder this executor's context is attached to, so turning
 // reporting on or off reaches an execution already under way.
 func (e *StateExecutor) trace() *TraceRecorder {
diff --git a/internal/exec/runtime/trace.go b/internal/exec/runtime/trace.go
index c15d6c61cf..153b4aa05e 100644
--- a/internal/exec/runtime/trace.go
+++ b/internal/exec/runtime/trace.go
@@ -38,6 +38,9 @@ const (
 	TraceChoice
 	// TraceGuard is a guard the run read to report a choice and could not evaluate.
 	TraceGuard
+	// TraceTerminate is a state machine's performance ending without exiting its states:
+	// a terminate action, or the end of the occurrence performing it.
+	TraceTerminate
 )
 
 // String names the kind as a query reads it.
@@ -61,6 +64,8 @@ func (k TraceKind) String() string {
 		return "choice"
 	case TraceGuard:
 		return "guard"
+	case TraceTerminate:
+		return "terminate"
 	}
 	return fmt.Sprintf("TraceKind(%d)", int(k))
 }
@@ -81,10 +86,17 @@ type TraceRecord struct {
 	// State is the state entered, exited or stepped; From and To are a fired
 	// transition's endpoints.
 	State, From, To string
+	// Path qualifies a state by its written enclosing states; Region qualifies
+	// the innermost orthogonal region, and is empty outside every region.
+	Path, Region string
+	// Source is where the state an entry or exit names was declared; zero when unknown.
+	Source symbols.Origin
 	// Event is the trigger a transition fired on, or the signal or operation an
 	// accept or send carries; Payload is the message's payload.
 	Event   string
 	Payload map[string]Value
+	// Message is the Serial of the message a send posted or an accept took; 0 for none.
+	Message uint64
 	// Target is the object a send was addressed to, nil for a broadcast or a
 	// destination named only as text (kept in To).
 	Target *Instance
@@ -124,6 +136,8 @@ func (r TraceRecord) Line() (line string, printed bool) {
 		return fmt.Sprintf("do: %s", r.State), true
 	case TraceChoice, TraceGuard:
 		return r.Note.String(), true
+	case TraceTerminate:
+		return r.text, true
 	}
 	return "", false
 }
@@ -137,6 +151,40 @@ func (r TraceRecord) Text() string {
 	return r.Kind.String() + " " + r.Event
 }
 
+// Machine names the behavior a record came from as its object exhibits it, or
+// as declared when it is anonymous or the record has no object.
+func (r TraceRecord) Machine() string {
+	behavior := r.Origin.Behavior
+	if behavior == nil {
+		return ""
+	}
+	if r.Origin.Object != nil {
+		for _, b := range r.Origin.Object.Behaviors() {
+			if b.Symbol == behavior || (b.State != nil && b.State.StateMachineSymbol() == behavior) {
+				if b.Name != "" {
+					return b.Name
+				}
+				break
+			}
+		}
+	}
+	return behavior.Name
+}
+
+// PayloadTexts renders a message payload as `name = value` entries in name order.
+func (r TraceRecord) PayloadTexts() []string {
+	names := make([]string, 0, len(r.Payload))
+	for name := range r.Payload {
+		names = append(names, name)
+	}
+	sort.Strings(names)
+	out := make([]string, 0, len(names))
+	for _, name := range names {
+		out = append(out, name+" = "+FormatValue(r.Payload[name]))
+	}
+	return out
+}
+
 // TraceRecorder keeps a run's trace as typed records, in the order they were
 // made, and prints them as the deterministic lines the golden trace tests read.
 //
@@ -266,11 +314,11 @@ func (tr *TraceRecorder) Mark() int {
 
 // RecordAcceptAt records an accept as RecordAccept does, placed at mark: before
 // the records the dispatch of the event made. A mark already printed stays printed.
-func (tr *TraceRecorder) RecordAcceptAt(mark int, origin TraceOrigin, event string, payload map[string]Value) {
+func (tr *TraceRecorder) RecordAcceptAt(mark int, origin TraceOrigin, serial uint64, event string, payload map[string]Value) {
 	if !tr.enabled {
 		return
 	}
-	record := TraceRecord{Kind: TraceAccept, Origin: origin, Event: event, Payload: payload}
+	record := TraceRecord{Kind: TraceAccept, Origin: origin, Event: event, Message: serial, Payload: payload}
 	mark = min(max(mark-tr.dropped, 0), len(tr.records))
 	tr.records = append(tr.records, TraceRecord{})
 	copy(tr.records[mark+1:], tr.records[mark:])
@@ -288,8 +336,8 @@ func (tr *TraceRecorder) RecordStateTransition(origin TraceOrigin, fromState, to
 
 // RecordAccept records an event a behavior took off its queue: the signal or
 // operation it names, with the payload it carries.
-func (tr *TraceRecorder) RecordAccept(origin TraceOrigin, event string, payload map[string]Value) {
-	tr.add(TraceRecord{Kind: TraceAccept, Origin: origin, Event: event, Payload: payload})
+func (tr *TraceRecorder) RecordAccept(origin TraceOrigin, serial uint64, event string, payload map[string]Value) {
+	tr.add(TraceRecord{Kind: TraceAccept, Origin: origin, Event: event, Message: serial, Payload: payload})
 }
 
 // RecordSend records a message posted onto the bus by the object at origin, or
@@ -299,37 +347,57 @@ func (tr *TraceRecorder) RecordSend(origin TraceOrigin, msg Message, target *Ins
 	if msg.EventName != "" {
 		event = msg.EventName
 	}
-	tr.add(TraceRecord{Kind: TraceSend, Origin: origin, Event: event, To: msg.Target, Target: target, Payload: msg.Payload})
+	tr.add(TraceRecord{Kind: TraceSend, Origin: origin, Event: event, Message: msg.Serial, To: msg.Target, Target: target, Payload: msg.Payload})
 }
 
-// RecordStateTerminate records the machine's performance ending at the terminate
-// action stop, with the states whose do behaviors it abandoned.
-func (tr *TraceRecorder) RecordStateTerminate(stop string, abandoned []string) {
+// RecordStateTerminate records a state machine's performance ending without exiting its
+// states: a terminate action, or the end of the occurrence performing it.
+func (tr *TraceRecorder) RecordStateTerminate(origin TraceOrigin, stop string, abandoned []string) {
+	text := fmt.Sprintf("terminate: %s", stop)
 	if len(abandoned) == 0 {
-		tr.line(fmt.Sprintf("terminate: %s", stop))
-		return
+		tr.add(TraceRecord{Kind: TraceTerminate, Origin: origin, text: text})
+	} else {
+		text += fmt.Sprintf(" (do behavior abandoned: %s)", strings.Join(abandoned, ", "))
+		tr.add(TraceRecord{Kind: TraceTerminate, Origin: origin, text: text})
 	}
-	tr.line(fmt.Sprintf("terminate: %s (do behavior abandoned: %s)", stop, strings.Join(abandoned, ", ")))
 }
 
 // RecordStateEndedWithOccurrence records the machine's performance ending with the
 // occurrence a `terminate` named, with the states whose do behaviors it abandoned.
-func (tr *TraceRecorder) RecordStateEndedWithOccurrence(machine string, abandoned []string) {
+func (tr *TraceRecorder) RecordStateEndedWithOccurrence(origin TraceOrigin, machine string, abandoned []string) {
+	text := fmt.Sprintf("terminated with occurrence: %s", machine)
 	if len(abandoned) == 0 {
-		tr.line(fmt.Sprintf("terminated with occurrence: %s", machine))
-		return
+		tr.add(TraceRecord{Kind: TraceTerminate, Origin: origin, text: text})
+	} else {
+		text += fmt.Sprintf(" (do behavior abandoned: %s)", strings.Join(abandoned, ", "))
+		tr.add(TraceRecord{Kind: TraceTerminate, Origin: origin, text: text})
 	}
-	tr.line(fmt.Sprintf("terminated with occurrence: %s (do behavior abandoned: %s)", machine, strings.Join(abandoned, ", ")))
 }
 
 // RecordStateEntry records entering a state with optional entry action execution.
-func (tr *TraceRecorder) RecordStateEntry(origin TraceOrigin, state string, hasEntryAction bool) {
-	tr.add(TraceRecord{Kind: TraceEntry, Origin: origin, State: state, Action: hasEntryAction})
+func (tr *TraceRecorder) RecordStateEntry(origin TraceOrigin, state, path, region string, hasEntryAction bool) {
+	tr.RecordStateEntryWithSource(origin, state, path, region, hasEntryAction, symbols.Origin{})
+}
+
+// RecordStateEntryWithSource records entering a state with its declaration origin.
+func (tr *TraceRecorder) RecordStateEntryWithSource(origin TraceOrigin, state, path, region string, hasEntryAction bool, source symbols.Origin) {
+	tr.add(TraceRecord{
+		Kind: TraceEntry, Origin: origin, State: state, Path: path, Region: region,
+		Source: source, Action: hasEntryAction,
+	})
 }
 
 // RecordStateExit records exiting a state with optional exit action execution.
-func (tr *TraceRecorder) RecordStateExit(origin TraceOrigin, state string, hasExitAction bool) {
-	tr.add(TraceRecord{Kind: TraceExit, Origin: origin, State: state, Action: hasExitAction})
+func (tr *TraceRecorder) RecordStateExit(origin TraceOrigin, state, path, region string, hasExitAction bool) {
+	tr.RecordStateExitWithSource(origin, state, path, region, hasExitAction, symbols.Origin{})
+}
+
+// RecordStateExitWithSource records exiting a state with its declaration origin.
+func (tr *TraceRecorder) RecordStateExitWithSource(origin TraceOrigin, state, path, region string, hasExitAction bool, source symbols.Origin) {
+	tr.add(TraceRecord{
+		Kind: TraceExit, Origin: origin, State: state, Path: path, Region: region,
+		Source: source, Action: hasExitAction,
+	})
 }
 
 // RecordActionNodeEnter records a token entering the flow an action node owns,
@@ -483,8 +551,8 @@ func (tr *TraceRecorder) record(entry string) {
 
 // RecordDoStep records one action of a state's do behavior, which is how the
 // interleaving of concurrently active states' do behaviors becomes visible.
-func (tr *TraceRecorder) RecordDoStep(origin TraceOrigin, state string) {
-	tr.add(TraceRecord{Kind: TraceDo, Origin: origin, State: state})
+func (tr *TraceRecorder) RecordDoStep(origin TraceOrigin, state, path, region string) {
+	tr.add(TraceRecord{Kind: TraceDo, Origin: origin, State: state, Path: path, Region: region})
 }
 
 // RecordEvent records an event being processed.
diff --git a/internal/exec/runtime/trace_records_test.go b/internal/exec/runtime/trace_records_test.go
index b81da7e437..8a69126e94 100644
--- a/internal/exec/runtime/trace_records_test.go
+++ b/internal/exec/runtime/trace_records_test.go
@@ -107,22 +107,83 @@ func TestTraceRecordsCarryTheBehaviorThatMadeThem(t *testing.T) {
 	}
 }
 
+func TestStateTraceRecordsCarryWrittenPathsAndInnermostRegions(t *testing.T) {
+	idx, _, ctx := buildRuntimeWithLibraries(t, "<test>", parseAndBuild(t, `
+		package test {
+			attribute def Ping;
+			state def Machine {
+				entry; then open;
+				state open parallel {
+					state pointing {
+						entry; then slewing;
+						state slewing;
+						state settled;
+						transition first slewing accept Ping then settled;
+					}
+					state power {
+						entry; then awake;
+						state awake;
+					}
+				}
+			}
+		}`))
+	exec, err := ctx.CreateStateExecutor(oneSymbol(t, idx, "test::Machine"))
+	if err != nil {
+		t.Fatalf("create executor: %v", err)
+	}
+	trace := NewTraceRecorder()
+	exec.SetTrace(trace)
+	if err := exec.initialize(); err != nil {
+		t.Fatalf("initialize: %v", err)
+	}
+	exec.SendSignal("Ping", nil)
+	if err := exec.RunToCompletion(); err != nil {
+		t.Fatalf("run: %v", err)
+	}
+
+	got := make(map[string]map[TraceKind]TraceRecord)
+	for _, record := range trace.Records() {
+		if (record.Kind == TraceEntry || record.Kind == TraceExit) &&
+			(record.State == "slewing" || record.State == "awake") {
+			if got[record.State] == nil {
+				got[record.State] = make(map[TraceKind]TraceRecord)
+			}
+			got[record.State][record.Kind] = record
+		}
+	}
+	for state, region := range map[string]string{"slewing": "open.pointing", "awake": "open.power"} {
+		record, ok := got[state][TraceEntry]
+		if !ok {
+			t.Fatalf("trace has no entry record for %s: %+v", state, trace.Records())
+		}
+		wantPath := "open." + state
+		if record.Path != wantPath || record.Region != region {
+			t.Errorf("%s path/region = %q / %q, want %q / %q", state, record.Path, record.Region, wantPath, region)
+		}
+	}
+	if record, ok := got["slewing"][TraceExit]; !ok {
+		t.Errorf("trace has no exit record for slewing: %+v", trace.Records())
+	} else if record.Path != "open.slewing" || record.Region != "open.pointing" {
+		t.Errorf("slewing exit path/region = %q / %q, want open.slewing / open.pointing", record.Path, record.Region)
+	}
+}
+
 // An event recorder keeps the most recent limit records, no printed lines, and
 // places a late accept by its whole-run mark.
 func TestEventRecorderKeepsTheMostRecentRecords(t *testing.T) {
 	tr := NewEventRecorder(3)
 	at := func(t float64, object *Instance) TraceOrigin { return TraceOrigin{At: t, Object: object} }
 	tr.line("printed only")
-	tr.RecordStateEntry(at(0, nil), "a", false)
-	tr.RecordStateEntry(at(1, nil), "b", false)
+	tr.RecordStateEntry(at(0, nil), "a", "a", "", false)
+	tr.RecordStateEntry(at(1, nil), "b", "b", "", false)
 	if dropped, _ := tr.Dropped(); dropped != 0 || len(tr.Records()) != 2 {
 		t.Fatalf("records = %d dropped = %d, want the two entries and no line", len(tr.Records()), dropped)
 	}
 	tr.Clear()
 	mark := tr.Mark()
-	tr.RecordStateEntry(at(2, nil), "c", false)
-	tr.RecordStateEntry(at(3, nil), "d", false)
-	tr.RecordAcceptAt(mark, at(2, nil), "Go", nil)
+	tr.RecordStateEntry(at(2, nil), "c", "c", "", false)
+	tr.RecordStateEntry(at(3, nil), "d", "d", "", false)
+	tr.RecordAcceptAt(mark, at(2, nil), 0, "Go", nil)
 	states := func() string {
 		var out []string
 		for _, r := range tr.Records() {
@@ -150,7 +211,7 @@ func TestEventRecorderCaptureRestoresTruncation(t *testing.T) {
 	tr := NewEventRecorder(3)
 	at := func(t float64) TraceOrigin { return TraceOrigin{At: t} }
 	for i, s := range []string{"a", "b", "c", "d"} {
-		tr.RecordStateEntry(at(float64(i)), s, false)
+		tr.RecordStateEntry(at(float64(i)), s, s, "", false)
 	}
 	states := func() string {
 		var out []string
@@ -160,8 +221,8 @@ func TestEventRecorderCaptureRestoresTruncation(t *testing.T) {
 		return strings.Join(out, " ")
 	}
 	capture := captureTrace(tr)
-	tr.RecordStateEntry(at(4), "e", false)
-	tr.RecordStateEntry(at(5), "f", false)
+	tr.RecordStateEntry(at(4), "e", "e", "", false)
+	tr.RecordStateEntry(at(5), "f", "f", "", false)
 	if dropped, upTo := tr.Dropped(); states() != "d e f" || dropped != 3 || upTo != 2 {
 		t.Fatalf("after the mark: %s dropped %d up to %v", states(), dropped, upTo)
 	}
diff --git a/internal/exec/runtrace/render_golden_test.go b/internal/exec/runtrace/render_golden_test.go
new file mode 100644
index 0000000000..de23d5f5fd
--- /dev/null
+++ b/internal/exec/runtrace/render_golden_test.go
@@ -0,0 +1,405 @@
+package runtrace
+
+import (
+	"flag"
+	"fmt"
+	"os"
+	"path/filepath"
+	"testing"
+
+	"github.com/Open-MBEE/OpenSysML/internal/exec/runtime"
+	"github.com/Open-MBEE/OpenSysML/internal/ir/view"
+	"github.com/Open-MBEE/OpenSysML/internal/semantic/resolve"
+	"github.com/Open-MBEE/OpenSysML/internal/semantic/semantics"
+	"github.com/Open-MBEE/OpenSysML/internal/semantic/symbols"
+	"github.com/Open-MBEE/OpenSysML/internal/syntax/parser"
+	"github.com/Open-MBEE/OpenSysML/internal/syntax/source"
+	"github.com/Open-MBEE/OpenSysML/internal/workspace/libs"
+)
+
+var updateRunGoldens = flag.Bool("update", false, "rewrite run-rendering goldens")
+
+type renderingGolden struct {
+	name    string
+	form    view.Form
+	run     *view.Rendering
+	options view.Options
+}
+
+func TestRunRenderingGoldens(t *testing.T) {
+	example, options := exampleRun(t)
+	cases := make([]renderingGolden, 0)
+	for _, kind := range []Kind{KindTimeline, KindSequence} {
+		run, err := Render(kind, example, options)
+		if err != nil {
+			t.Fatal(err)
+		}
+		cases = appendForms(cases, "example-"+string(kind), run)
+		if kind == KindSequence {
+			path := filepath.Join("..", "..", "..", "examples", "run-timeline", "run-timeline.sysml")
+			data, err := os.ReadFile(path)
+			if err != nil {
+				t.Fatal(err)
+			}
+			linkedOptions := view.Options{Links: linksForTestFile(path, data)}
+			for _, form := range []view.Form{view.FormMermaid, view.FormPlantUML} {
+				cases = append(cases, renderingGolden{
+					name: "example-sequence-links", form: form, run: run, options: linkedOptions,
+				})
+			}
+		} else {
+			path := filepath.Join("..", "..", "..", "examples", "run-timeline", "run-timeline.sysml")
+			data, err := os.ReadFile(path)
+			if err != nil {
+				t.Fatal(err)
+			}
+			cases = append(cases, renderingGolden{
+				name: "example-timeline-links", form: view.FormPlantUML, run: run,
+				options: view.Options{Links: linksForTestFile(path, data)},
+			})
+		}
+		empty, err := Render(kind, runtime.NewTraceRecorder(), Options{})
+		if err != nil {
+			t.Fatal(err)
+		}
+		cases = appendForms(cases, "empty-"+string(kind), empty)
+	}
+
+	parallelTrace, parallelOptions, _, _ := fixtureRun(t, "parallel-regions.sysml", "box", 2)
+	parallelTimeline, err := Render(KindTimeline, parallelTrace, parallelOptions)
+	if err != nil {
+		t.Fatal(err)
+	}
+	cases = append(cases, renderingGolden{name: "parallel-regions-timeline", form: view.FormText, run: parallelTimeline})
+	parallelPath := filepath.Join("testdata", "parallel-regions.sysml")
+	parallelData, err := os.ReadFile(parallelPath)
+	if err != nil {
+		t.Fatal(err)
+	}
+	cases = append(cases, renderingGolden{
+		name: "parallel-regions-timeline-links", form: view.FormPlantUML, run: parallelTimeline,
+		options: view.Options{Links: linksForTestFile(parallelPath, parallelData)},
+	})
+
+	serialTrace, serialOptions, serialCtx, mission := fixtureRun(t, "serial-pairing.sysml", "mission", 2)
+	serialLabels := make(map[int64]string)
+	for _, name := range []string{"alpha", "beta", "receiver"} {
+		value, err := mission.GetFeatureValue(serialCtx, name)
+		if err != nil {
+			t.Fatal(err)
+		}
+		id, ok := value.HeldValue().Object()
+		if !ok {
+			t.Fatalf("mission.%s does not hold an object", name)
+		}
+		serialLabels[id] = "SerialPairing::mission." + name
+	}
+	serialOptions.Label = func(inst *runtime.Instance) string { return serialLabels[inst.ID] }
+	serialSequence, err := Render(KindSequence, serialTrace, serialOptions)
+	if err != nil {
+		t.Fatal(err)
+	}
+	cases = append(cases, renderingGolden{name: "serial-pairing-sequence", form: view.FormText, run: serialSequence})
+
+	terminationTrace, terminationOptions, _, _ := fixtureRun(t, "termination.sysml", "mission", 10)
+	terminationTimeline, err := Render(KindTimeline, terminationTrace, terminationOptions)
+	if err != nil {
+		t.Fatal(err)
+	}
+	cases = append(cases, renderingGolden{name: "termination-timeline", form: view.FormText, run: terminationTimeline})
+
+	cappedTimeline := longTimeline()
+	cappedTimelineOptions := Options{Until: 201, Limit: 200}
+	capped, err := Render(KindTimeline, cappedTimeline, cappedTimelineOptions)
+	if err != nil {
+		t.Fatal(err)
+	}
+	cases = append(cases, renderingGolden{name: "capped-timeline", form: view.FormText, run: capped})
+	cappedSequence, err := Render(KindSequence, longSequence(), Options{Until: 201, Limit: 200})
+	if err != nil {
+		t.Fatal(err)
+	}
+	cases = append(cases, renderingGolden{name: "capped-sequence", form: view.FormText, run: cappedSequence})
+
+	truncatedTimeline := truncatedTimelineTrace()
+	truncated, err := Render(KindTimeline, truncatedTimeline, Options{Until: 4})
+	if err != nil {
+		t.Fatal(err)
+	}
+	cases = append(cases, renderingGolden{name: "truncated-timeline", form: view.FormText, run: truncated})
+	truncatedSequence, err := Render(KindSequence, truncatedSequenceTrace(), Options{Until: 4})
+	if err != nil {
+		t.Fatal(err)
+	}
+	cases = append(cases, renderingGolden{name: "truncated-sequence", form: view.FormText, run: truncatedSequence})
+
+	guard, guardOptions := guardTrace()
+	guardRun, err := Render(KindTimeline, guard, guardOptions)
+	if err != nil {
+		t.Fatal(err)
+	}
+	cases = append(cases, renderingGolden{name: "guard-timeline", form: view.FormText, run: guardRun})
+	messages := messageEdgeCases()
+	messageRun, err := Render(KindSequence, messages, Options{Until: 4})
+	if err != nil {
+		t.Fatal(err)
+	}
+	cases = append(cases, renderingGolden{name: "messages-sequence", form: view.FormText, run: messageRun})
+	selfTransition, err := Render(KindTimeline, selfTransitionTrace(), Options{Until: 2})
+	if err != nil {
+		t.Fatal(err)
+	}
+	cases = append(cases, renderingGolden{name: "self-transition-timeline", form: view.FormText, run: selfTransition})
+	hashLabel := runtime.NewTraceRecorder()
+	hashObject, hashBehavior := traceObject(7, "receiver")
+	hashLabel.RecordStateEntry(traceOrigin(0, hashObject, hashBehavior), "ready", "ready", "", false)
+	hashRun, err := Render(KindTimeline, hashLabel, Options{Until: 1})
+	if err != nil {
+		t.Fatal(err)
+	}
+	cases = appendForms(cases, "hash-label-timeline", hashRun)
+	for _, kind := range []Kind{KindTimeline, KindSequence} {
+		run, err := Render(kind, example, options)
+		if err != nil {
+			t.Fatal(err)
+		}
+		cases = append(cases, renderingGolden{name: "dot-" + string(kind), form: view.FormDot, run: run})
+	}
+
+	for _, tc := range cases {
+		t.Run(tc.name+"."+string(tc.form), func(t *testing.T) {
+			got, err := tc.run.WriteWith(tc.form, tc.options)
+			if tc.form == view.FormDot {
+				if err == nil {
+					t.Fatal("DOT rendering unexpectedly succeeded")
+				}
+				got = err.Error() + "\n"
+			} else if err != nil {
+				t.Fatal(err)
+			}
+			path := filepath.Join("testdata", tc.name+"."+string(tc.form)+".golden")
+			if *updateRunGoldens {
+				if err := os.WriteFile(path, []byte(got), 0o644); err != nil {
+					t.Fatal(err)
+				}
+				return
+			}
+			want, err := os.ReadFile(path)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if string(want) != got {
+				t.Errorf("golden mismatch; run with -update to accept:\n%s", firstDifference(string(want), got))
+			}
+		})
+	}
+}
+
+func linksForTestFile(path string, data []byte) view.Links {
+	doc := filepath.Clean(path)
+	lines := source.NewLineIndex(data)
+	return view.Links{
+		Template: "https://example.test/src/{file}#L{line}",
+		Sites: func(origin view.Origin) (view.Site, bool) {
+			if filepath.Clean(origin.Doc) != doc || !origin.Located() {
+				return view.Site{}, false
+			}
+			pos := lines.PosAt(origin.Span.Offset)
+			return view.Site{File: filepath.Base(doc), Line: pos.Line, Col: pos.Col}, true
+		},
+	}
+}
+
+func appendForms(cases []renderingGolden, name string, run *view.Rendering) []renderingGolden {
+	for _, form := range []view.Form{view.FormText, view.FormMermaid, view.FormPlantUML} {
+		cases = append(cases, renderingGolden{name: name, form: form, run: run})
+	}
+	return cases
+}
+
+func exampleRun(t *testing.T) (*runtime.TraceRecorder, Options) {
+	t.Helper()
+	path := filepath.Join("..", "..", "..", "examples", "run-timeline", "run-timeline.sysml")
+	data, err := os.ReadFile(path)
+	if err != nil {
+		t.Fatal(err)
+	}
+	src := source.New(path, data)
+	file := parser.New(src).ParseFile()
+	index := libs.NewModelIndex()
+	index.AddDocument(path, file)
+	resolver := resolve.New(index)
+	ctx := runtime.NewContext(runtime.NewModel(semantics.NewModel(resolver), resolver), 100_000)
+	ctx.SetTrace(runtime.NewTraceRecorder())
+	if err := ctx.SetSchedule(runtime.DefaultSchedulePolicy); err != nil {
+		t.Fatal(err)
+	}
+	packageScope := index.DocumentRoot(path).Children()[0]
+	root, err := ctx.Instantiate(mustSymbol(t, packageScope, "mission"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	labels := make(map[int64]string)
+	for _, feature := range []string{"controller", "instrument"} {
+		fv, err := root.GetFeatureValue(ctx, feature)
+		if err != nil {
+			t.Fatal(err)
+		}
+		id, ok := fv.HeldValue().Object()
+		if !ok {
+			t.Fatalf("mission.%s does not hold an object", feature)
+		}
+		labels[id] = "RunTimeline::mission." + feature
+	}
+	if _, err := ctx.Advance(6); err != nil {
+		t.Fatal(err)
+	}
+	return ctx.Trace(), Options{
+		Until: 6,
+		Label: func(inst *runtime.Instance) string { return labels[inst.ID] },
+	}
+}
+
+func fixtureRun(t *testing.T, filename, instanceName string, until float64) (*runtime.TraceRecorder, Options, *runtime.Context, *runtime.Instance) {
+	t.Helper()
+	path := filepath.Join("testdata", filename)
+	data, err := os.ReadFile(path)
+	if err != nil {
+		t.Fatal(err)
+	}
+	src := source.New(path, data)
+	file := parser.New(src).ParseFile()
+	index := libs.NewModelIndex()
+	index.AddDocument(path, file)
+	resolver := resolve.New(index)
+	ctx := runtime.NewContext(runtime.NewModel(semantics.NewModel(resolver), resolver), 100_000)
+	ctx.SetTrace(runtime.NewTraceRecorder())
+	if err := ctx.SetSchedule(runtime.DefaultSchedulePolicy); err != nil {
+		t.Fatal(err)
+	}
+	packageScope := index.DocumentRoot(path).Children()[0]
+	root, err := ctx.Instantiate(mustSymbol(t, packageScope, instanceName))
+	if err != nil {
+		t.Fatal(err)
+	}
+	if _, err := ctx.Advance(until); err != nil {
+		t.Fatal(err)
+	}
+	return ctx.Trace(), Options{
+		Until: until,
+		Label: func(inst *runtime.Instance) string {
+			if inst.Type != nil {
+				return inst.Type.Name
+			}
+			return ""
+		},
+	}, ctx, root
+}
+
+func mustSymbol(t *testing.T, scope *symbols.Scope, name string) *symbols.Symbol {
+	t.Helper()
+	if scope == nil {
+		t.Fatalf("no scope while looking up %q", name)
+	}
+	symbol, ok := scope.LookupLocal(name)
+	if !ok {
+		t.Fatalf("no symbol %q", name)
+	}
+	return symbol
+}
+
+func traceOrigin(at float64, object *runtime.Instance, behavior *symbols.Symbol) runtime.TraceOrigin {
+	return runtime.TraceOrigin{At: at, Object: object, Behavior: behavior}
+}
+
+func traceObject(id int64, name string) (*runtime.Instance, *symbols.Symbol) {
+	typeSymbol := &symbols.Symbol{Name: name}
+	return &runtime.Instance{ID: id, Type: typeSymbol}, &symbols.Symbol{Name: "modes"}
+}
+
+func longTimeline() *runtime.TraceRecorder {
+	trace := runtime.NewTraceRecorder()
+	object, behavior := traceObject(1, "sender")
+	trace.RecordStateEntry(traceOrigin(0, object, behavior), "s0", "s0", "", false)
+	for at := 1; at <= 201; at++ {
+		from := fmt.Sprintf("s%d", at-1)
+		to := fmt.Sprintf("s%d", at)
+		trace.RecordStateExit(traceOrigin(float64(at), object, behavior), from, from, "", false)
+		trace.RecordStateTransition(traceOrigin(float64(at), object, behavior), from, to, "tick")
+		trace.RecordStateEntry(traceOrigin(float64(at), object, behavior), to, to, "", false)
+	}
+	return trace
+}
+
+func longSequence() *runtime.TraceRecorder {
+	trace := runtime.NewTraceRecorder()
+	sender, senderBehavior := traceObject(1, "sender")
+	receiver, receiverBehavior := traceObject(2, "receiver")
+	for at := 0; at < 201; at++ {
+		trace.RecordSend(traceOrigin(float64(at), sender, senderBehavior), runtime.Message{SignalType: "Ping"}, receiver)
+		trace.RecordAccept(traceOrigin(float64(at), receiver, receiverBehavior), 0, "Ping", nil)
+	}
+	return trace
+}
+
+func truncatedTimelineTrace() *runtime.TraceRecorder {
+	trace := runtime.NewEventRecorder(2)
+	object, behavior := traceObject(1, "sender")
+	trace.RecordStateEntry(traceOrigin(0, object, behavior), "old", "old", "", false)
+	trace.RecordStateExit(traceOrigin(1, object, behavior), "old", "old", "", false)
+	trace.RecordStateEntry(traceOrigin(2, object, behavior), "next", "next", "", false)
+	trace.RecordStateExit(traceOrigin(3, object, behavior), "next", "next", "", false)
+	trace.RecordStateEntry(traceOrigin(4, object, behavior), "held", "held", "", false)
+	return trace
+}
+
+func truncatedSequenceTrace() *runtime.TraceRecorder {
+	trace := runtime.NewEventRecorder(2)
+	sender, senderBehavior := traceObject(1, "sender")
+	receiver, receiverBehavior := traceObject(2, "receiver")
+	trace.RecordSend(traceOrigin(0, sender, senderBehavior), runtime.Message{SignalType: "Old"}, receiver)
+	trace.RecordAccept(traceOrigin(1, receiver, receiverBehavior), 0, "Old", nil)
+	trace.RecordSend(traceOrigin(2, sender, senderBehavior), runtime.Message{SignalType: "Ping"}, receiver)
+	trace.RecordAccept(traceOrigin(3, receiver, receiverBehavior), 0, "Ping", nil)
+	return trace
+}
+
+func guardTrace() (*runtime.TraceRecorder, Options) {
+	trace := runtime.NewTraceRecorder()
+	object, behavior := traceObject(1, "sender")
+	origin := traceOrigin(1, object, behavior)
+	trace.RecordStateEntry(traceOrigin(0, object, behavior), "waiting", "waiting", "", false)
+	trace.RecordNote(origin, runtime.UnevaluableGuard{Where: "waiting", Alternative: "accept Ping", Reason: "unbound"})
+	return trace, Options{Until: 2}
+}
+
+func messageEdgeCases() *runtime.TraceRecorder {
+	trace := runtime.NewTraceRecorder()
+	sender, senderBehavior := traceObject(1, "sender")
+	receiver, receiverBehavior := traceObject(2, "receiver")
+	trace.RecordSend(traceOrigin(0, sender, senderBehavior), runtime.Message{SignalType: "Unmatched"}, receiver)
+	trace.RecordSend(traceOrigin(1, nil, nil), runtime.Message{SignalType: "Outside"}, nil)
+	trace.RecordSend(traceOrigin(2, sender, senderBehavior), runtime.Message{SignalType: "Broadcast"}, nil)
+	trace.RecordAccept(traceOrigin(2.5, receiver, receiverBehavior), 0, "Broadcast", nil)
+	trace.RecordAccept(traceOrigin(3, receiver, receiverBehavior), 0, "Missing", nil)
+	return trace
+}
+
+func selfTransitionTrace() *runtime.TraceRecorder {
+	trace := runtime.NewTraceRecorder()
+	object, behavior := traceObject(1, "sender")
+	trace.RecordStateEntry(traceOrigin(0, object, behavior), "idle", "idle", "", false)
+	trace.RecordStateExit(traceOrigin(1, object, behavior), "idle", "idle", "", false)
+	trace.RecordStateTransition(traceOrigin(1, object, behavior), "idle", "idle", "accept Tick")
+	trace.RecordStateEntry(traceOrigin(1, object, behavior), "idle", "idle", "", false)
+	return trace
+}
+
+func firstDifference(want, got string) string {
+	for i := 0; i < len(want) && i < len(got); i++ {
+		if want[i] != got[i] {
+			return fmt.Sprintf("first difference at byte %d\nwant: %q\ngot:  %q", i, want[i:], got[i:])
+		}
+	}
+	return fmt.Sprintf("want %d bytes, got %d", len(want), len(got))
+}
diff --git a/internal/exec/runtrace/runtrace.go b/internal/exec/runtrace/runtrace.go
new file mode 100644
index 0000000000..1c0530cef7
--- /dev/null
+++ b/internal/exec/runtrace/runtrace.go
@@ -0,0 +1,88 @@
+package runtrace
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+
+	"github.com/Open-MBEE/OpenSysML/internal/exec/runtime"
+	"github.com/Open-MBEE/OpenSysML/internal/ir/view"
+)
+
+// Kind is a rendering of a recorded execution run.
+type Kind string
+
+const (
+	// KindTimeline renders state occupancy over a run's clock time.
+	KindTimeline Kind = "timeline"
+	// KindSequence renders the messages recorded during a run.
+	KindSequence Kind = "sequence"
+	// DefaultLimit bounds the number of spans or messages in a run rendering.
+	DefaultLimit = 200
+)
+
+// Kinds are the run renderings, in the order they are offered.
+func Kinds() []Kind { return []Kind{KindTimeline, KindSequence} }
+
+// ParseKind reports whether s names a run rendering.
+func ParseKind(s string) (Kind, bool) {
+	kind := Kind(s)
+	switch kind {
+	case KindTimeline, KindSequence:
+		return kind, true
+	}
+	return "", false
+}
+
+// Options tune the labels, end instant and size of a run rendering.
+type Options struct {
+	Label func(*runtime.Instance) string
+	Until float64
+	Limit int
+}
+
+// ErrNoTrace reports a session with no recorded trace.
+var ErrNoTrace = errors.New("the session records no trace")
+
+// Render builds one run rendering from its trace.
+func Render(kind Kind, trace *runtime.TraceRecorder, options Options) (*view.Rendering, error) {
+	if trace == nil {
+		return nil, ErrNoTrace
+	}
+	switch kind {
+	case KindTimeline:
+		return Timeline(trace, options), nil
+	case KindSequence:
+		return Sequence(trace, options), nil
+	default:
+		return nil, fmt.Errorf("unknown run rendering %q; ask for %s", kind, kindNames())
+	}
+}
+
+// Timeline builds a state-occupancy timeline from the trace.
+func Timeline(trace *runtime.TraceRecorder, options Options) *view.Rendering {
+	return timeline(trace, options)
+}
+
+// Sequence builds a message sequence from the trace.
+func Sequence(trace *runtime.TraceRecorder, options Options) *view.Rendering {
+	return sequence(trace, options)
+}
+
+func kindNames() string {
+	kinds := Kinds()
+	names := make([]string, len(kinds))
+	for i, kind := range kinds {
+		names[i] = string(kind)
+	}
+	return strings.Join(names, ", ")
+}
+
+func runRendering(kind view.Kind, options Options) *view.Rendering {
+	return &view.Rendering{
+		Kind:     kind,
+		Run:      true,
+		RunUntil: options.Until,
+		Stated:   fmt.Sprintf("the trace of a run to t = %s", runInstant(options.Until)),
+	}
+}
diff --git a/internal/exec/runtrace/runtrace_test.go b/internal/exec/runtrace/runtrace_test.go
new file mode 100644
index 0000000000..d57be119ea
--- /dev/null
+++ b/internal/exec/runtrace/runtrace_test.go
@@ -0,0 +1,450 @@
+package runtrace
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+
+	"github.com/Open-MBEE/OpenSysML/internal/exec/runtime"
+	"github.com/Open-MBEE/OpenSysML/internal/ir/view"
+	"github.com/Open-MBEE/OpenSysML/internal/semantic/symbols"
+)
+
+func TestKindParsingAndMissingTrace(t *testing.T) {
+	if got := fmt.Sprint(Kinds()); got != "[timeline sequence]" {
+		t.Fatalf("Kinds() = %s", got)
+	}
+	for _, want := range Kinds() {
+		got, ok := ParseKind(string(want))
+		if !ok || got != want {
+			t.Errorf("ParseKind(%q) = %q, %t", want, got, ok)
+		}
+	}
+	if _, ok := ParseKind("Timeline"); ok {
+		t.Error("ParseKind accepted a differently cased kind")
+	}
+	if _, err := Render(KindTimeline, nil, Options{}); !errors.Is(err, ErrNoTrace) {
+		t.Errorf("Render with no trace = %v, want ErrNoTrace", err)
+	}
+	if _, err := Render(Kind("other"), runtime.NewEventRecorder(0), Options{}); err == nil ||
+		!strings.Contains(err.Error(), "timeline, sequence") {
+		t.Errorf("Render with an unknown kind = %v", err)
+	}
+}
+
+func TestTimelineGroupsStateChangesAndOrdersParallelLeaves(t *testing.T) {
+	trace := runtime.NewEventRecorder(0)
+	rover := testObject(1, "Rover")
+	drone := testObject(2, "Drone")
+	machine := &symbols.Symbol{Name: "Machine"}
+	otherMachine := &symbols.Symbol{Name: "Other"}
+	origin := func(at float64) runtime.TraceOrigin {
+		return runtime.TraceOrigin{At: at, Object: rover, Behavior: machine}
+	}
+	trace.RecordStateEntry(origin(0), "open", "open", "", false)
+	trace.RecordStateEntry(origin(0), "slewing", "open.slewing", "open.pointing", false)
+	trace.RecordStateEntry(origin(0), "awake", "open.awake", "open.power", false)
+	trace.RecordStateEntry(origin(0), "blink", "open.pointing.blink", "open.pointing", false)
+	trace.RecordStateExit(origin(0), "blink", "open.pointing.blink", "open.pointing", false)
+	trace.RecordNote(origin(1), runtime.ChoicePoint{
+		Kind: runtime.ChoiceTransition, Where: "open", Alternatives: []string{"slewing", "settled"}, Taken: 0,
+	})
+	trace.RecordStateExit(origin(1.5), "slewing", "open.slewing", "open.pointing", false)
+	trace.RecordStateTransition(origin(1.5), "slewing", "settled", "accept Ping")
+	trace.RecordStateEntry(origin(1.5), "settled", "open.settled", "open.pointing", false)
+	trace.RecordStateExit(origin(2), "awake", "open.awake", "open.power", false)
+	trace.RecordStateTransition(origin(2), "awake", "awake", "after 1 s")
+	trace.RecordStateEntry(origin(2), "awake", "open.awake", "open.power", false)
+	trace.RecordNote(runtime.TraceOrigin{At: 2.5, Object: rover, Behavior: otherMachine},
+		runtime.UnevaluableGuard{Where: "open", Alternative: "stalled", Reason: "value unavailable"})
+	trace.RecordStateEntry(runtime.TraceOrigin{At: 0, Object: drone, Behavior: machine}, "ready", "ready", "", false)
+	environmentChoice := runtime.ChoicePoint{Kind: runtime.ChoiceRegionOrder, Where: "dispatch"}
+	trace.RecordNote(runtime.TraceOrigin{At: 3}, environmentChoice)
+
+	rendering := Timeline(trace, Options{
+		Until: 4,
+		Label: func(instance *runtime.Instance) string {
+			if instance.ID == rover.ID {
+				return "rover"
+			}
+			return "drone"
+		},
+	})
+	if !rendering.Run || rendering.Kind != view.KindTimeline || rendering.Stated != "the trace of a run to t = 4" {
+		t.Fatalf("timeline metadata = %+v", rendering)
+	}
+	if len(rendering.Lanes) != 2 || rendering.Lanes[0].ID != "l0" || rendering.Lanes[1].ID != "l1" {
+		t.Fatalf("lanes = %+v, want first-record order", rendering.Lanes)
+	}
+	lane := rendering.Lanes[0]
+	if lane.Name != "rover.Machine" {
+		t.Errorf("lane name = %q", lane.Name)
+	}
+	if len(lane.Spans) != 3 {
+		t.Fatalf("spans = %+v, want initial, triggered and self-transition spans", lane.Spans)
+	}
+	want := []view.Span{
+		{State: "slewing | awake", From: 0, To: 1.5, Through: []string{"blink"}},
+		{State: "settled | awake", From: 1.5, To: 2, Triggers: []string{"accept Ping"}},
+		{State: "settled | awake", From: 2, To: 4, Triggers: []string{"after 1 s"}, Open: true},
+	}
+	for i := range want {
+		if got := lane.Spans[i]; got.State != want[i].State || got.From != want[i].From || got.To != want[i].To ||
+			got.Open != want[i].Open || strings.Join(got.Triggers, "|") != strings.Join(want[i].Triggers, "|") ||
+			strings.Join(got.Through, "|") != strings.Join(want[i].Through, "|") {
+			t.Errorf("span %d = %+v, want %+v", i, got, want[i])
+		}
+	}
+	if len(lane.Transitions) != 2 || lane.Transitions[0].Event != "accept Ping" ||
+		lane.Transitions[1].From != "awake" || lane.Transitions[1].To != "awake" {
+		t.Errorf("transitions = %+v", lane.Transitions)
+	}
+	if len(lane.Marks) != 2 || lane.Marks[0].Kind != "choice" ||
+		lane.Marks[0].Text == "" || lane.Marks[1].Kind != "guard" || !strings.Contains(lane.Marks[1].Text, "unevaluable guard") {
+		t.Errorf("marks = %+v", lane.Marks)
+	}
+	if rendering.Lanes[1].Name != "drone.Machine" || len(rendering.Lanes[1].Spans) != 1 ||
+		rendering.Lanes[1].Spans[0].State != "ready" {
+		t.Errorf("second lane = %+v", rendering.Lanes[1])
+	}
+	if !strings.Contains(strings.Join(rendering.Notices, "\n"), environmentChoice.String()) {
+		t.Errorf("unattached mark notice = %v", rendering.Notices)
+	}
+}
+
+func TestTimelineDistinguishesSameNamedStatesInSiblingRegions(t *testing.T) {
+	trace, options, _, _ := fixtureRun(t, "parallel-regions.sysml", "box", 2)
+	var waiting []runtime.TraceRecord
+	for _, record := range trace.Records() {
+		if record.Kind == runtime.TraceEntry && record.State == "waiting" {
+			waiting = append(waiting, record)
+		}
+	}
+	if len(waiting) != 2 {
+		t.Fatalf("waiting entries = %+v, want two sibling leaves", waiting)
+	}
+	regions := make(map[string]bool, len(waiting))
+	for _, record := range waiting {
+		if record.Path != "open.waiting" {
+			t.Errorf("waiting path = %q, want open.waiting", record.Path)
+		}
+		regions[record.Region] = true
+	}
+	if !regions["open.left"] || !regions["open.right"] {
+		t.Errorf("waiting regions = %v, want open.left and open.right", regions)
+	}
+	rendering, err := Render(KindTimeline, trace, options)
+	if err != nil {
+		t.Fatal(err)
+	}
+	got, err := rendering.Write(view.FormText)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, want := range []string{"0 .. 1  left.waiting | right.waiting", "1 .. 2  done | waiting"} {
+		if !strings.Contains(got, want) {
+			t.Errorf("timeline is missing %q:\n%s", want, got)
+		}
+	}
+}
+
+func TestTimelineDisambiguatesThroughLabelsByRegionPath(t *testing.T) {
+	got := stateLabels([]runtime.TraceRecord{
+		{State: "waiting", Path: "open.waiting", Region: "open.left"},
+		{State: "waiting", Path: "open.waiting", Region: "open.right"},
+	})
+	if strings.Join(got, " | ") != "left.waiting | right.waiting" {
+		t.Errorf("through labels = %v, want [left.waiting right.waiting]", got)
+	}
+}
+
+func TestTimelineTruncationAndSpanLimit(t *testing.T) {
+	truncated := runtime.NewEventRecorder(3)
+	object := testObject(1, "Rover")
+	behavior := &symbols.Symbol{Name: "Machine"}
+	origin := func(at float64) runtime.TraceOrigin {
+		return runtime.TraceOrigin{At: at, Object: object, Behavior: behavior}
+	}
+	truncated.RecordStateEntry(origin(0), "lost", "lost", "", false)
+	truncated.RecordStateExit(origin(1), "lost", "lost", "", false)
+	truncated.RecordStateEntry(origin(2), "kept", "kept", "", false)
+	truncated.RecordStateExit(origin(3), "kept", "kept", "", false)
+	got := Timeline(truncated, Options{Until: 4})
+	if len(got.Lanes) != 1 || len(got.Lanes[0].Spans) != 1 ||
+		got.Lanes[0].Spans[0].State != "kept" || got.Lanes[0].Spans[0].From != 2 ||
+		!strings.Contains(strings.Join(got.Notices, "\n"), "1 earlier records up to t = 0 were dropped") {
+		t.Errorf("truncated rendering = %+v", got)
+	}
+
+	long := runtime.NewEventRecorder(0)
+	long.RecordStateEntry(origin(0), "s0", "s0", "", false)
+	for i := 1; i <= 202; i++ {
+		at := float64(i)
+		long.RecordStateExit(origin(at), fmt.Sprintf("s%d", i-1), fmt.Sprintf("s%d", i-1), "", false)
+		long.RecordStateEntry(origin(at), fmt.Sprintf("s%d", i), fmt.Sprintf("s%d", i), "", false)
+	}
+	limited := Timeline(long, Options{Until: 203, Limit: 200})
+	if count := len(limited.Lanes[0].Spans); count != 200 {
+		t.Fatalf("limited spans = %d, want 200", count)
+	}
+	last := limited.Lanes[0].Spans[199]
+	if last.From != 199 || last.To != 200 || last.Open {
+		t.Errorf("last capped span = %+v", last)
+	}
+	if !strings.Contains(strings.Join(limited.Notices, "\n"),
+		"3 later state changes from t = 200 are not drawn (at most 200 spans are)") {
+		t.Errorf("cap notice = %v", limited.Notices)
+	}
+}
+
+func TestTimelineCapUsesStableSpanIdentityForEqualInstants(t *testing.T) {
+	trace := runtime.NewEventRecorder(0)
+	behavior := &symbols.Symbol{Name: "Machine"}
+	for i := int64(1); i <= 201; i++ {
+		object := testObject(i, fmt.Sprintf("Object%d", i))
+		trace.RecordStateEntry(runtime.TraceOrigin{At: 0, Object: object, Behavior: behavior},
+			fmt.Sprintf("state%d", i), fmt.Sprintf("state%d", i), "", false)
+	}
+
+	rendering := Timeline(trace, Options{Until: 1, Limit: 200})
+	total := 0
+	for _, lane := range rendering.Lanes {
+		total += len(lane.Spans)
+	}
+	if total != 200 {
+		t.Fatalf("retained %d spans, want exactly 200", total)
+	}
+	for i := 0; i < 200; i++ {
+		lane := rendering.Lanes[i]
+		if lane.Name != fmt.Sprintf("#%d.Machine", i+1) || len(lane.Spans) != 1 ||
+			lane.Spans[0].State != fmt.Sprintf("state%d", i+1) {
+			t.Errorf("retained lane %d = %+v, want the corresponding first stable span", i, lane)
+		}
+	}
+	if len(rendering.Notices) == 0 ||
+		rendering.Notices[len(rendering.Notices)-1] != "1 later state change from t = 0 is not drawn (at most 200 spans are)" {
+		t.Fatalf("cap notice = %v", rendering.Notices)
+	}
+}
+
+func TestTimelineCapDoesNotExtendAcrossInactiveGap(t *testing.T) {
+	rendering := &view.Rendering{Lanes: []view.Lane{{
+		Spans: []view.Span{
+			{State: "finished", From: 0, To: 1, Open: true},
+			{State: "later", From: 4, To: 5},
+		},
+	}}}
+
+	applyTimelineLimit(rendering, 1)
+
+	if len(rendering.Lanes[0].Spans) != 1 {
+		t.Fatalf("spans = %+v, want one retained span", rendering.Lanes[0].Spans)
+	}
+	if span := rendering.Lanes[0].Spans[0]; span.To != 1 || span.Open {
+		t.Errorf("last kept span = %+v, want its original end 1 and closed", span)
+	}
+}
+
+func TestTimelineClosesTerminatedMachineAtTermination(t *testing.T) {
+	trace, options, _, _ := fixtureRun(t, "termination.sysml", "mission", 10)
+	rendering := Timeline(trace, options)
+	var terminatedLane *view.Lane
+	for i := range rendering.Lanes {
+		if strings.Contains(rendering.Lanes[i].Name, "Stopper.modes") {
+			terminatedLane = &rendering.Lanes[i]
+			break
+		}
+	}
+	if terminatedLane == nil {
+		t.Fatalf("no stopper lane in %+v", rendering.Lanes)
+	}
+	if len(terminatedLane.Spans) != 1 {
+		t.Fatalf("stopper spans = %+v, want one span ending at termination", terminatedLane.Spans)
+	}
+	span := terminatedLane.Spans[0]
+	if span.From != 0 || span.To != 2 || span.Open {
+		t.Errorf("stopper span = %+v, want a closed span from 0 to 2", span)
+	}
+	for _, mark := range terminatedLane.Marks {
+		if mark.Kind == "terminate" && mark.At == 2 &&
+			mark.Text == "terminated with occurrence: modes (do behavior abandoned: waiting)" {
+			return
+		}
+	}
+	t.Errorf("stopper marks = %+v, want a terminate mark at 2", terminatedLane.Marks)
+}
+
+func TestSequencePairsMessagesAndKeepsUnmatchedEndpoints(t *testing.T) {
+	trace := runtime.NewEventRecorder(0)
+	sender := testObject(1, "Sender")
+	receiver := testObject(2, "Receiver")
+	other := testObject(3, "Other")
+	trace.RecordSend(runtime.TraceOrigin{At: 0, Object: sender}, runtime.Message{
+		SignalType: "Ping", Payload: map[string]runtime.Value{"z": runtime.NewStringValue("last"), "a": runtime.NewStringValue("first")},
+	}, receiver)
+	trace.RecordSend(runtime.TraceOrigin{At: 0.5, Object: sender}, runtime.Message{SignalType: "Ping"}, other)
+	trace.RecordAccept(runtime.TraceOrigin{At: 1, Object: other}, 0, "Ping", nil)
+	trace.RecordAccept(runtime.TraceOrigin{At: 2, Object: receiver}, 0, "Ping", nil)
+	trace.RecordSend(runtime.TraceOrigin{At: 3, Object: other}, runtime.Message{SignalType: "Notice"}, receiver)
+	trace.RecordSend(runtime.TraceOrigin{At: 4}, runtime.Message{SignalType: "Broadcast"}, other)
+	trace.RecordAccept(runtime.TraceOrigin{At: 5, Object: receiver}, 0, "Pong", nil)
+	rendering := Sequence(trace, Options{
+		Until: 6,
+		Label: func(instance *runtime.Instance) string { return instance.Type.Name },
+	})
+	if !rendering.Run || rendering.Kind != view.KindSequence || len(rendering.Edges) != 5 {
+		t.Fatalf("sequence = %+v", rendering)
+	}
+	wantLabels := []string{
+		`t=0..2 Ping (a = "first", z = "last")`,
+		"t=0.5..1 Ping",
+		"t=3 Notice (not accepted)",
+		"t=4 Broadcast (not accepted)",
+		"t=5 Pong",
+	}
+	for i, want := range wantLabels {
+		edge := rendering.Edges[i]
+		if edge.Kind != view.EdgeFlow || edge.Label != want {
+			t.Errorf("edge %d = %+v, want label %q", i, edge, want)
+		}
+	}
+	if rendering.Edges[0].From != "n0" || rendering.Edges[0].To != "n1" ||
+		rendering.Edges[1].From != "n0" || rendering.Edges[1].To != "n2" {
+		t.Errorf("paired endpoints = %+v", rendering.Edges[:2])
+	}
+	if rendering.Edges[2].To != "n1" || rendering.Edges[3].From != "n3" ||
+		rendering.Edges[3].To != "n2" || rendering.Edges[4].From != "n3" {
+		t.Errorf("unmatched endpoints = %+v", rendering.Edges[2:])
+	}
+	if len(rendering.Roots) != 4 ||
+		rendering.Roots[0].Kind != "object" || rendering.Roots[0].Name != "Sender" || rendering.Roots[0].Type != "Sender" ||
+		rendering.Roots[3].Kind != "environment" || rendering.Roots[3].Name != "environment" {
+		t.Errorf("participants = %+v", rendering.Roots)
+	}
+}
+
+func TestSequencePairsNonzeroSerialsAndRetainsLegacyPairing(t *testing.T) {
+	trace := runtime.NewEventRecorder(0)
+	alpha, alphaBehavior := traceObject(1, "Alpha")
+	beta, betaBehavior := traceObject(2, "Beta")
+	legacy, legacyBehavior := traceObject(3, "Legacy")
+	receiver, receiverBehavior := traceObject(4, "Receiver")
+	trace.RecordSend(traceOrigin(0, alpha, alphaBehavior), runtime.Message{
+		Serial: 11, SignalType: "Ping", Payload: map[string]runtime.Value{"seq": runtime.NewStringValue("one")},
+	}, receiver)
+	trace.RecordSend(traceOrigin(0.5, beta, betaBehavior), runtime.Message{
+		Serial: 12, SignalType: "Ping", Payload: map[string]runtime.Value{"seq": runtime.NewStringValue("two")},
+	}, receiver)
+	trace.RecordSend(traceOrigin(1, legacy, legacyBehavior), runtime.Message{
+		SignalType: "Ping", Payload: map[string]runtime.Value{"seq": runtime.NewStringValue("three")},
+	}, receiver)
+	trace.RecordAccept(traceOrigin(2, receiver, receiverBehavior), 12, "Ping", nil)
+	trace.RecordAccept(traceOrigin(3, receiver, receiverBehavior), 0, "Ping", nil)
+
+	rendering := Sequence(trace, Options{
+		Until: 4,
+		Label: func(instance *runtime.Instance) string { return instance.Type.Name },
+	})
+	if len(rendering.Edges) != 3 {
+		t.Fatalf("edges = %+v, want the two sends and one serial-zero send", rendering.Edges)
+	}
+	if !strings.Contains(rendering.Edges[0].Label, `seq = "one"`) || !strings.Contains(rendering.Edges[0].Label, "not accepted") {
+		t.Errorf("earlier same-event send = %+v, want unmatched Alpha message", rendering.Edges[0])
+	}
+	if !strings.Contains(rendering.Edges[1].Label, `seq = "two"`) || strings.Contains(rendering.Edges[1].Label, "not accepted") ||
+		rendering.Edges[1].From != "n2" {
+		t.Errorf("matching serial send = %+v, want the Beta message accepted", rendering.Edges[1])
+	}
+	if !strings.Contains(rendering.Edges[2].Label, `seq = "three"`) || strings.Contains(rendering.Edges[2].Label, "not accepted") ||
+		rendering.Edges[2].From != "n3" {
+		t.Errorf("serial-zero send = %+v, want legacy event/target pairing", rendering.Edges[2])
+	}
+}
+
+func TestSequenceUsesAcceptedBetaMessageIdentityEndToEnd(t *testing.T) {
+	trace, options, ctx, mission := fixtureRun(t, "serial-pairing.sysml", "mission", 2)
+	labels := make(map[int64]string)
+	for _, name := range []string{"alpha", "beta", "receiver"} {
+		value, err := mission.GetFeatureValue(ctx, name)
+		if err != nil {
+			t.Fatal(err)
+		}
+		id, ok := value.HeldValue().Object()
+		if !ok {
+			t.Fatalf("mission.%s does not hold an object", name)
+		}
+		labels[id] = "SerialPairing::mission." + name
+	}
+	options.Label = func(instance *runtime.Instance) string { return labels[instance.ID] }
+	rendering := Sequence(trace, options)
+	rootNames := make(map[string]string, len(rendering.Roots))
+	for _, root := range rendering.Roots {
+		rootNames[root.ID] = root.Name
+	}
+	alphaUnmatched, betaAccepted := false, false
+	for _, edge := range rendering.Edges {
+		switch {
+		case strings.Contains(edge.Label, "seq = 1"):
+			alphaUnmatched = rootNames[edge.From] == "SerialPairing::mission.alpha" &&
+				strings.Contains(edge.Label, "not accepted")
+		case strings.Contains(edge.Label, "seq = 2"):
+			betaAccepted = rootNames[edge.From] == "SerialPairing::mission.beta" &&
+				!strings.Contains(edge.Label, "not accepted")
+		}
+	}
+	if !alphaUnmatched || !betaAccepted {
+		t.Fatalf("sequence edges = %+v, roots = %+v; want Alpha unmatched and Beta's payload accepted",
+			rendering.Edges, rendering.Roots)
+	}
+	artifact, err := rendering.WriteWith(view.FormText, view.Options{})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if text := string(artifact); !strings.Contains(text, "SerialPairing::mission.beta") ||
+		!strings.Contains(text, "seq = 2") {
+		t.Errorf("sequence diagram does not identify Beta and its payload:\n%s", text)
+	}
+}
+
+func TestSequenceCapsMessagesAndReportsDroppedRecords(t *testing.T) {
+	object := testObject(1, "Sender")
+	trace := runtime.NewEventRecorder(0)
+	for i := 0; i < 5; i++ {
+		trace.RecordSend(runtime.TraceOrigin{At: float64(i), Object: object},
+			runtime.Message{SignalType: "Ping"}, nil)
+	}
+	rendering := Sequence(trace, Options{Until: 5, Limit: 2})
+	if len(rendering.Edges) != 2 {
+		t.Fatalf("edges = %d, want 2", len(rendering.Edges))
+	}
+	notices := strings.Join(rendering.Notices, "\n")
+	if !strings.Contains(notices, "3 later messages, t = 2 to 4, are not drawn (at most 2 are)") {
+		t.Errorf("message cap notice = %s", notices)
+	}
+	equalInstants := runtime.NewEventRecorder(0)
+	for i := 0; i < 4; i++ {
+		equalInstants.RecordSend(runtime.TraceOrigin{At: 2, Object: object},
+			runtime.Message{SignalType: "Ping"}, nil)
+	}
+	equal := Sequence(equalInstants, Options{Until: 3, Limit: 2})
+	if got := strings.Join(equal.Notices, "\n"); !strings.Contains(got,
+		"2 later messages, at t = 2, are not drawn (at most 2 are)") {
+		t.Errorf("equal-instant cap notice = %s", got)
+	}
+	truncated := runtime.NewEventRecorder(3)
+	for i := 0; i < 5; i++ {
+		truncated.RecordSend(runtime.TraceOrigin{At: float64(i), Object: object},
+			runtime.Message{SignalType: "Ping"}, nil)
+	}
+	truncatedRendering := Sequence(truncated, Options{Until: 5})
+	truncatedNotices := strings.Join(truncatedRendering.Notices, "\n")
+	if !strings.Contains(truncatedNotices, "2 earlier records up to t = 1 were dropped") ||
+		!strings.Contains(truncatedNotices, "senders or acceptors of earlier messages may be missing") {
+		t.Errorf("truncation notice = %s", truncatedNotices)
+	}
+}
+
+func testObject(id int64, typeName string) *runtime.Instance {
+	return &runtime.Instance{ID: id, Type: &symbols.Symbol{Name: typeName}}
+}
diff --git a/internal/exec/runtrace/sequence.go b/internal/exec/runtrace/sequence.go
new file mode 100644
index 0000000000..635438f9ca
--- /dev/null
+++ b/internal/exec/runtrace/sequence.go
@@ -0,0 +1,244 @@
+package runtrace
+
+import (
+	"fmt"
+	"sort"
+	"strings"
+
+	"github.com/Open-MBEE/OpenSysML/internal/exec/runtime"
+	"github.com/Open-MBEE/OpenSysML/internal/ir/view"
+	"github.com/Open-MBEE/OpenSysML/internal/semantic/symbols"
+)
+
+type sendRef struct {
+	index  int
+	record runtime.TraceRecord
+	target int64
+	used   bool
+}
+
+type sendQueue struct {
+	items  []*sendRef
+	cursor int
+}
+
+type runMessage struct {
+	at    float64
+	index int
+	from  participant
+	to    participant
+	label string
+}
+
+type participant struct {
+	object   *runtime.Instance
+	behavior *symbols.Symbol
+}
+
+type participantKey struct {
+	object   int64
+	behavior *symbols.Symbol
+	ambient  bool
+}
+
+type participantSet struct {
+	ids     map[participantKey]string
+	roots   []*view.Node
+	labelFn func(*runtime.Instance) string
+}
+
+func sequence(trace *runtime.TraceRecorder, options Options) *view.Rendering {
+	out := runRendering(view.KindSequence, options)
+	if trace == nil {
+		return out
+	}
+	records := trace.Records()
+	queues := make(map[string]map[int64]*sendQueue)
+	bySerial := make(map[uint64]*sendRef)
+	var sends []*sendRef
+	var messages []runMessage
+	for index, record := range records {
+		switch record.Kind {
+		case runtime.TraceSend:
+			target := int64(0)
+			if record.Target != nil {
+				target = record.Target.ID
+			}
+			ref := &sendRef{index: index, record: record, target: target}
+			sends = append(sends, ref)
+			if record.Message != 0 {
+				bySerial[record.Message] = ref
+				continue
+			}
+			if queues[record.Event] == nil {
+				queues[record.Event] = make(map[int64]*sendQueue)
+			}
+			queue := queues[record.Event][target]
+			if queue == nil {
+				queue = &sendQueue{}
+				queues[record.Event][target] = queue
+			}
+			queue.items = append(queue.items, ref)
+		case runtime.TraceAccept:
+			var paired *sendRef
+			objectID := int64(0)
+			if record.Origin.Object != nil {
+				objectID = record.Origin.Object.ID
+			}
+			if record.Message != 0 {
+				paired = bySerial[record.Message]
+				if paired != nil && paired.used {
+					paired = nil
+				}
+				if paired != nil {
+					paired.used = true
+				}
+			} else if byTarget := queues[record.Event]; byTarget != nil {
+				broadcast := byTarget[0]
+				targeted := byTarget[objectID]
+				paired = earliestSend(broadcast, targeted)
+				if paired != nil {
+					paired.used = true
+					consumeSend(paired, broadcast, targeted)
+				}
+			}
+			if paired == nil {
+				messages = append(messages, runMessage{
+					at: record.Origin.At, index: index,
+					from: participant{}, to: participant{object: record.Origin.Object, behavior: record.Origin.Behavior},
+					label: messageLabel(record.Origin.At, 0, record.Event, record.PayloadTexts(), false, false),
+				})
+				continue
+			}
+			payload := paired.record.PayloadTexts()
+			messages = append(messages, runMessage{
+				at: paired.record.Origin.At, index: paired.index,
+				from:  participant{object: paired.record.Origin.Object, behavior: paired.record.Origin.Behavior},
+				to:    participant{object: record.Origin.Object, behavior: record.Origin.Behavior},
+				label: messageLabel(paired.record.Origin.At, record.Origin.At, paired.record.Event, payload, true, false),
+			})
+		}
+	}
+	for _, send := range sends {
+		if send.used {
+			continue
+		}
+		to := participant{}
+		if send.record.Target != nil {
+			to.object = send.record.Target
+		}
+		messages = append(messages, runMessage{
+			at: send.record.Origin.At, index: send.index,
+			from:  participant{object: send.record.Origin.Object, behavior: send.record.Origin.Behavior},
+			to:    to,
+			label: messageLabel(send.record.Origin.At, 0, send.record.Event, send.record.PayloadTexts(), false, true),
+		})
+	}
+	sort.SliceStable(messages, func(i, j int) bool {
+		if messages[i].at != messages[j].at {
+			return messages[i].at < messages[j].at
+		}
+		return messages[i].index < messages[j].index
+	})
+	limit := effectiveLimit(options.Limit)
+	if len(messages) > limit {
+		later := messages[limit:]
+		verb := "are"
+		if len(later) == 1 {
+			verb = "is"
+		}
+		first, last := runInstant(later[0].at), runInstant(later[len(later)-1].at)
+		if first == last {
+			out.Notices = append(out.Notices, fmt.Sprintf("%d later %s, at t = %s, %s not drawn (at most %d are)",
+				len(later), plural(len(later), "message", "messages"), first, verb, limit))
+		} else {
+			out.Notices = append(out.Notices, fmt.Sprintf("%d later %s, t = %s to %s, %s not drawn (at most %d are)",
+				len(later), plural(len(later), "message", "messages"), first, last, verb, limit))
+		}
+		messages = messages[:limit]
+	}
+	if count, upTo := trace.Dropped(); count > 0 {
+		out.Notices = append(out.Notices, fmt.Sprintf("%d earlier records up to t = %s were dropped; senders or acceptors of earlier messages may be missing",
+			count, runInstant(upTo)))
+	}
+	participants := participantSet{ids: make(map[participantKey]string), labelFn: options.Label}
+	for _, message := range messages {
+		from := participants.add(message.from)
+		to := participants.add(message.to)
+		out.Edges = append(out.Edges, view.Edge{From: from, To: to, Kind: view.EdgeFlow, Label: message.label})
+	}
+	out.Roots = participants.roots
+	return out
+}
+
+func earliestSend(first, second *sendQueue) *sendRef {
+	var a, b *sendRef
+	if first != nil && first.cursor < len(first.items) {
+		a = first.items[first.cursor]
+	}
+	if second != nil && second.cursor < len(second.items) {
+		b = second.items[second.cursor]
+	}
+	if a == nil {
+		return b
+	}
+	if b == nil || a.index < b.index {
+		return a
+	}
+	return b
+}
+
+func consumeSend(send *sendRef, first, second *sendQueue) {
+	if first != nil && first.cursor < len(first.items) && first.items[first.cursor] == send {
+		first.cursor++
+		return
+	}
+	if second != nil && second.cursor < len(second.items) && second.items[second.cursor] == send {
+		second.cursor++
+	}
+}
+
+func messageLabel(at, acceptedAt float64, event string, payload []string, accepted, unmatched bool) string {
+	time := runInstant(at)
+	if accepted && acceptedAt > at {
+		time += ".." + runInstant(acceptedAt)
+	}
+	label := "t=" + time + " " + event
+	if len(payload) > 0 {
+		label += " (" + strings.Join(payload, ", ") + ")"
+	}
+	if unmatched {
+		label += " (not accepted)"
+	}
+	return label
+}
+
+func (set *participantSet) add(participant participant) string {
+	key := participantKey{}
+	node := &view.Node{}
+	switch {
+	case participant.object != nil:
+		key.object = participant.object.ID
+		node.Kind = "object"
+		node.Name = instanceName(participant.object, set.labelFn)
+		if participant.object.Type != nil {
+			node.Type = participant.object.Type.Name
+			node.Origin = participant.object.Type.Origin()
+		}
+	case participant.behavior != nil:
+		key.behavior = participant.behavior
+		node.Kind = "behavior"
+		node.Name = participant.behavior.Name
+	default:
+		key.ambient = true
+		node.Kind = "environment"
+		node.Name = "environment"
+	}
+	if id, ok := set.ids[key]; ok {
+		return id
+	}
+	node.ID = fmt.Sprintf("n%d", len(set.roots))
+	set.ids[key] = node.ID
+	set.roots = append(set.roots, node)
+	return node.ID
+}
diff --git a/internal/exec/runtrace/testdata/capped-sequence.text.golden b/internal/exec/runtrace/testdata/capped-sequence.text.golden
new file mode 100644
index 0000000000..2a773b0a6d
--- /dev/null
+++ b/internal/exec/runtrace/testdata/capped-sequence.text.golden
@@ -0,0 +1,209 @@
+run - sequence rendering (the trace of a run to t = 201)
+
+object #1 : sender
+object #2 : receiver
+
+messages:
+  #1 => #2: t=0 Ping
+  #1 => #2: t=1 Ping
+  #1 => #2: t=2 Ping
+  #1 => #2: t=3 Ping
+  #1 => #2: t=4 Ping
+  #1 => #2: t=5 Ping
+  #1 => #2: t=6 Ping
+  #1 => #2: t=7 Ping
+  #1 => #2: t=8 Ping
+  #1 => #2: t=9 Ping
+  #1 => #2: t=10 Ping
+  #1 => #2: t=11 Ping
+  #1 => #2: t=12 Ping
+  #1 => #2: t=13 Ping
+  #1 => #2: t=14 Ping
+  #1 => #2: t=15 Ping
+  #1 => #2: t=16 Ping
+  #1 => #2: t=17 Ping
+  #1 => #2: t=18 Ping
+  #1 => #2: t=19 Ping
+  #1 => #2: t=20 Ping
+  #1 => #2: t=21 Ping
+  #1 => #2: t=22 Ping
+  #1 => #2: t=23 Ping
+  #1 => #2: t=24 Ping
+  #1 => #2: t=25 Ping
+  #1 => #2: t=26 Ping
+  #1 => #2: t=27 Ping
+  #1 => #2: t=28 Ping
+  #1 => #2: t=29 Ping
+  #1 => #2: t=30 Ping
+  #1 => #2: t=31 Ping
+  #1 => #2: t=32 Ping
+  #1 => #2: t=33 Ping
+  #1 => #2: t=34 Ping
+  #1 => #2: t=35 Ping
+  #1 => #2: t=36 Ping
+  #1 => #2: t=37 Ping
+  #1 => #2: t=38 Ping
+  #1 => #2: t=39 Ping
+  #1 => #2: t=40 Ping
+  #1 => #2: t=41 Ping
+  #1 => #2: t=42 Ping
+  #1 => #2: t=43 Ping
+  #1 => #2: t=44 Ping
+  #1 => #2: t=45 Ping
+  #1 => #2: t=46 Ping
+  #1 => #2: t=47 Ping
+  #1 => #2: t=48 Ping
+  #1 => #2: t=49 Ping
+  #1 => #2: t=50 Ping
+  #1 => #2: t=51 Ping
+  #1 => #2: t=52 Ping
+  #1 => #2: t=53 Ping
+  #1 => #2: t=54 Ping
+  #1 => #2: t=55 Ping
+  #1 => #2: t=56 Ping
+  #1 => #2: t=57 Ping
+  #1 => #2: t=58 Ping
+  #1 => #2: t=59 Ping
+  #1 => #2: t=60 Ping
+  #1 => #2: t=61 Ping
+  #1 => #2: t=62 Ping
+  #1 => #2: t=63 Ping
+  #1 => #2: t=64 Ping
+  #1 => #2: t=65 Ping
+  #1 => #2: t=66 Ping
+  #1 => #2: t=67 Ping
+  #1 => #2: t=68 Ping
+  #1 => #2: t=69 Ping
+  #1 => #2: t=70 Ping
+  #1 => #2: t=71 Ping
+  #1 => #2: t=72 Ping
+  #1 => #2: t=73 Ping
+  #1 => #2: t=74 Ping
+  #1 => #2: t=75 Ping
+  #1 => #2: t=76 Ping
+  #1 => #2: t=77 Ping
+  #1 => #2: t=78 Ping
+  #1 => #2: t=79 Ping
+  #1 => #2: t=80 Ping
+  #1 => #2: t=81 Ping
+  #1 => #2: t=82 Ping
+  #1 => #2: t=83 Ping
+  #1 => #2: t=84 Ping
+  #1 => #2: t=85 Ping
+  #1 => #2: t=86 Ping
+  #1 => #2: t=87 Ping
+  #1 => #2: t=88 Ping
+  #1 => #2: t=89 Ping
+  #1 => #2: t=90 Ping
+  #1 => #2: t=91 Ping
+  #1 => #2: t=92 Ping
+  #1 => #2: t=93 Ping
+  #1 => #2: t=94 Ping
+  #1 => #2: t=95 Ping
+  #1 => #2: t=96 Ping
+  #1 => #2: t=97 Ping
+  #1 => #2: t=98 Ping
+  #1 => #2: t=99 Ping
+  #1 => #2: t=100 Ping
+  #1 => #2: t=101 Ping
+  #1 => #2: t=102 Ping
+  #1 => #2: t=103 Ping
+  #1 => #2: t=104 Ping
+  #1 => #2: t=105 Ping
+  #1 => #2: t=106 Ping
+  #1 => #2: t=107 Ping
+  #1 => #2: t=108 Ping
+  #1 => #2: t=109 Ping
+  #1 => #2: t=110 Ping
+  #1 => #2: t=111 Ping
+  #1 => #2: t=112 Ping
+  #1 => #2: t=113 Ping
+  #1 => #2: t=114 Ping
+  #1 => #2: t=115 Ping
+  #1 => #2: t=116 Ping
+  #1 => #2: t=117 Ping
+  #1 => #2: t=118 Ping
+  #1 => #2: t=119 Ping
+  #1 => #2: t=120 Ping
+  #1 => #2: t=121 Ping
+  #1 => #2: t=122 Ping
+  #1 => #2: t=123 Ping
+  #1 => #2: t=124 Ping
+  #1 => #2: t=125 Ping
+  #1 => #2: t=126 Ping
+  #1 => #2: t=127 Ping
+  #1 => #2: t=128 Ping
+  #1 => #2: t=129 Ping
+  #1 => #2: t=130 Ping
+  #1 => #2: t=131 Ping
+  #1 => #2: t=132 Ping
+  #1 => #2: t=133 Ping
+  #1 => #2: t=134 Ping
+  #1 => #2: t=135 Ping
+  #1 => #2: t=136 Ping
+  #1 => #2: t=137 Ping
+  #1 => #2: t=138 Ping
+  #1 => #2: t=139 Ping
+  #1 => #2: t=140 Ping
+  #1 => #2: t=141 Ping
+  #1 => #2: t=142 Ping
+  #1 => #2: t=143 Ping
+  #1 => #2: t=144 Ping
+  #1 => #2: t=145 Ping
+  #1 => #2: t=146 Ping
+  #1 => #2: t=147 Ping
+  #1 => #2: t=148 Ping
+  #1 => #2: t=149 Ping
+  #1 => #2: t=150 Ping
+  #1 => #2: t=151 Ping
+  #1 => #2: t=152 Ping
+  #1 => #2: t=153 Ping
+  #1 => #2: t=154 Ping
+  #1 => #2: t=155 Ping
+  #1 => #2: t=156 Ping
+  #1 => #2: t=157 Ping
+  #1 => #2: t=158 Ping
+  #1 => #2: t=159 Ping
+  #1 => #2: t=160 Ping
+  #1 => #2: t=161 Ping
+  #1 => #2: t=162 Ping
+  #1 => #2: t=163 Ping
+  #1 => #2: t=164 Ping
+  #1 => #2: t=165 Ping
+  #1 => #2: t=166 Ping
+  #1 => #2: t=167 Ping
+  #1 => #2: t=168 Ping
+  #1 => #2: t=169 Ping
+  #1 => #2: t=170 Ping
+  #1 => #2: t=171 Ping
+  #1 => #2: t=172 Ping
+  #1 => #2: t=173 Ping
+  #1 => #2: t=174 Ping
+  #1 => #2: t=175 Ping
+  #1 => #2: t=176 Ping
+  #1 => #2: t=177 Ping
+  #1 => #2: t=178 Ping
+  #1 => #2: t=179 Ping
+  #1 => #2: t=180 Ping
+  #1 => #2: t=181 Ping
+  #1 => #2: t=182 Ping
+  #1 => #2: t=183 Ping
+  #1 => #2: t=184 Ping
+  #1 => #2: t=185 Ping
+  #1 => #2: t=186 Ping
+  #1 => #2: t=187 Ping
+  #1 => #2: t=188 Ping
+  #1 => #2: t=189 Ping
+  #1 => #2: t=190 Ping
+  #1 => #2: t=191 Ping
+  #1 => #2: t=192 Ping
+  #1 => #2: t=193 Ping
+  #1 => #2: t=194 Ping
+  #1 => #2: t=195 Ping
+  #1 => #2: t=196 Ping
+  #1 => #2: t=197 Ping
+  #1 => #2: t=198 Ping
+  #1 => #2: t=199 Ping
+
+not represented:
+  - 1 later message, at t = 200, is not drawn (at most 200 are)
diff --git a/internal/exec/runtrace/testdata/capped-timeline.text.golden b/internal/exec/runtrace/testdata/capped-timeline.text.golden
new file mode 100644
index 0000000000..20e91dde38
--- /dev/null
+++ b/internal/exec/runtrace/testdata/capped-timeline.text.golden
@@ -0,0 +1,407 @@
+run - timeline rendering (the trace of a run to t = 201)
+
+#1.modes
+  0 .. 1      s0
+  1 .. 2      s1 (tick)
+  2 .. 3      s2 (tick)
+  3 .. 4      s3 (tick)
+  4 .. 5      s4 (tick)
+  5 .. 6      s5 (tick)
+  6 .. 7      s6 (tick)
+  7 .. 8      s7 (tick)
+  8 .. 9      s8 (tick)
+  9 .. 10     s9 (tick)
+  10 .. 11    s10 (tick)
+  11 .. 12    s11 (tick)
+  12 .. 13    s12 (tick)
+  13 .. 14    s13 (tick)
+  14 .. 15    s14 (tick)
+  15 .. 16    s15 (tick)
+  16 .. 17    s16 (tick)
+  17 .. 18    s17 (tick)
+  18 .. 19    s18 (tick)
+  19 .. 20    s19 (tick)
+  20 .. 21    s20 (tick)
+  21 .. 22    s21 (tick)
+  22 .. 23    s22 (tick)
+  23 .. 24    s23 (tick)
+  24 .. 25    s24 (tick)
+  25 .. 26    s25 (tick)
+  26 .. 27    s26 (tick)
+  27 .. 28    s27 (tick)
+  28 .. 29    s28 (tick)
+  29 .. 30    s29 (tick)
+  30 .. 31    s30 (tick)
+  31 .. 32    s31 (tick)
+  32 .. 33    s32 (tick)
+  33 .. 34    s33 (tick)
+  34 .. 35    s34 (tick)
+  35 .. 36    s35 (tick)
+  36 .. 37    s36 (tick)
+  37 .. 38    s37 (tick)
+  38 .. 39    s38 (tick)
+  39 .. 40    s39 (tick)
+  40 .. 41    s40 (tick)
+  41 .. 42    s41 (tick)
+  42 .. 43    s42 (tick)
+  43 .. 44    s43 (tick)
+  44 .. 45    s44 (tick)
+  45 .. 46    s45 (tick)
+  46 .. 47    s46 (tick)
+  47 .. 48    s47 (tick)
+  48 .. 49    s48 (tick)
+  49 .. 50    s49 (tick)
+  50 .. 51    s50 (tick)
+  51 .. 52    s51 (tick)
+  52 .. 53    s52 (tick)
+  53 .. 54    s53 (tick)
+  54 .. 55    s54 (tick)
+  55 .. 56    s55 (tick)
+  56 .. 57    s56 (tick)
+  57 .. 58    s57 (tick)
+  58 .. 59    s58 (tick)
+  59 .. 60    s59 (tick)
+  60 .. 61    s60 (tick)
+  61 .. 62    s61 (tick)
+  62 .. 63    s62 (tick)
+  63 .. 64    s63 (tick)
+  64 .. 65    s64 (tick)
+  65 .. 66    s65 (tick)
+  66 .. 67    s66 (tick)
+  67 .. 68    s67 (tick)
+  68 .. 69    s68 (tick)
+  69 .. 70    s69 (tick)
+  70 .. 71    s70 (tick)
+  71 .. 72    s71 (tick)
+  72 .. 73    s72 (tick)
+  73 .. 74    s73 (tick)
+  74 .. 75    s74 (tick)
+  75 .. 76    s75 (tick)
+  76 .. 77    s76 (tick)
+  77 .. 78    s77 (tick)
+  78 .. 79    s78 (tick)
+  79 .. 80    s79 (tick)
+  80 .. 81    s80 (tick)
+  81 .. 82    s81 (tick)
+  82 .. 83    s82 (tick)
+  83 .. 84    s83 (tick)
+  84 .. 85    s84 (tick)
+  85 .. 86    s85 (tick)
+  86 .. 87    s86 (tick)
+  87 .. 88    s87 (tick)
+  88 .. 89    s88 (tick)
+  89 .. 90    s89 (tick)
+  90 .. 91    s90 (tick)
+  91 .. 92    s91 (tick)
+  92 .. 93    s92 (tick)
+  93 .. 94    s93 (tick)
+  94 .. 95    s94 (tick)
+  95 .. 96    s95 (tick)
+  96 .. 97    s96 (tick)
+  97 .. 98    s97 (tick)
+  98 .. 99    s98 (tick)
+  99 .. 100   s99 (tick)
+  100 .. 101  s100 (tick)
+  101 .. 102  s101 (tick)
+  102 .. 103  s102 (tick)
+  103 .. 104  s103 (tick)
+  104 .. 105  s104 (tick)
+  105 .. 106  s105 (tick)
+  106 .. 107  s106 (tick)
+  107 .. 108  s107 (tick)
+  108 .. 109  s108 (tick)
+  109 .. 110  s109 (tick)
+  110 .. 111  s110 (tick)
+  111 .. 112  s111 (tick)
+  112 .. 113  s112 (tick)
+  113 .. 114  s113 (tick)
+  114 .. 115  s114 (tick)
+  115 .. 116  s115 (tick)
+  116 .. 117  s116 (tick)
+  117 .. 118  s117 (tick)
+  118 .. 119  s118 (tick)
+  119 .. 120  s119 (tick)
+  120 .. 121  s120 (tick)
+  121 .. 122  s121 (tick)
+  122 .. 123  s122 (tick)
+  123 .. 124  s123 (tick)
+  124 .. 125  s124 (tick)
+  125 .. 126  s125 (tick)
+  126 .. 127  s126 (tick)
+  127 .. 128  s127 (tick)
+  128 .. 129  s128 (tick)
+  129 .. 130  s129 (tick)
+  130 .. 131  s130 (tick)
+  131 .. 132  s131 (tick)
+  132 .. 133  s132 (tick)
+  133 .. 134  s133 (tick)
+  134 .. 135  s134 (tick)
+  135 .. 136  s135 (tick)
+  136 .. 137  s136 (tick)
+  137 .. 138  s137 (tick)
+  138 .. 139  s138 (tick)
+  139 .. 140  s139 (tick)
+  140 .. 141  s140 (tick)
+  141 .. 142  s141 (tick)
+  142 .. 143  s142 (tick)
+  143 .. 144  s143 (tick)
+  144 .. 145  s144 (tick)
+  145 .. 146  s145 (tick)
+  146 .. 147  s146 (tick)
+  147 .. 148  s147 (tick)
+  148 .. 149  s148 (tick)
+  149 .. 150  s149 (tick)
+  150 .. 151  s150 (tick)
+  151 .. 152  s151 (tick)
+  152 .. 153  s152 (tick)
+  153 .. 154  s153 (tick)
+  154 .. 155  s154 (tick)
+  155 .. 156  s155 (tick)
+  156 .. 157  s156 (tick)
+  157 .. 158  s157 (tick)
+  158 .. 159  s158 (tick)
+  159 .. 160  s159 (tick)
+  160 .. 161  s160 (tick)
+  161 .. 162  s161 (tick)
+  162 .. 163  s162 (tick)
+  163 .. 164  s163 (tick)
+  164 .. 165  s164 (tick)
+  165 .. 166  s165 (tick)
+  166 .. 167  s166 (tick)
+  167 .. 168  s167 (tick)
+  168 .. 169  s168 (tick)
+  169 .. 170  s169 (tick)
+  170 .. 171  s170 (tick)
+  171 .. 172  s171 (tick)
+  172 .. 173  s172 (tick)
+  173 .. 174  s173 (tick)
+  174 .. 175  s174 (tick)
+  175 .. 176  s175 (tick)
+  176 .. 177  s176 (tick)
+  177 .. 178  s177 (tick)
+  178 .. 179  s178 (tick)
+  179 .. 180  s179 (tick)
+  180 .. 181  s180 (tick)
+  181 .. 182  s181 (tick)
+  182 .. 183  s182 (tick)
+  183 .. 184  s183 (tick)
+  184 .. 185  s184 (tick)
+  185 .. 186  s185 (tick)
+  186 .. 187  s186 (tick)
+  187 .. 188  s187 (tick)
+  188 .. 189  s188 (tick)
+  189 .. 190  s189 (tick)
+  190 .. 191  s190 (tick)
+  191 .. 192  s191 (tick)
+  192 .. 193  s192 (tick)
+  193 .. 194  s193 (tick)
+  194 .. 195  s194 (tick)
+  195 .. 196  s195 (tick)
+  196 .. 197  s196 (tick)
+  197 .. 198  s197 (tick)
+  198 .. 199  s198 (tick)
+  199 .. 200  s199 (tick)
+  transitions:
+    t=1 s0 -> s1 (tick)
+    t=2 s1 -> s2 (tick)
+    t=3 s2 -> s3 (tick)
+    t=4 s3 -> s4 (tick)
+    t=5 s4 -> s5 (tick)
+    t=6 s5 -> s6 (tick)
+    t=7 s6 -> s7 (tick)
+    t=8 s7 -> s8 (tick)
+    t=9 s8 -> s9 (tick)
+    t=10 s9 -> s10 (tick)
+    t=11 s10 -> s11 (tick)
+    t=12 s11 -> s12 (tick)
+    t=13 s12 -> s13 (tick)
+    t=14 s13 -> s14 (tick)
+    t=15 s14 -> s15 (tick)
+    t=16 s15 -> s16 (tick)
+    t=17 s16 -> s17 (tick)
+    t=18 s17 -> s18 (tick)
+    t=19 s18 -> s19 (tick)
+    t=20 s19 -> s20 (tick)
+    t=21 s20 -> s21 (tick)
+    t=22 s21 -> s22 (tick)
+    t=23 s22 -> s23 (tick)
+    t=24 s23 -> s24 (tick)
+    t=25 s24 -> s25 (tick)
+    t=26 s25 -> s26 (tick)
+    t=27 s26 -> s27 (tick)
+    t=28 s27 -> s28 (tick)
+    t=29 s28 -> s29 (tick)
+    t=30 s29 -> s30 (tick)
+    t=31 s30 -> s31 (tick)
+    t=32 s31 -> s32 (tick)
+    t=33 s32 -> s33 (tick)
+    t=34 s33 -> s34 (tick)
+    t=35 s34 -> s35 (tick)
+    t=36 s35 -> s36 (tick)
+    t=37 s36 -> s37 (tick)
+    t=38 s37 -> s38 (tick)
+    t=39 s38 -> s39 (tick)
+    t=40 s39 -> s40 (tick)
+    t=41 s40 -> s41 (tick)
+    t=42 s41 -> s42 (tick)
+    t=43 s42 -> s43 (tick)
+    t=44 s43 -> s44 (tick)
+    t=45 s44 -> s45 (tick)
+    t=46 s45 -> s46 (tick)
+    t=47 s46 -> s47 (tick)
+    t=48 s47 -> s48 (tick)
+    t=49 s48 -> s49 (tick)
+    t=50 s49 -> s50 (tick)
+    t=51 s50 -> s51 (tick)
+    t=52 s51 -> s52 (tick)
+    t=53 s52 -> s53 (tick)
+    t=54 s53 -> s54 (tick)
+    t=55 s54 -> s55 (tick)
+    t=56 s55 -> s56 (tick)
+    t=57 s56 -> s57 (tick)
+    t=58 s57 -> s58 (tick)
+    t=59 s58 -> s59 (tick)
+    t=60 s59 -> s60 (tick)
+    t=61 s60 -> s61 (tick)
+    t=62 s61 -> s62 (tick)
+    t=63 s62 -> s63 (tick)
+    t=64 s63 -> s64 (tick)
+    t=65 s64 -> s65 (tick)
+    t=66 s65 -> s66 (tick)
+    t=67 s66 -> s67 (tick)
+    t=68 s67 -> s68 (tick)
+    t=69 s68 -> s69 (tick)
+    t=70 s69 -> s70 (tick)
+    t=71 s70 -> s71 (tick)
+    t=72 s71 -> s72 (tick)
+    t=73 s72 -> s73 (tick)
+    t=74 s73 -> s74 (tick)
+    t=75 s74 -> s75 (tick)
+    t=76 s75 -> s76 (tick)
+    t=77 s76 -> s77 (tick)
+    t=78 s77 -> s78 (tick)
+    t=79 s78 -> s79 (tick)
+    t=80 s79 -> s80 (tick)
+    t=81 s80 -> s81 (tick)
+    t=82 s81 -> s82 (tick)
+    t=83 s82 -> s83 (tick)
+    t=84 s83 -> s84 (tick)
+    t=85 s84 -> s85 (tick)
+    t=86 s85 -> s86 (tick)
+    t=87 s86 -> s87 (tick)
+    t=88 s87 -> s88 (tick)
+    t=89 s88 -> s89 (tick)
+    t=90 s89 -> s90 (tick)
+    t=91 s90 -> s91 (tick)
+    t=92 s91 -> s92 (tick)
+    t=93 s92 -> s93 (tick)
+    t=94 s93 -> s94 (tick)
+    t=95 s94 -> s95 (tick)
+    t=96 s95 -> s96 (tick)
+    t=97 s96 -> s97 (tick)
+    t=98 s97 -> s98 (tick)
+    t=99 s98 -> s99 (tick)
+    t=100 s99 -> s100 (tick)
+    t=101 s100 -> s101 (tick)
+    t=102 s101 -> s102 (tick)
+    t=103 s102 -> s103 (tick)
+    t=104 s103 -> s104 (tick)
+    t=105 s104 -> s105 (tick)
+    t=106 s105 -> s106 (tick)
+    t=107 s106 -> s107 (tick)
+    t=108 s107 -> s108 (tick)
+    t=109 s108 -> s109 (tick)
+    t=110 s109 -> s110 (tick)
+    t=111 s110 -> s111 (tick)
+    t=112 s111 -> s112 (tick)
+    t=113 s112 -> s113 (tick)
+    t=114 s113 -> s114 (tick)
+    t=115 s114 -> s115 (tick)
+    t=116 s115 -> s116 (tick)
+    t=117 s116 -> s117 (tick)
+    t=118 s117 -> s118 (tick)
+    t=119 s118 -> s119 (tick)
+    t=120 s119 -> s120 (tick)
+    t=121 s120 -> s121 (tick)
+    t=122 s121 -> s122 (tick)
+    t=123 s122 -> s123 (tick)
+    t=124 s123 -> s124 (tick)
+    t=125 s124 -> s125 (tick)
+    t=126 s125 -> s126 (tick)
+    t=127 s126 -> s127 (tick)
+    t=128 s127 -> s128 (tick)
+    t=129 s128 -> s129 (tick)
+    t=130 s129 -> s130 (tick)
+    t=131 s130 -> s131 (tick)
+    t=132 s131 -> s132 (tick)
+    t=133 s132 -> s133 (tick)
+    t=134 s133 -> s134 (tick)
+    t=135 s134 -> s135 (tick)
+    t=136 s135 -> s136 (tick)
+    t=137 s136 -> s137 (tick)
+    t=138 s137 -> s138 (tick)
+    t=139 s138 -> s139 (tick)
+    t=140 s139 -> s140 (tick)
+    t=141 s140 -> s141 (tick)
+    t=142 s141 -> s142 (tick)
+    t=143 s142 -> s143 (tick)
+    t=144 s143 -> s144 (tick)
+    t=145 s144 -> s145 (tick)
+    t=146 s145 -> s146 (tick)
+    t=147 s146 -> s147 (tick)
+    t=148 s147 -> s148 (tick)
+    t=149 s148 -> s149 (tick)
+    t=150 s149 -> s150 (tick)
+    t=151 s150 -> s151 (tick)
+    t=152 s151 -> s152 (tick)
+    t=153 s152 -> s153 (tick)
+    t=154 s153 -> s154 (tick)
+    t=155 s154 -> s155 (tick)
+    t=156 s155 -> s156 (tick)
+    t=157 s156 -> s157 (tick)
+    t=158 s157 -> s158 (tick)
+    t=159 s158 -> s159 (tick)
+    t=160 s159 -> s160 (tick)
+    t=161 s160 -> s161 (tick)
+    t=162 s161 -> s162 (tick)
+    t=163 s162 -> s163 (tick)
+    t=164 s163 -> s164 (tick)
+    t=165 s164 -> s165 (tick)
+    t=166 s165 -> s166 (tick)
+    t=167 s166 -> s167 (tick)
+    t=168 s167 -> s168 (tick)
+    t=169 s168 -> s169 (tick)
+    t=170 s169 -> s170 (tick)
+    t=171 s170 -> s171 (tick)
+    t=172 s171 -> s172 (tick)
+    t=173 s172 -> s173 (tick)
+    t=174 s173 -> s174 (tick)
+    t=175 s174 -> s175 (tick)
+    t=176 s175 -> s176 (tick)
+    t=177 s176 -> s177 (tick)
+    t=178 s177 -> s178 (tick)
+    t=179 s178 -> s179 (tick)
+    t=180 s179 -> s180 (tick)
+    t=181 s180 -> s181 (tick)
+    t=182 s181 -> s182 (tick)
+    t=183 s182 -> s183 (tick)
+    t=184 s183 -> s184 (tick)
+    t=185 s184 -> s185 (tick)
+    t=186 s185 -> s186 (tick)
+    t=187 s186 -> s187 (tick)
+    t=188 s187 -> s188 (tick)
+    t=189 s188 -> s189 (tick)
+    t=190 s189 -> s190 (tick)
+    t=191 s190 -> s191 (tick)
+    t=192 s191 -> s192 (tick)
+    t=193 s192 -> s193 (tick)
+    t=194 s193 -> s194 (tick)
+    t=195 s194 -> s195 (tick)
+    t=196 s195 -> s196 (tick)
+    t=197 s196 -> s197 (tick)
+    t=198 s197 -> s198 (tick)
+    t=199 s198 -> s199 (tick)
+    t=200 s199 -> s200 (tick)
+
+not represented:
+  - 2 later state changes from t = 200 are not drawn (at most 200 spans are)
diff --git a/internal/exec/runtrace/testdata/dot-sequence.dot.golden b/internal/exec/runtrace/testdata/dot-sequence.dot.golden
new file mode 100644
index 0000000000..0c5ca9ecb1
--- /dev/null
+++ b/internal/exec/runtrace/testdata/dot-sequence.dot.golden
@@ -0,0 +1 @@
+a sequence rendering is not written as dot; ask for text, mermaid or plantuml
diff --git a/internal/exec/runtrace/testdata/dot-timeline.dot.golden b/internal/exec/runtrace/testdata/dot-timeline.dot.golden
new file mode 100644
index 0000000000..a98d2944b7
--- /dev/null
+++ b/internal/exec/runtrace/testdata/dot-timeline.dot.golden
@@ -0,0 +1 @@
+a timeline rendering is not written as dot; ask for text, mermaid or plantuml
diff --git a/internal/exec/runtrace/testdata/empty-sequence.mermaid.golden b/internal/exec/runtrace/testdata/empty-sequence.mermaid.golden
new file mode 100644
index 0000000000..5b594f1808
--- /dev/null
+++ b/internal/exec/runtrace/testdata/empty-sequence.mermaid.golden
@@ -0,0 +1,35 @@
+---
+config:
+  fontFamily: "Helvetica, Arial, sans-serif"
+  theme: base
+  themeVariables:
+    fontFamily: "Helvetica, Arial, sans-serif"
+    fontSize: "14px"
+    primaryColor: "#FFFFFF"
+    secondaryColor: "#FFFFFF"
+    tertiaryColor: "#FFFFFF"
+    background: "#FFFFFF"
+    primaryBorderColor: "#181818"
+    primaryTextColor: "#000000"
+    lineColor: "#181818"
+    textColor: "#000000"
+    noteBkgColor: "#FEFFDD"
+    noteBorderColor: "#181818"
+    noteTextColor: "#000000"
+    actorBkg: "#FFFFFF"
+    actorBorder: "#181818"
+    actorTextColor: "#000000"
+    actorLineColor: "#181818"
+    signalColor: "#181818"
+    signalTextColor: "#000000"
+    labelBoxBkgColor: "#FFFFFF"
+    labelBoxBorderColor: "#181818"
+    labelTextColor: "#000000"
+    loopTextColor: "#000000"
+    activationBorderColor: "#181818"
+    activationBkgColor: "#FFFFFF"
+    sequenceNumberColor: "#000000"
+---
+%% run — sequence rendering (the trace of a run to t = 0)
+sequenceDiagram
+  participant empty as the run recorded no message#59; the rendering is empty
diff --git a/internal/exec/runtrace/testdata/empty-sequence.plantuml.golden b/internal/exec/runtrace/testdata/empty-sequence.plantuml.golden
new file mode 100644
index 0000000000..11571b7044
--- /dev/null
+++ b/internal/exec/runtrace/testdata/empty-sequence.plantuml.golden
@@ -0,0 +1,44 @@
+@startuml
+' run — sequence rendering (the trace of a run to t = 0)
+<style>
+root {
+  BackGroundColor white
+  FontName SansSerif
+  FontSize 14
+  FontColor black
+  LineColor #181818
+  HorizontalAlignment left
+}
+element {
+  BackGroundColor white
+  LineColor #181818
+  LineThickness 0.5
+  RoundCorner 0
+  Shadowing 0.0
+}
+start, end, activityBar {
+  BackGroundColor black
+}
+arrow {
+  LineColor #181818
+  LineThickness 1
+  FontSize 13
+}
+note {
+  BackGroundColor #FEFFDD
+  FontSize 13
+}
+.usage {
+  RoundCorner 20
+}
+.package {
+  LineThickness 1.5
+}
+.region {
+  LineStyle 4
+}
+</style>
+skinparam wrapWidth 300
+hide stereotype
+participant "the run recorded no message; the rendering is empty" as empty
+@enduml
diff --git a/internal/exec/runtrace/testdata/empty-sequence.text.golden b/internal/exec/runtrace/testdata/empty-sequence.text.golden
new file mode 100644
index 0000000000..e15a123751
--- /dev/null
+++ b/internal/exec/runtrace/testdata/empty-sequence.text.golden
@@ -0,0 +1,3 @@
+run - sequence rendering (the trace of a run to t = 0)
+
+the run recorded no message; the rendering is empty
diff --git a/internal/exec/runtrace/testdata/empty-timeline.mermaid.golden b/internal/exec/runtrace/testdata/empty-timeline.mermaid.golden
new file mode 100644
index 0000000000..f1caa16891
--- /dev/null
+++ b/internal/exec/runtrace/testdata/empty-timeline.mermaid.golden
@@ -0,0 +1,32 @@
+---
+config:
+  fontFamily: "Helvetica, Arial, sans-serif"
+  theme: base
+  themeCSS: ".edgeLabel rect { opacity: 1 !important; } .cluster-label .nodeLabel { text-align: center; }"
+  gantt:
+    displayMode: compact
+    leftPadding: 75
+  themeVariables:
+    fontFamily: "Helvetica, Arial, sans-serif"
+    fontSize: "14px"
+    primaryColor: "#FFFFFF"
+    secondaryColor: "#FFFFFF"
+    tertiaryColor: "#FFFFFF"
+    background: "#FFFFFF"
+    primaryBorderColor: "#181818"
+    primaryTextColor: "#000000"
+    lineColor: "#181818"
+    textColor: "#000000"
+    noteBkgColor: "#FEFFDD"
+    noteBorderColor: "#181818"
+    noteTextColor: "#000000"
+    clusterBkg: "#FFFFFF"
+    clusterBorder: "#181818"
+    edgeLabelBackground: "#FFFFFF"
+---
+%% run — timeline rendering (the trace of a run to t = 0)
+%% the run recorded no state; the rendering is empty
+gantt
+    dateFormat x
+    axisFormat %M:%S.%L
+    todayMarker off
diff --git a/internal/exec/runtrace/testdata/empty-timeline.plantuml.golden b/internal/exec/runtrace/testdata/empty-timeline.plantuml.golden
new file mode 100644
index 0000000000..5c8107793d
--- /dev/null
+++ b/internal/exec/runtrace/testdata/empty-timeline.plantuml.golden
@@ -0,0 +1,4 @@
+@startuml
+' run — timeline rendering (the trace of a run to t = 0)
+' the run recorded no state; the rendering is empty
+@enduml
diff --git a/internal/exec/runtrace/testdata/empty-timeline.text.golden b/internal/exec/runtrace/testdata/empty-timeline.text.golden
new file mode 100644
index 0000000000..5bd7f8acad
--- /dev/null
+++ b/internal/exec/runtrace/testdata/empty-timeline.text.golden
@@ -0,0 +1,3 @@
+run - timeline rendering (the trace of a run to t = 0)
+
+the run recorded no state; the rendering is empty
diff --git a/internal/exec/runtrace/testdata/example-sequence-links.mermaid.golden b/internal/exec/runtrace/testdata/example-sequence-links.mermaid.golden
new file mode 100644
index 0000000000..7f75e28bd4
--- /dev/null
+++ b/internal/exec/runtrace/testdata/example-sequence-links.mermaid.golden
@@ -0,0 +1,44 @@
+---
+config:
+  fontFamily: "Helvetica, Arial, sans-serif"
+  theme: base
+  themeVariables:
+    fontFamily: "Helvetica, Arial, sans-serif"
+    fontSize: "14px"
+    primaryColor: "#FFFFFF"
+    secondaryColor: "#FFFFFF"
+    tertiaryColor: "#FFFFFF"
+    background: "#FFFFFF"
+    primaryBorderColor: "#181818"
+    primaryTextColor: "#000000"
+    lineColor: "#181818"
+    textColor: "#000000"
+    noteBkgColor: "#FEFFDD"
+    noteBorderColor: "#181818"
+    noteTextColor: "#000000"
+    actorBkg: "#FFFFFF"
+    actorBorder: "#181818"
+    actorTextColor: "#000000"
+    actorLineColor: "#181818"
+    signalColor: "#181818"
+    signalTextColor: "#000000"
+    labelBoxBkgColor: "#FFFFFF"
+    labelBoxBorderColor: "#181818"
+    labelTextColor: "#000000"
+    loopTextColor: "#000000"
+    activationBorderColor: "#181818"
+    activationBkgColor: "#FFFFFF"
+    sequenceNumberColor: "#000000"
+---
+%% run — sequence rendering (the trace of a run to t = 6)
+sequenceDiagram
+  participant n0 as RunTimeline::mission.controller : Controller
+  link n0: Source @ https://example.test/src/run-timeline.sysml#L23
+  participant n1 as RunTimeline::mission.instrument : Instrument
+  link n1: Source @ https://example.test/src/run-timeline.sysml#L47
+  n0->>n1: t=1 Ping (seq = 1)
+  n1->>n0: t=1 Ack (seq = 1)
+  n0->>n1: t=3 Ping (seq = 1)
+  n1->>n0: t=3 Ack (seq = 1)
+  n0->>n1: t=5 Ping (seq = 1)
+  n1->>n0: t=5 Ack (seq = 1)
diff --git a/internal/exec/runtrace/testdata/example-sequence-links.plantuml.golden b/internal/exec/runtrace/testdata/example-sequence-links.plantuml.golden
new file mode 100644
index 0000000000..5296173c45
--- /dev/null
+++ b/internal/exec/runtrace/testdata/example-sequence-links.plantuml.golden
@@ -0,0 +1,51 @@
+@startuml
+' run — sequence rendering (the trace of a run to t = 6)
+<style>
+root {
+  BackGroundColor white
+  FontName SansSerif
+  FontSize 14
+  FontColor black
+  LineColor #181818
+  HorizontalAlignment left
+}
+element {
+  BackGroundColor white
+  LineColor #181818
+  LineThickness 0.5
+  RoundCorner 0
+  Shadowing 0.0
+}
+start, end, activityBar {
+  BackGroundColor black
+}
+arrow {
+  LineColor #181818
+  LineThickness 1
+  FontSize 13
+}
+note {
+  BackGroundColor #FEFFDD
+  FontSize 13
+}
+.usage {
+  RoundCorner 20
+}
+.package {
+  LineThickness 1.5
+}
+.region {
+  LineStyle 4
+}
+</style>
+skinparam wrapWidth 300
+hide stereotype
+participant "RunTimeline::mission.controller : Controller" as n0 <<object>> <<usage>> [[https://example.test/src/run-timeline.sysml#L23]]
+participant "RunTimeline::mission.instrument : Instrument" as n1 <<object>> <<usage>> [[https://example.test/src/run-timeline.sysml#L47]]
+n0 -> n1 : t=1 Ping (seq = 1)
+n1 -> n0 : t=1 Ack (seq = 1)
+n0 -> n1 : t=3 Ping (seq = 1)
+n1 -> n0 : t=3 Ack (seq = 1)
+n0 -> n1 : t=5 Ping (seq = 1)
+n1 -> n0 : t=5 Ack (seq = 1)
+@enduml
diff --git a/internal/exec/runtrace/testdata/example-sequence.mermaid.golden b/internal/exec/runtrace/testdata/example-sequence.mermaid.golden
new file mode 100644
index 0000000000..651fb56e2f
--- /dev/null
+++ b/internal/exec/runtrace/testdata/example-sequence.mermaid.golden
@@ -0,0 +1,42 @@
+---
+config:
+  fontFamily: "Helvetica, Arial, sans-serif"
+  theme: base
+  themeVariables:
+    fontFamily: "Helvetica, Arial, sans-serif"
+    fontSize: "14px"
+    primaryColor: "#FFFFFF"
+    secondaryColor: "#FFFFFF"
+    tertiaryColor: "#FFFFFF"
+    background: "#FFFFFF"
+    primaryBorderColor: "#181818"
+    primaryTextColor: "#000000"
+    lineColor: "#181818"
+    textColor: "#000000"
+    noteBkgColor: "#FEFFDD"
+    noteBorderColor: "#181818"
+    noteTextColor: "#000000"
+    actorBkg: "#FFFFFF"
+    actorBorder: "#181818"
+    actorTextColor: "#000000"
+    actorLineColor: "#181818"
+    signalColor: "#181818"
+    signalTextColor: "#000000"
+    labelBoxBkgColor: "#FFFFFF"
+    labelBoxBorderColor: "#181818"
+    labelTextColor: "#000000"
+    loopTextColor: "#000000"
+    activationBorderColor: "#181818"
+    activationBkgColor: "#FFFFFF"
+    sequenceNumberColor: "#000000"
+---
+%% run — sequence rendering (the trace of a run to t = 6)
+sequenceDiagram
+  participant n0 as RunTimeline::mission.controller : Controller
+  participant n1 as RunTimeline::mission.instrument : Instrument
+  n0->>n1: t=1 Ping (seq = 1)
+  n1->>n0: t=1 Ack (seq = 1)
+  n0->>n1: t=3 Ping (seq = 1)
+  n1->>n0: t=3 Ack (seq = 1)
+  n0->>n1: t=5 Ping (seq = 1)
+  n1->>n0: t=5 Ack (seq = 1)
diff --git a/internal/exec/runtrace/testdata/example-sequence.plantuml.golden b/internal/exec/runtrace/testdata/example-sequence.plantuml.golden
new file mode 100644
index 0000000000..3d8bdf033f
--- /dev/null
+++ b/internal/exec/runtrace/testdata/example-sequence.plantuml.golden
@@ -0,0 +1,51 @@
+@startuml
+' run — sequence rendering (the trace of a run to t = 6)
+<style>
+root {
+  BackGroundColor white
+  FontName SansSerif
+  FontSize 14
+  FontColor black
+  LineColor #181818
+  HorizontalAlignment left
+}
+element {
+  BackGroundColor white
+  LineColor #181818
+  LineThickness 0.5
+  RoundCorner 0
+  Shadowing 0.0
+}
+start, end, activityBar {
+  BackGroundColor black
+}
+arrow {
+  LineColor #181818
+  LineThickness 1
+  FontSize 13
+}
+note {
+  BackGroundColor #FEFFDD
+  FontSize 13
+}
+.usage {
+  RoundCorner 20
+}
+.package {
+  LineThickness 1.5
+}
+.region {
+  LineStyle 4
+}
+</style>
+skinparam wrapWidth 300
+hide stereotype
+participant "RunTimeline::mission.controller : Controller" as n0 <<object>> <<usage>>
+participant "RunTimeline::mission.instrument : Instrument" as n1 <<object>> <<usage>>
+n0 -> n1 : t=1 Ping (seq = 1)
+n1 -> n0 : t=1 Ack (seq = 1)
+n0 -> n1 : t=3 Ping (seq = 1)
+n1 -> n0 : t=3 Ack (seq = 1)
+n0 -> n1 : t=5 Ping (seq = 1)
+n1 -> n0 : t=5 Ack (seq = 1)
+@enduml
diff --git a/internal/exec/runtrace/testdata/example-sequence.text.golden b/internal/exec/runtrace/testdata/example-sequence.text.golden
new file mode 100644
index 0000000000..e49c65eb03
--- /dev/null
+++ b/internal/exec/runtrace/testdata/example-sequence.text.golden
@@ -0,0 +1,12 @@
+run - sequence rendering (the trace of a run to t = 6)
+
+object RunTimeline::mission.controller : Controller
+object RunTimeline::mission.instrument : Instrument
+
+messages:
+  RunTimeline::mission.controller => RunTimeline::mission.instrument: t=1 Ping (seq = 1)
+  RunTimeline::mission.instrument => RunTimeline::mission.controller: t=1 Ack (seq = 1)
+  RunTimeline::mission.controller => RunTimeline::mission.instrument: t=3 Ping (seq = 1)
+  RunTimeline::mission.instrument => RunTimeline::mission.controller: t=3 Ack (seq = 1)
+  RunTimeline::mission.controller => RunTimeline::mission.instrument: t=5 Ping (seq = 1)
+  RunTimeline::mission.instrument => RunTimeline::mission.controller: t=5 Ack (seq = 1)
diff --git a/internal/exec/runtrace/testdata/example-timeline-links.plantuml.golden b/internal/exec/runtrace/testdata/example-timeline-links.plantuml.golden
new file mode 100644
index 0000000000..6f45f5514f
--- /dev/null
+++ b/internal/exec/runtrace/testdata/example-timeline-links.plantuml.golden
@@ -0,0 +1,31 @@
+@startuml
+' run — timeline rendering (the trace of a run to t = 6)
+' not represented: 1 state held for no time is listed in the text form
+scale 1 as 311 pixels
+concise "[[https://example.test/src/run-timeline.sysml#L26 RunTimeline::mission.controller.modes]]" as l0
+concise "[[https://example.test/src/run-timeline.sysml#L50 RunTimeline::mission.instrument.modes]]" as l1
+@0
+l0 is "waiting | charged"
+note top of l0 : choice entering modes: next waiting(entry), charged(entry) (unordered; took waiting(entry) first)
+l1 is "[[https://example.test/src/run-timeline.sysml#L52 waiting]]"
+@1
+l0 is "acknowledged | charged (time, accept Ack)"
+l1 is "[[https://example.test/src/run-timeline.sysml#L53 acknowledged (accept Ping)]]"
+@2
+l0 is "waiting | charged (time)"
+@2.5
+l1 is "[[https://example.test/src/run-timeline.sysml#L52 waiting (time)]]"
+@3
+l0 is "acknowledged | charged (time, accept Ack)"
+l1 is "[[https://example.test/src/run-timeline.sysml#L53 acknowledged (accept Ping)]]"
+@4
+l0 is "waiting | charged (time)"
+@4.5
+l1 is "[[https://example.test/src/run-timeline.sysml#L52 waiting (time)]]"
+@5
+l0 is "acknowledged | charged (time, accept Ack)"
+l1 is "[[https://example.test/src/run-timeline.sysml#L53 acknowledged (accept Ping)]]"
+@6
+l0 is {hidden}
+l1 is {hidden}
+@enduml
diff --git a/internal/exec/runtrace/testdata/example-timeline.mermaid.golden b/internal/exec/runtrace/testdata/example-timeline.mermaid.golden
new file mode 100644
index 0000000000..b49ebb4171
--- /dev/null
+++ b/internal/exec/runtrace/testdata/example-timeline.mermaid.golden
@@ -0,0 +1,48 @@
+---
+config:
+  fontFamily: "Helvetica, Arial, sans-serif"
+  theme: base
+  themeCSS: ".edgeLabel rect { opacity: 1 !important; } .cluster-label .nodeLabel { text-align: center; }"
+  gantt:
+    displayMode: compact
+    leftPadding: 283
+  themeVariables:
+    fontFamily: "Helvetica, Arial, sans-serif"
+    fontSize: "14px"
+    primaryColor: "#FFFFFF"
+    secondaryColor: "#FFFFFF"
+    tertiaryColor: "#FFFFFF"
+    background: "#FFFFFF"
+    primaryBorderColor: "#181818"
+    primaryTextColor: "#000000"
+    lineColor: "#181818"
+    textColor: "#000000"
+    noteBkgColor: "#FEFFDD"
+    noteBorderColor: "#181818"
+    noteTextColor: "#000000"
+    clusterBkg: "#FFFFFF"
+    clusterBorder: "#181818"
+    edgeLabelBackground: "#FFFFFF"
+---
+%% run — timeline rendering (the trace of a run to t = 6)
+%% not represented: 1 state held for no time is listed in the text form
+%% not represented: Mermaid gantt draws no note; choice and guard records are comments
+%% t=0 choice entering modes: next waiting(entry), charged(entry) (unordered; took waiting(entry) first)
+gantt
+    dateFormat x
+    axisFormat %M:%S.%L
+    todayMarker off
+    section RunTimeline#58;#58;mission.controller.modes
+        waiting | charged :l0s0, 0, 1000
+        acknowledged | charged (time, accept Ack) :l0s1, 1000, 2000
+        waiting | charged (time) :l0s2, 2000, 3000
+        acknowledged | charged (time, accept Ack) :l0s3, 3000, 4000
+        waiting | charged (time) :l0s4, 4000, 5000
+        acknowledged | charged (time, accept Ack) :l0s5, 5000, 6000
+    section RunTimeline#58;#58;mission.instrument.modes
+        waiting :l1s0, 0, 1000
+        acknowledged (accept Ping) :l1s1, 1000, 2500
+        waiting (time) :l1s2, 2500, 3000
+        acknowledged (accept Ping) :l1s3, 3000, 4500
+        waiting (time) :l1s4, 4500, 5000
+        acknowledged (accept Ping) :l1s5, 5000, 6000
diff --git a/internal/exec/runtrace/testdata/example-timeline.plantuml.golden b/internal/exec/runtrace/testdata/example-timeline.plantuml.golden
new file mode 100644
index 0000000000..f4a2e7aade
--- /dev/null
+++ b/internal/exec/runtrace/testdata/example-timeline.plantuml.golden
@@ -0,0 +1,31 @@
+@startuml
+' run — timeline rendering (the trace of a run to t = 6)
+' not represented: 1 state held for no time is listed in the text form
+scale 1 as 311 pixels
+concise "RunTimeline::mission.controller.modes" as l0
+concise "RunTimeline::mission.instrument.modes" as l1
+@0
+l0 is "waiting | charged"
+note top of l0 : choice entering modes: next waiting(entry), charged(entry) (unordered; took waiting(entry) first)
+l1 is "waiting"
+@1
+l0 is "acknowledged | charged (time, accept Ack)"
+l1 is "acknowledged (accept Ping)"
+@2
+l0 is "waiting | charged (time)"
+@2.5
+l1 is "waiting (time)"
+@3
+l0 is "acknowledged | charged (time, accept Ack)"
+l1 is "acknowledged (accept Ping)"
+@4
+l0 is "waiting | charged (time)"
+@4.5
+l1 is "waiting (time)"
+@5
+l0 is "acknowledged | charged (time, accept Ack)"
+l1 is "acknowledged (accept Ping)"
+@6
+l0 is {hidden}
+l1 is {hidden}
+@enduml
diff --git a/internal/exec/runtrace/testdata/example-timeline.text.golden b/internal/exec/runtrace/testdata/example-timeline.text.golden
new file mode 100644
index 0000000000..cf351312ba
--- /dev/null
+++ b/internal/exec/runtrace/testdata/example-timeline.text.golden
@@ -0,0 +1,36 @@
+run - timeline rendering (the trace of a run to t = 6)
+
+RunTimeline::mission.controller.modes
+  0 .. 1  waiting | charged
+  1 .. 2  acknowledged | charged (time, accept Ack)  via sending
+  2 .. 3  waiting | charged (time)
+  3 .. 4  acknowledged | charged (time, accept Ack)  via sending
+  4 .. 5  waiting | charged (time)
+  5 .. 6  acknowledged | charged (time, accept Ack)  via sending
+  6 .. 6  waiting | charged (time)  (held at the end)
+  transitions:
+    t=1 waiting -> sending (time)
+    t=1 sending -> acknowledged (accept Ack)
+    t=2 acknowledged -> waiting (time)
+    t=3 waiting -> sending (time)
+    t=3 sending -> acknowledged (accept Ack)
+    t=4 acknowledged -> waiting (time)
+    t=5 waiting -> sending (time)
+    t=5 sending -> acknowledged (accept Ack)
+    t=6 acknowledged -> waiting (time)
+  noted:
+    t=0 choice entering modes: next waiting(entry), charged(entry) (unordered; took waiting(entry) first)
+
+RunTimeline::mission.instrument.modes
+  0 .. 1    waiting
+  1 .. 2.5  acknowledged (accept Ping)
+  2.5 .. 3  waiting (time)
+  3 .. 4.5  acknowledged (accept Ping)
+  4.5 .. 5  waiting (time)
+  5 .. 6    acknowledged (accept Ping)  (held at the end)
+  transitions:
+    t=1 waiting -> acknowledged (accept Ping)
+    t=2.5 acknowledged -> waiting (time)
+    t=3 waiting -> acknowledged (accept Ping)
+    t=4.5 acknowledged -> waiting (time)
+    t=5 waiting -> acknowledged (accept Ping)
diff --git a/internal/exec/runtrace/testdata/guard-timeline.text.golden b/internal/exec/runtrace/testdata/guard-timeline.text.golden
new file mode 100644
index 0000000000..9ca5788c53
--- /dev/null
+++ b/internal/exec/runtrace/testdata/guard-timeline.text.golden
@@ -0,0 +1,6 @@
+run - timeline rendering (the trace of a run to t = 2)
+
+#1.modes
+  0 .. 2  waiting  (held at the end)
+  noted:
+    t=1 unevaluable guard waiting: transition accept Ping: unbound (not selected)
diff --git a/internal/exec/runtrace/testdata/hash-label-timeline.mermaid.golden b/internal/exec/runtrace/testdata/hash-label-timeline.mermaid.golden
new file mode 100644
index 0000000000..4b92438f66
--- /dev/null
+++ b/internal/exec/runtrace/testdata/hash-label-timeline.mermaid.golden
@@ -0,0 +1,33 @@
+---
+config:
+  fontFamily: "Helvetica, Arial, sans-serif"
+  theme: base
+  themeCSS: ".edgeLabel rect { opacity: 1 !important; } .cluster-label .nodeLabel { text-align: center; }"
+  gantt:
+    displayMode: compact
+    leftPadding: 80
+  themeVariables:
+    fontFamily: "Helvetica, Arial, sans-serif"
+    fontSize: "14px"
+    primaryColor: "#FFFFFF"
+    secondaryColor: "#FFFFFF"
+    tertiaryColor: "#FFFFFF"
+    background: "#FFFFFF"
+    primaryBorderColor: "#181818"
+    primaryTextColor: "#000000"
+    lineColor: "#181818"
+    textColor: "#000000"
+    noteBkgColor: "#FEFFDD"
+    noteBorderColor: "#181818"
+    noteTextColor: "#000000"
+    clusterBkg: "#FFFFFF"
+    clusterBorder: "#181818"
+    edgeLabelBackground: "#FFFFFF"
+---
+%% run — timeline rendering (the trace of a run to t = 1)
+gantt
+    dateFormat x
+    axisFormat %M:%S.%L
+    todayMarker off
+    section #35;7.modes
+        ready :l0s0, 0, 1000
diff --git a/internal/exec/runtrace/testdata/hash-label-timeline.plantuml.golden b/internal/exec/runtrace/testdata/hash-label-timeline.plantuml.golden
new file mode 100644
index 0000000000..d431c874c1
--- /dev/null
+++ b/internal/exec/runtrace/testdata/hash-label-timeline.plantuml.golden
@@ -0,0 +1,9 @@
+@startuml
+' run — timeline rendering (the trace of a run to t = 1)
+scale 1 as 140 pixels
+concise "<U+0023>7.modes" as l0
+@0
+l0 is "ready"
+@1
+l0 is {hidden}
+@enduml
diff --git a/internal/exec/runtrace/testdata/hash-label-timeline.text.golden b/internal/exec/runtrace/testdata/hash-label-timeline.text.golden
new file mode 100644
index 0000000000..c846088c26
--- /dev/null
+++ b/internal/exec/runtrace/testdata/hash-label-timeline.text.golden
@@ -0,0 +1,4 @@
+run - timeline rendering (the trace of a run to t = 1)
+
+#7.modes
+  0 .. 1  ready  (held at the end)
diff --git a/internal/exec/runtrace/testdata/messages-sequence.text.golden b/internal/exec/runtrace/testdata/messages-sequence.text.golden
new file mode 100644
index 0000000000..93b9c1f238
--- /dev/null
+++ b/internal/exec/runtrace/testdata/messages-sequence.text.golden
@@ -0,0 +1,11 @@
+run - sequence rendering (the trace of a run to t = 4)
+
+object #1 : sender
+object #2 : receiver
+environment environment
+
+messages:
+  #1 => #2: t=0 Unmatched (not accepted)
+  environment => environment: t=1 Outside (not accepted)
+  #1 => #2: t=2..2.5 Broadcast
+  environment => #2: t=3 Missing
diff --git a/internal/exec/runtrace/testdata/parallel-regions-timeline-links.plantuml.golden b/internal/exec/runtrace/testdata/parallel-regions-timeline-links.plantuml.golden
new file mode 100644
index 0000000000..bc1056f886
--- /dev/null
+++ b/internal/exec/runtrace/testdata/parallel-regions-timeline-links.plantuml.golden
@@ -0,0 +1,12 @@
+@startuml
+' run — timeline rendering (the trace of a run to t = 2)
+scale 1 as 220 pixels
+concise "[[https://example.test/src/parallel-regions.sysml#L5 box.modes]]" as l0
+@0
+l0 is "left.waiting | right.waiting"
+note top of l0 : choice entering open: next left.waiting(entry), right.waiting(entry) (unordered; took left.waiting(entry) first)
+@1
+l0 is "done | waiting (time)"
+@2
+l0 is {hidden}
+@enduml
diff --git a/internal/exec/runtrace/testdata/parallel-regions-timeline.text.golden b/internal/exec/runtrace/testdata/parallel-regions-timeline.text.golden
new file mode 100644
index 0000000000..89b3b8f291
--- /dev/null
+++ b/internal/exec/runtrace/testdata/parallel-regions-timeline.text.golden
@@ -0,0 +1,9 @@
+run - timeline rendering (the trace of a run to t = 2)
+
+box.modes
+  0 .. 1  left.waiting | right.waiting
+  1 .. 2  done | waiting (time)  (held at the end)
+  transitions:
+    t=1 waiting -> done (time)
+  noted:
+    t=0 choice entering open: next left.waiting(entry), right.waiting(entry) (unordered; took left.waiting(entry) first)
diff --git a/internal/exec/runtrace/testdata/parallel-regions.sysml b/internal/exec/runtrace/testdata/parallel-regions.sysml
new file mode 100644
index 0000000000..e11fb602ea
--- /dev/null
+++ b/internal/exec/runtrace/testdata/parallel-regions.sysml
@@ -0,0 +1,26 @@
+package Par {
+    private import SI::*;
+
+    part def Box {
+        exhibit state modes {
+            entry; then open;
+
+            state open parallel {
+                state left {
+                    entry; then waiting;
+                    state waiting;
+                    state done;
+
+                    transition first waiting accept after 1 [s] then done;
+                }
+
+                state right {
+                    entry; then waiting;
+                    state waiting;
+                }
+            }
+        }
+    }
+
+    part box : Box;
+}
diff --git a/internal/exec/runtrace/testdata/self-transition-timeline.text.golden b/internal/exec/runtrace/testdata/self-transition-timeline.text.golden
new file mode 100644
index 0000000000..b46579cbce
--- /dev/null
+++ b/internal/exec/runtrace/testdata/self-transition-timeline.text.golden
@@ -0,0 +1,7 @@
+run - timeline rendering (the trace of a run to t = 2)
+
+#1.modes
+  0 .. 1  idle
+  1 .. 2  idle (accept Tick)  (held at the end)
+  transitions:
+    t=1 idle -> idle (accept Tick)
diff --git a/internal/exec/runtrace/testdata/serial-pairing-sequence.text.golden b/internal/exec/runtrace/testdata/serial-pairing-sequence.text.golden
new file mode 100644
index 0000000000..d6801b09dd
--- /dev/null
+++ b/internal/exec/runtrace/testdata/serial-pairing-sequence.text.golden
@@ -0,0 +1,9 @@
+run - sequence rendering (the trace of a run to t = 2)
+
+object SerialPairing::mission.alpha : alpha
+object SerialPairing::mission.receiver : Receiver
+object SerialPairing::mission.beta : beta
+
+messages:
+  SerialPairing::mission.alpha => SerialPairing::mission.receiver: t=0 Ping (seq = 1) (not accepted)
+  SerialPairing::mission.beta => SerialPairing::mission.receiver: t=1 Ping (seq = 2)
diff --git a/internal/exec/runtrace/testdata/serial-pairing.sysml b/internal/exec/runtrace/testdata/serial-pairing.sysml
new file mode 100644
index 0000000000..8b370f20cf
--- /dev/null
+++ b/internal/exec/runtrace/testdata/serial-pairing.sysml
@@ -0,0 +1,70 @@
+package SerialPairing {
+    private import ScalarValues::*;
+    private import SI::*;
+
+    package Alpha {
+        item def Ping {
+            attribute seq : Integer;
+        }
+    }
+
+    package Beta {
+        item def Ping {
+            attribute seq : Integer;
+        }
+    }
+
+    port def PingPort {
+        out item alpha : Alpha::Ping;
+        out item beta : Beta::Ping;
+    }
+
+    part def Sender {
+        port p : PingPort;
+    }
+
+    part def Receiver {
+        port p : ~PingPort;
+
+        exhibit state listening {
+            entry; then waiting;
+
+            state waiting;
+            state received;
+
+            transition first waiting accept order : Beta::Ping via p then received;
+        }
+    }
+
+    part def Mission {
+        part alpha : Sender {
+            exhibit state dispatch {
+                entry; then sent;
+
+                state sent {
+                    entry send new Alpha::Ping(seq = 1) via p;
+                }
+            }
+        }
+
+        part beta : Sender {
+            exhibit state dispatch {
+                entry; then waiting;
+
+                state waiting;
+                state sent {
+                    entry send new Beta::Ping(seq = 2) via p;
+                }
+
+                transition first waiting accept after 1 [s] then sent;
+            }
+        }
+
+        part receiver : Receiver;
+
+        connect alpha.p to receiver.p;
+        connect beta.p to receiver.p;
+    }
+
+    part mission : Mission;
+}
diff --git a/internal/exec/runtrace/testdata/termination-timeline.text.golden b/internal/exec/runtrace/testdata/termination-timeline.text.golden
new file mode 100644
index 0000000000..586c542ddf
--- /dev/null
+++ b/internal/exec/runtrace/testdata/termination-timeline.text.golden
@@ -0,0 +1,12 @@
+run - timeline rendering (the trace of a run to t = 10)
+
+Stopper.modes
+  0 .. 2  waiting
+  noted:
+    t=2 terminated with occurrence: modes (do behavior abandoned: waiting)
+
+Runner.modes
+  0 .. 10   waiting
+  10 .. 10  finished (time)  (held at the end)
+  transitions:
+    t=10 waiting -> finished (time)
diff --git a/internal/exec/runtrace/testdata/termination.sysml b/internal/exec/runtrace/testdata/termination.sysml
new file mode 100644
index 0000000000..7e35bc006b
--- /dev/null
+++ b/internal/exec/runtrace/testdata/termination.sysml
@@ -0,0 +1,36 @@
+package Termination {
+    private import ScalarValues::*;
+    private import SI::*;
+
+    part def Stopper {
+        exhibit state modes {
+            entry; then waiting;
+
+            state waiting {
+                do action stop {
+                    first start;
+                    then action wait accept after 2 [s];
+                    then terminate this;
+                }
+            }
+        }
+    }
+
+    part def Runner {
+        exhibit state modes {
+            entry; then waiting;
+
+            state waiting;
+            state finished;
+
+            transition first waiting accept after 10 [s] then finished;
+        }
+    }
+
+    part def Mission {
+        part stopper : Stopper;
+        part runner : Runner;
+    }
+
+    part mission : Mission;
+}
diff --git a/internal/exec/runtrace/testdata/truncated-sequence.text.golden b/internal/exec/runtrace/testdata/truncated-sequence.text.golden
new file mode 100644
index 0000000000..52093d9168
--- /dev/null
+++ b/internal/exec/runtrace/testdata/truncated-sequence.text.golden
@@ -0,0 +1,10 @@
+run - sequence rendering (the trace of a run to t = 4)
+
+object #1 : sender
+object #2 : receiver
+
+messages:
+  #1 => #2: t=2..3 Ping
+
+not represented:
+  - 2 earlier records up to t = 1 were dropped; senders or acceptors of earlier messages may be missing
diff --git a/internal/exec/runtrace/testdata/truncated-timeline.text.golden b/internal/exec/runtrace/testdata/truncated-timeline.text.golden
new file mode 100644
index 0000000000..918f532bd1
--- /dev/null
+++ b/internal/exec/runtrace/testdata/truncated-timeline.text.golden
@@ -0,0 +1,7 @@
+run - timeline rendering (the trace of a run to t = 4)
+
+#1.modes
+  4 .. 4  held  (held at the end)
+
+not represented:
+  - 3 earlier records up to t = 2 were dropped; a lane starts at its first state entry kept
diff --git a/internal/exec/runtrace/timeline.go b/internal/exec/runtrace/timeline.go
new file mode 100644
index 0000000000..466fbd7527
--- /dev/null
+++ b/internal/exec/runtrace/timeline.go
@@ -0,0 +1,536 @@
+package runtrace
+
+import (
+	"fmt"
+	"sort"
+	"strconv"
+	"strings"
+
+	"github.com/Open-MBEE/OpenSysML/internal/exec/runtime"
+	"github.com/Open-MBEE/OpenSysML/internal/ir/view"
+	"github.com/Open-MBEE/OpenSysML/internal/semantic/symbols"
+)
+
+type laneKey struct {
+	object   int64
+	behavior *symbols.Symbol
+}
+
+type timelineLane struct {
+	rendering *view.Lane
+	key       laneKey
+	regions   map[string]int
+	states    map[stateKey]activeState
+	first     map[stateKey]int
+	nextOrder int
+}
+
+type stateKey struct {
+	path   string
+	region string
+}
+
+type activeState struct {
+	record runtime.TraceRecord
+	order  int
+}
+
+type timelineGroup struct {
+	at          float64
+	states      []runtime.TraceRecord
+	transitions []runtime.TraceRecord
+	terminated  []runtime.TraceRecord
+}
+
+type transientState struct {
+	key    stateKey
+	record runtime.TraceRecord
+	order  int
+}
+
+func timeline(trace *runtime.TraceRecorder, options Options) *view.Rendering {
+	out := runRendering(view.KindTimeline, options)
+	if trace == nil {
+		return out
+	}
+	records := trace.Records()
+	lanes := make([]*timelineLane, 0)
+	byKey := make(map[laneKey]*timelineLane)
+	for _, record := range records {
+		if record.Kind != runtime.TraceEntry && record.Kind != runtime.TraceExit && record.Kind != runtime.TraceTerminate {
+			continue
+		}
+		key := keyOf(record.Origin)
+		if lane := byKey[key]; lane != nil {
+			lane.regionOrder(record.Region)
+			if record.Kind == runtime.TraceEntry {
+				key := stateKeyOf(record)
+				if _, seen := lane.first[key]; !seen {
+					lane.first[key] = lane.nextOrder
+					lane.nextOrder++
+				}
+			}
+			continue
+		}
+		var origin view.Origin
+		if record.Origin.Behavior != nil {
+			origin = record.Origin.Behavior.Origin()
+		}
+		lane := &view.Lane{
+			ID:     fmt.Sprintf("l%d", len(lanes)),
+			Name:   laneName(record, options.Label),
+			Origin: origin,
+		}
+		stateLane := &timelineLane{
+			rendering: lane, key: key,
+			regions: make(map[string]int), states: make(map[stateKey]activeState), first: make(map[stateKey]int),
+		}
+		stateLane.regionOrder(record.Region)
+		if record.Kind == runtime.TraceEntry {
+			stateLane.first[stateKeyOf(record)] = stateLane.nextOrder
+			stateLane.nextOrder++
+		}
+		lanes = append(lanes, stateLane)
+		byKey[key] = stateLane
+	}
+	groups := make(map[*timelineLane]map[float64]*timelineGroup, len(lanes))
+	for _, lane := range lanes {
+		groups[lane] = make(map[float64]*timelineGroup)
+	}
+	for _, record := range records {
+		if record.Kind != runtime.TraceEntry && record.Kind != runtime.TraceExit && record.Kind != runtime.TraceTerminate {
+			continue
+		}
+		lane := byKey[keyOf(record.Origin)]
+		if lane != nil {
+			group := groups[lane][record.Origin.At]
+			if group == nil {
+				group = &timelineGroup{at: record.Origin.At}
+				groups[lane][record.Origin.At] = group
+			}
+			if record.Kind == runtime.TraceTerminate {
+				group.terminated = append(group.terminated, record)
+			} else {
+				group.states = append(group.states, record)
+			}
+		}
+	}
+	for _, record := range records {
+		key := keyOf(record.Origin)
+		lane := byKey[key]
+		switch record.Kind {
+		case runtime.TraceTransition:
+			if lane == nil {
+				out.Notices = append(out.Notices, fmt.Sprintf("transition at t = %s has no state lane: %s -> %s",
+					runInstant(record.Origin.At), record.From, record.To))
+				continue
+			}
+			transition := view.LaneTransition{At: record.Origin.At, From: record.From, To: record.To, Event: record.Event}
+			lane.rendering.Transitions = append(lane.rendering.Transitions, transition)
+			if group := groups[lane][record.Origin.At]; group != nil {
+				group.transitions = append(group.transitions, record)
+			}
+		case runtime.TraceChoice, runtime.TraceGuard:
+			if lane == nil {
+				lane = laneForObject(lanes, key.object)
+			}
+			if lane == nil {
+				out.Notices = append(out.Notices, fmt.Sprintf("t=%s %s", runInstant(record.Origin.At), record.Text()))
+				continue
+			}
+			lane.rendering.Marks = append(lane.rendering.Marks, view.Mark{
+				At: record.Origin.At, Kind: record.Kind.String(), Text: record.Text(),
+			})
+		case runtime.TraceTerminate:
+			if lane == nil {
+				lane = laneForObject(lanes, key.object)
+			}
+			if lane == nil {
+				continue
+			}
+			lane.rendering.Marks = append(lane.rendering.Marks, view.Mark{
+				At: record.Origin.At, Kind: record.Kind.String(), Text: record.Text(),
+			})
+		}
+	}
+	for _, lane := range lanes {
+		ordered := make([]*timelineGroup, 0, len(groups[lane]))
+		for _, group := range groups[lane] {
+			ordered = append(ordered, group)
+		}
+		sort.SliceStable(ordered, func(i, j int) bool { return ordered[i].at < ordered[j].at })
+		currentSpan := -1
+		for _, group := range ordered {
+			through, changed := lane.apply(group.states, len(group.terminated) > 0)
+			if !changed {
+				continue
+			}
+			if currentSpan >= 0 {
+				lane.rendering.Spans[currentSpan].To = group.at
+				lane.rendering.Spans[currentSpan].Open = false
+			}
+			leaves := lane.leaves()
+			if len(leaves) == 0 {
+				currentSpan = -1
+				continue
+			}
+			leafRecords := make([]runtime.TraceRecord, len(leaves))
+			for i, leaf := range leaves {
+				leafRecords[i] = leaf.record
+			}
+			span := view.Span{State: strings.Join(stateLabels(leafRecords), " | "), From: group.at, To: group.at}
+			if len(leaves) == 1 {
+				span.Origin = leaves[0].record.Source
+			}
+			throughRecords := make([]runtime.TraceRecord, len(through))
+			for i, item := range through {
+				throughRecords[i] = item.record
+			}
+			span.Through = stateLabels(throughRecords)
+			for _, transition := range group.transitions {
+				if transition.Event != "" {
+					span.Triggers = append(span.Triggers, transition.Event)
+				}
+			}
+			lane.rendering.Spans = append(lane.rendering.Spans, span)
+			currentSpan = len(lane.rendering.Spans) - 1
+		}
+		if currentSpan >= 0 {
+			span := &lane.rendering.Spans[currentSpan]
+			span.To = max(options.Until, span.From)
+			span.Open = true
+		}
+		sort.SliceStable(lane.rendering.Transitions, func(i, j int) bool {
+			return lane.rendering.Transitions[i].At < lane.rendering.Transitions[j].At
+		})
+		sort.SliceStable(lane.rendering.Marks, func(i, j int) bool {
+			return lane.rendering.Marks[i].At < lane.rendering.Marks[j].At
+		})
+		out.Lanes = append(out.Lanes, *lane.rendering)
+	}
+	if count, upTo := trace.Dropped(); count > 0 {
+		out.Notices = append(out.Notices, fmt.Sprintf("%d earlier records up to t = %s were dropped; a lane starts at its first state entry kept",
+			count, runInstant(upTo)))
+	}
+	applyTimelineLimit(out, options.Limit)
+	return out
+}
+
+func stateLabels(records []runtime.TraceRecord) []string {
+	labels := make([]string, len(records))
+	byName := make(map[string][]int)
+	for i, record := range records {
+		labels[i] = record.State
+		byName[record.State] = append(byName[record.State], i)
+	}
+	for name, indexes := range byName {
+		if len(indexes) < 2 {
+			continue
+		}
+		paths := make([]string, len(indexes))
+		for i, index := range indexes {
+			paths[i] = records[index].Path
+		}
+		suffixes, ok := uniqueTrailingPaths(paths)
+		if !ok {
+			regions := make([]string, len(indexes))
+			for i, index := range indexes {
+				regions[i] = records[index].Region
+			}
+			suffixes, ok = uniqueTrailingPaths(regions)
+			if ok {
+				for i := range suffixes {
+					suffixes[i] += "." + name
+				}
+			}
+		}
+		if ok {
+			for i, index := range indexes {
+				labels[index] = suffixes[i]
+			}
+		}
+	}
+	return labels
+}
+
+func uniqueTrailingPaths(paths []string) ([]string, bool) {
+	parts := make([][]string, len(paths))
+	maxParts := 0
+	for i, path := range paths {
+		if path == "" {
+			return nil, false
+		}
+		parts[i] = strings.Split(path, ".")
+		maxParts = max(maxParts, len(parts[i]))
+	}
+	for width := 1; width <= maxParts; width++ {
+		suffixes := make([]string, len(parts))
+		seen := make(map[string]bool, len(parts))
+		unique := true
+		for i, path := range parts {
+			start := max(0, len(path)-width)
+			suffixes[i] = strings.Join(path[start:], ".")
+			if seen[suffixes[i]] {
+				unique = false
+				break
+			}
+			seen[suffixes[i]] = true
+		}
+		if unique {
+			return suffixes, true
+		}
+	}
+	return nil, false
+}
+
+func (lane *timelineLane) apply(records []runtime.TraceRecord, terminated bool) ([]transientState, bool) {
+	entered := make(map[stateKey]runtime.TraceRecord)
+	var exitedLeaves []transientState
+	changed := false
+	for _, record := range records {
+		key := stateKeyOf(record)
+		lane.regionOrder(record.Region)
+		switch record.Kind {
+		case runtime.TraceEntry:
+			order, seen := lane.first[key]
+			if !seen {
+				order = lane.nextOrder
+				lane.nextOrder++
+				lane.first[key] = order
+			}
+			if current, ok := lane.states[key]; ok {
+				order = current.order
+			}
+			lane.states[key] = activeState{record: record, order: order}
+			entered[key] = record
+			changed = true
+		case runtime.TraceExit:
+			current, ok := lane.states[key]
+			if !ok {
+				continue
+			}
+			if !lane.hasDescendant(key) {
+				exitedLeaves = append(exitedLeaves, transientState{key: key, record: current.record, order: current.order})
+			}
+			delete(lane.states, key)
+			changed = true
+		}
+	}
+	if terminated {
+		for key := range lane.states {
+			delete(lane.states, key)
+		}
+		changed = true
+	}
+	through := make([]transientState, 0)
+	for _, exited := range exitedLeaves {
+		if _, wasEntered := entered[exited.key]; !wasEntered {
+			continue
+		}
+		if _, active := lane.states[exited.key]; active {
+			continue
+		}
+		through = append(through, exited)
+	}
+	sort.SliceStable(through, func(i, j int) bool {
+		left, right := lane.regionOrder(through[i].record.Region), lane.regionOrder(through[j].record.Region)
+		if left != right {
+			return left < right
+		}
+		return through[i].order < through[j].order
+	})
+	filtered := through[:0]
+	for _, item := range through {
+		parent := false
+		for _, other := range through {
+			if other.key.descendsFrom(item.key) {
+				parent = true
+				break
+			}
+		}
+		if !parent {
+			filtered = append(filtered, item)
+		}
+	}
+	return filtered, changed
+}
+
+func (lane *timelineLane) leaves() []activeState {
+	var leaves []activeState
+	for key, state := range lane.states {
+		if !lane.hasDescendant(key) {
+			leaves = append(leaves, state)
+		}
+	}
+	sort.SliceStable(leaves, func(i, j int) bool {
+		left, right := lane.regionOrder(leaves[i].record.Region), lane.regionOrder(leaves[j].record.Region)
+		if left != right {
+			return left < right
+		}
+		return leaves[i].order < leaves[j].order
+	})
+	return leaves
+}
+
+func (lane *timelineLane) hasDescendant(parent stateKey) bool {
+	for active := range lane.states {
+		if active.descendsFrom(parent) {
+			return true
+		}
+	}
+	return false
+}
+
+func (key stateKey) descendsFrom(parent stateKey) bool {
+	if !strings.HasPrefix(key.path, parent.path+".") {
+		return false
+	}
+	return parent.region == "" || key.region == parent.region || strings.HasPrefix(key.region, parent.region+".")
+}
+
+func (lane *timelineLane) regionOrder(region string) int {
+	if order, ok := lane.regions[region]; ok {
+		return order
+	}
+	order := len(lane.regions)
+	lane.regions[region] = order
+	return order
+}
+
+func keyOf(origin runtime.TraceOrigin) laneKey {
+	key := laneKey{behavior: origin.Behavior}
+	if origin.Object != nil {
+		key.object = origin.Object.ID
+	}
+	return key
+}
+
+func laneName(record runtime.TraceRecord, label func(*runtime.Instance) string) string {
+	machine := record.Machine()
+	if machine == "" && record.Origin.Behavior != nil {
+		machine = record.Origin.Behavior.Name
+	}
+	if record.Origin.Object != nil {
+		name := instanceName(record.Origin.Object, label)
+		if machine != "" {
+			return name + "." + machine
+		}
+		return name
+	}
+	if machine != "" {
+		return machine
+	}
+	return "environment"
+}
+
+func instanceName(instance *runtime.Instance, label func(*runtime.Instance) string) string {
+	if label != nil {
+		if name := label(instance); name != "" {
+			return name
+		}
+	}
+	return fmt.Sprintf("#%d", instance.ID)
+}
+
+func laneForObject(lanes []*timelineLane, object int64) *timelineLane {
+	if object == 0 {
+		return nil
+	}
+	for _, lane := range lanes {
+		if lane.key.object == object {
+			return lane
+		}
+	}
+	return nil
+}
+
+func statePath(record runtime.TraceRecord) string {
+	if record.Path != "" {
+		return record.Path
+	}
+	return record.State
+}
+
+func stateKeyOf(record runtime.TraceRecord) stateKey {
+	return stateKey{path: statePath(record), region: record.Region}
+}
+
+type spanRef struct {
+	lane  int
+	index int
+	from  float64
+}
+
+func applyTimelineLimit(rendering *view.Rendering, requested int) {
+	limit := effectiveLimit(requested)
+	var spans []spanRef
+	for laneIndex, lane := range rendering.Lanes {
+		for spanIndex, span := range lane.Spans {
+			spans = append(spans, spanRef{lane: laneIndex, index: spanIndex, from: span.From})
+		}
+	}
+	if len(spans) <= limit {
+		return
+	}
+	sort.SliceStable(spans, func(i, j int) bool { return spans[i].from < spans[j].from })
+	cutoff := spans[limit].from
+	firstDropped := make(map[int]int)
+	for _, span := range spans[limit:] {
+		if index, exists := firstDropped[span.lane]; !exists || span.index < index {
+			firstDropped[span.lane] = span.index
+		}
+	}
+	dropped := 0
+	for laneIndex := range rendering.Lanes {
+		lane := &rendering.Lanes[laneIndex]
+		dropIndex, hasDrops := firstDropped[laneIndex]
+		if !hasDrops {
+			continue
+		}
+		dropped += len(lane.Spans) - dropIndex
+		boundary := lane.Spans[dropIndex].From
+		lane.Spans = lane.Spans[:dropIndex]
+		if dropIndex > 0 {
+			lane.Spans[dropIndex-1].To = min(lane.Spans[dropIndex-1].To, boundary)
+			lane.Spans[dropIndex-1].Open = false
+		}
+		transitions := lane.Transitions[:0]
+		for _, transition := range lane.Transitions {
+			if transition.At <= boundary {
+				transitions = append(transitions, transition)
+			}
+		}
+		lane.Transitions = transitions
+		marks := lane.Marks[:0]
+		for _, mark := range lane.Marks {
+			if mark.At <= boundary {
+				marks = append(marks, mark)
+			}
+		}
+		lane.Marks = marks
+	}
+	verb := "are"
+	if dropped == 1 {
+		verb = "is"
+	}
+	rendering.Notices = append(rendering.Notices, fmt.Sprintf("%d later state %s from t = %s %s not drawn (at most %d spans are)",
+		dropped, plural(dropped, "change", "changes"), runInstant(cutoff), verb, limit))
+}
+
+func effectiveLimit(limit int) int {
+	if limit <= 0 {
+		return DefaultLimit
+	}
+	return limit
+}
+
+func runInstant(instant float64) string {
+	return strconv.FormatFloat(instant, 'g', -1, 64)
+}
+
+func plural(count int, singular, plural string) string {
+	if count == 1 {
+		return singular
+	}
+	return plural
+}
diff --git a/internal/frontend/grpc/state_trace_test.go b/internal/frontend/grpc/state_trace_test.go
index 423a2cff33..0d19586ffd 100644
--- a/internal/frontend/grpc/state_trace_test.go
+++ b/internal/frontend/grpc/state_trace_test.go
@@ -99,6 +99,55 @@ func TestExecuteStateTraceOrderAndOptIn(t *testing.T) {
 	}
 }
 
+func TestExecuteStateTraceReportsTerminateAtTerminationInstant(t *testing.T) {
+	service := mustNewService(t, 10)
+	modelHash := parseStateTraceModel(t, service, `
+package Termination {
+  private import ScalarValues::*;
+  private import SI::*;
+  part def Stopper {
+    exhibit state modes {
+      entry; then waiting;
+      state waiting {
+        do action stop {
+          first start;
+          then action wait accept after 2 [s];
+          then terminate this;
+        }
+      }
+    }
+  }
+  part stopper : Stopper;
+}
+`)
+	response, err := service.ExecuteState(context.Background(), &pb.ExecuteStateRequest{
+		ModelHash:            modelHash,
+		StateMachineSymbolId: "Termination::Stopper::modes",
+		PerformerSymbolId:    "Termination::stopper",
+		Trace:                true,
+	})
+	if err != nil {
+		t.Fatalf("ExecuteState: %v", err)
+	}
+	if response.Error != "" {
+		t.Fatalf("execution error: %s", response.Error)
+	}
+	var termination *pb.DocumentEvent
+	for _, event := range response.Trace {
+		if event.Kind == "terminate" {
+			termination = event
+			break
+		}
+	}
+	if termination == nil {
+		t.Fatalf("trace has no terminate record: %v", response.Trace)
+	}
+	time := termination.Time.GetQuantity()
+	if time == nil || protoMagnitude(time) != 2 || time.GetUnit() != "s" {
+		t.Fatalf("terminate time = %v, want 2 [s]", termination.Time)
+	}
+}
+
 func TestExecuteStateTraceReportsChoice(t *testing.T) {
 	service := mustNewService(t, 10)
 	modelHash := parseStateTraceModel(t, service, `
diff --git a/internal/frontend/repl/complete.go b/internal/frontend/repl/complete.go
index 3b008a2a9f..b4dd10d271 100644
--- a/internal/frontend/repl/complete.go
+++ b/internal/frontend/repl/complete.go
@@ -11,6 +11,7 @@ import (
 
 	"github.com/Open-MBEE/OpenSysML/internal/exec/objref"
 	"github.com/Open-MBEE/OpenSysML/internal/exec/runtime"
+	"github.com/Open-MBEE/OpenSysML/internal/exec/runtrace"
 	"github.com/Open-MBEE/OpenSysML/internal/ir/view"
 	"github.com/Open-MBEE/OpenSysML/internal/semantic/symbols"
 	"github.com/Open-MBEE/OpenSysML/internal/syntax/source"
@@ -57,6 +58,30 @@ func (s *Session) Complete(line string, pos int) Completion {
 		word := lastField(head)
 		return completion(word, matchingPrefix(renderForms(), word))
 	}
+	if command == "%render-run" {
+		word := lastField(head)
+		switch index := argumentIndex(head); index {
+		case 1:
+			kinds := make([]string, 0, len(runtrace.Kinds()))
+			for _, kind := range runtrace.Kinds() {
+				kinds = append(kinds, string(kind))
+			}
+			return completion(word, matchingPrefix(kinds, word))
+		case 2:
+			return completion(word, matchingPrefix([]string{"text", "mermaid", "plantuml", "dot", "link="}, word))
+		case 3:
+			args := typedArgs(head)
+			options := []string{"link="}
+			if len(args) > 2 && strings.HasPrefix(args[2], "link=") {
+				options = []string{"text", "mermaid", "plantuml", "dot"}
+			}
+			return completion(word, matchingPrefix(options, word))
+		default:
+			if index > 3 {
+				return completion(word, nil)
+			}
+		}
+	}
 	if command == "%render" && atPaletteArgument(head) {
 		word := lastField(head)
 		return completion(word, matchingPrefix(renderPalettes(), word))
diff --git a/internal/frontend/repl/meta.go b/internal/frontend/repl/meta.go
index 265693ee9f..c56f45f7d4 100644
--- a/internal/frontend/repl/meta.go
+++ b/internal/frontend/repl/meta.go
@@ -29,7 +29,10 @@ import (
 
 // renderUsage is how %render is written: a view, the form to write it in, text
 // when none is named, then a palette, style and port display the form draws.
-const renderUsage = "usage: %render <name> [text|mermaid|markdown|dot|plantuml|d2|csv|tsv [palette] [pilot|cameo] [minimal|full] [verdicts] [link=<template>]]"
+const (
+	renderUsage    = "usage: %render <name> [text|mermaid|markdown|dot|plantuml|d2|csv|tsv [palette] [pilot|cameo] [minimal|full] [verdicts] [link=<template>]]"
+	renderRunUsage = "usage: %render-run <timeline|sequence> [text|mermaid|plantuml|dot] [link=<template>]"
+)
 
 // isMeta reports whether a trimmed input line is a meta command.
 func isMeta(line string) bool {
@@ -231,6 +234,7 @@ var metaCommandTable = []metaCommand{
 	{name: cmdSamples, group: groupBehavioral, args: "<n> <seed> <name>[(<args>)] [<object>] <p>=<from>..<to>...", desc: "run an analysis case or calc over <n> values drawn uniformly from each range with the given seed, and print the table"},
 	{name: cmdRuns, group: groupBehavioral, args: "<n> [<seed>] <action> [<observable>...]", desc: "run an action <n> times, each run's modeled randomness seeded from the given seed — left out under %draws min, max or average — and print the table of the observables with each one's distribution"},
 	{name: cmdRunQuery, group: groupBehavioral, args: "<name> [<p>=<expr>...]", desc: "execute a document query and print its rows, with each binding written as <parameter>=<expression>"},
+	{name: "%render-run", group: groupBehavioral, args: "<timeline|sequence> [form] [link=<template>]", desc: "render the recorded run as a state timeline or message sequence, optionally linking declarations to their source"},
 	{name: cmdRenderDocument, group: groupBehavioral, args: "<name> [mermaid|dot|plantuml|d2 [pilot|cameo]]", desc: "compile a document definition, run its queries and print the rendered Markdown, its graph-shaped diagrams as Mermaid, Graphviz DOT, PlantUML or D2"},
 	{name: "%constraint", group: groupBehavioral, args: argName, desc: "evaluate a constraint definition"},
 	{name: "%requirement", group: groupBehavioral, args: argName, desc: "evaluate a requirement definition"},
@@ -442,6 +446,8 @@ func (s *Session) metaSessionCommand(fields []string, line string) (metaResult,
 		return metaOut(s.doView(fields[1])), true
 	case "%render":
 		return metaOut(s.metaRender(fields[1:])), true
+	case "%render-run":
+		return metaOut(s.metaRenderRun(fields[1:])), true
 	case "%quit", "%exit":
 		return metaOut([]string{"goodbye"}, true, nil), true
 	}
diff --git a/internal/frontend/repl/query.go b/internal/frontend/repl/query.go
index ff49fc785c..5878506830 100644
--- a/internal/frontend/repl/query.go
+++ b/internal/frontend/repl/query.go
@@ -384,6 +384,20 @@ func (s *Session) instanceName(inst *runtime.Instance) string {
 	return ""
 }
 
+// runTraceLabel returns the label used for an object in a run rendering.
+func (s *Session) runTraceLabel(inst *runtime.Instance) string {
+	if inst == nil {
+		return ""
+	}
+	if label, ok := s.heldLabel(inst.ID); ok && label != "" {
+		return label
+	}
+	if label := s.instanceName(inst); label != "" {
+		return label
+	}
+	return fmt.Sprintf("#%d", inst.ID)
+}
+
 // resolveCheckTarget resolves the element a constraint/requirement check names.
 // The second result is non-nil for a check that cannot be made at all.
 func (s *Session) resolveCheckTarget(name string) (checkTarget, *Verdict) {
diff --git a/internal/frontend/repl/run_render.go b/internal/frontend/repl/run_render.go
new file mode 100644
index 0000000000..ef8f9eeded
--- /dev/null
+++ b/internal/frontend/repl/run_render.go
@@ -0,0 +1,94 @@
+package repl
+
+import (
+	"errors"
+	"fmt"
+	"slices"
+	"strings"
+
+	"github.com/Open-MBEE/OpenSysML/internal/exec/runtrace"
+	"github.com/Open-MBEE/OpenSysML/internal/ir/view"
+)
+
+func runViewKind(kind runtrace.Kind) view.Kind {
+	if kind == runtrace.KindTimeline {
+		return view.KindTimeline
+	}
+	return view.KindSequence
+}
+
+func (s *Session) metaRenderRun(args []string) ([]string, bool, error) {
+	if len(args) < 1 || len(args) > 3 {
+		return []string{renderRunUsage}, false, nil
+	}
+	kind, ok := runtrace.ParseKind(args[0])
+	if !ok {
+		return []string{fmt.Sprintf("unknown run rendering %q; want timeline or sequence; %s", args[0], renderRunUsage)}, false, nil
+	}
+	form := view.FormText
+	formSet := false
+	linkSet := false
+	links := view.Links{}
+	for _, arg := range args[1:] {
+		if strings.HasPrefix(arg, "link=") {
+			if linkSet {
+				return []string{renderRunUsage}, false, nil
+			}
+			links.Template = strings.TrimPrefix(arg, "link=")
+			if err := view.ParseLinkTemplate(links.Template); err != nil {
+				return []string{err.Error() + "; " + renderRunUsage}, false, nil
+			}
+			linkSet = true
+			continue
+		}
+		if formSet {
+			return []string{renderRunUsage}, false, nil
+		}
+		form = view.Form(arg)
+		if !slices.Contains(view.Forms(), form) {
+			return []string{fmt.Sprintf("unknown form %q; %s", arg, renderRunUsage)}, false, nil
+		}
+		formSet = true
+	}
+	if _, err := (&view.Rendering{Kind: runViewKind(kind), Run: true}).WriteWith(form, view.Options{Links: links}); err != nil {
+		return []string{"error: " + err.Error()}, false, nil
+	}
+	rendering, err := s.runTraceRendering(kind)
+	if errors.Is(err, runtrace.ErrNoTrace) {
+		return []string{"error: the session records no trace; %trace on before the run"}, false, nil
+	}
+	if err != nil {
+		return []string{"error: " + err.Error()}, false, nil
+	}
+	options := view.Options{Width: s.renderWidth, Links: links}
+	if links.Template != "" {
+		renderer, err := s.viewRenderer()
+		if err != nil {
+			return []string{"error: " + err.Error()}, false, nil
+		}
+		options.Links.Sites = renderer.Sites(s.sessionLocator())
+	}
+	lines, err := artifactLines(rendering, form, options)
+	if err != nil {
+		return []string{"error: " + err.Error()}, false, nil
+	}
+	return lines, false, nil
+}
+
+// RunTraceRendering renders the trace the session recorded so far.
+func (s *Session) RunTraceRendering(kind runtrace.Kind) (*view.Rendering, error) {
+	defer s.enter()()
+	return s.runTraceRendering(kind)
+}
+
+func (s *Session) runTraceRendering(kind runtrace.Kind) (*view.Rendering, error) {
+	trace := s.trace
+	var until float64
+	if s.rtCtx != nil {
+		if trace == nil {
+			trace = s.rtCtx.Trace()
+		}
+		until = s.rtCtx.Clock().Now()
+	}
+	return runtrace.Render(kind, trace, runtrace.Options{Label: s.runTraceLabel, Until: until})
+}
diff --git a/internal/frontend/repl/run_render_test.go b/internal/frontend/repl/run_render_test.go
new file mode 100644
index 0000000000..275797f878
--- /dev/null
+++ b/internal/frontend/repl/run_render_test.go
@@ -0,0 +1,122 @@
+package repl
+
+import (
+	"fmt"
+	"path/filepath"
+	"slices"
+	"strings"
+	"testing"
+)
+
+func TestRenderRunBuildsTimelineAndSequence(t *testing.T) {
+	s := loadFixture(t, "testdata/lamp_signals.sysml")
+	wants(t, run(t, s, "%trace on"), "trace: on")
+	wants(t, run(t, s, "%instantiate bulb"), "Created instance")
+	wants(t, run(t, s, "%state bulb"), "Current state: off")
+	run(t, s, "%send go")
+	run(t, s, "%advance 1")
+
+	timeline := run(t, s, "%render-run timeline")
+	wants(t, timeline, "run - timeline rendering", "Lamps::bulb.lamp", "on")
+	sequence := run(t, s, "%render-run sequence mermaid")
+	wants(t, sequence, "sequenceDiagram", "go")
+	wants(t, run(t, s, "%render-run timeline mermaid"), "gantt", "on (accept go)")
+	wants(t, run(t, s, "%render-run sequence text"), "run - sequence rendering", "go")
+}
+
+func TestRenderRunUsesHeldObjectPathLabels(t *testing.T) {
+	s := loadFixture(t, "testdata/run_render_nested.sysml")
+	run(t, s, "%trace on")
+	run(t, s, "%instantiate mission")
+	wants(t, run(t, s, "%state NestedRun::Controller::modes NestedRun::mission.controller"), "Debugging state machine", "NestedRun::mission.controller")
+	wants(t, run(t, s, "%advance 1"), "1.0")
+
+	wants(t, run(t, s, "%render-run timeline"), "NestedRun::mission.controller.modes")
+}
+
+func TestRenderRunLinksSourceDeclarations(t *testing.T) {
+	path, err := filepath.Abs(filepath.Join("..", "..", "..", "examples", "run-timeline", "run-timeline.sysml"))
+	if err != nil {
+		t.Fatalf("resolve example path: %v", err)
+	}
+	s := NewSession()
+	run(t, s, fmt.Sprintf("%%load %q", path))
+	run(t, s, "%trace on")
+	run(t, s, "%instantiate RunTimeline::mission")
+	verdicts := s.RunFor(nil, []Behavior{
+		{Name: "RunTimeline::Controller::modes", Performer: []string{"RunTimeline::mission.controller"}},
+		{Name: "RunTimeline::Instrument::modes", Performer: []string{"RunTimeline::mission.instrument"}},
+	}, 6)
+	if len(verdicts) != 2 {
+		t.Fatalf("behavior verdicts = %v, want both machine runs", verdicts)
+	}
+	for _, verdict := range verdicts {
+		if verdict.Status != VerdictHolds {
+			t.Fatalf("run verdict = %+v, want holds", verdict)
+		}
+	}
+
+	template := "https://example.test/src/{file}#L{line}"
+	sequence := run(t, s, "%render-run sequence mermaid link="+template)
+	wants(t, sequence, "link n0: Source @ https://example.test/src/", "RunTimeline::mission.controller")
+	timeline := run(t, s, "%render-run timeline plantuml link="+template)
+	wants(t, timeline, `[[https://example.test/src/`, "#L", "RunTimeline::mission.controller.modes")
+	wants(t, run(t, s, "%render-run timeline link=https://example.test/{missing}"), "unknown link template placeholder {missing}")
+}
+
+func TestRenderRunReportsMissingTraceAndRefusesDot(t *testing.T) {
+	fresh := NewSession()
+	wants(t, run(t, fresh, "%render-run timeline"), "error: the session records no trace; %trace on before the run")
+	wants(t, run(t, fresh, "%render-run"), renderRunUsage)
+	wants(t, run(t, fresh, "%render-run neither"), `unknown run rendering "neither"`, "timeline or sequence")
+	wants(t, run(t, fresh, "%render-run timeline svg"), `unknown form "svg"`)
+
+	s := loadFixture(t, "testdata/lamp_signals.sysml")
+	run(t, s, "%trace on")
+	run(t, s, "%instantiate bulb")
+	run(t, s, "%state bulb")
+	run(t, s, "%advance 1")
+	wants(t, run(t, s, "%render-run timeline dot"), "error:", "not written as dot")
+}
+
+func TestRenderRunWithoutRuntimeContext(t *testing.T) {
+	examplePath, err := filepath.Abs(filepath.Join("..", "..", "..", "examples", "run-timeline", "run-timeline.sysml"))
+	if err != nil {
+		t.Fatalf("resolve example path: %v", err)
+	}
+	s := NewSession()
+	run(t, s, fmt.Sprintf("%%load %q", examplePath))
+	run(t, s, "%trace on")
+	if s.rtCtx != nil {
+		t.Fatal("loading a model and enabling trace created a runtime context")
+	}
+
+	wants(t, run(t, s, "%render-run timeline"), "the run recorded no state; the rendering is empty")
+	wants(t, run(t, s, "%render-run sequence"), "the run recorded no message; the rendering is empty")
+
+	run(t, s, "%trace off")
+	wants(t, run(t, s, "%render-run timeline"), "error: the session records no trace; %trace on before the run")
+}
+
+func TestRenderRunCompletesKindAndForm(t *testing.T) {
+	s := NewSession()
+	if got := s.Complete("%render-run ti", len("%render-run ti")); !slices.Equal(got.Candidates, []string{"timeline"}) {
+		t.Errorf("completing run kind offered %v", got.Candidates)
+	}
+	if got := s.Complete("%render-run timeline p", len("%render-run timeline p")); !slices.Equal(got.Candidates, []string{"plantuml"}) {
+		t.Errorf("completing run form offered %v", got.Candidates)
+	}
+	if got := s.Complete("%render-run timeline l", len("%render-run timeline l")); !slices.Equal(got.Candidates, []string{"link="}) {
+		t.Errorf("completing run link offered %v", got.Candidates)
+	}
+	if got := s.Complete("%render-run timeline plantuml l", len("%render-run timeline plantuml l")); !slices.Equal(got.Candidates, []string{"link="}) {
+		t.Errorf("completing run link after form offered %v", got.Candidates)
+	}
+	if got := s.Complete("%render-run sequence link=x m", len("%render-run sequence link=x m")); !slices.Equal(got.Candidates, []string{"mermaid"}) {
+		t.Errorf("completing run form after link offered %v", got.Candidates)
+	}
+	if got := s.Complete("%render-run timeline plantuml link=x ", len("%render-run timeline plantuml link=x ")); len(got.Candidates) != 0 {
+		t.Errorf("completion after run-render link argument offered %v, want no candidates", got.Candidates)
+	}
+	wants(t, strings.Join(helpText(), "\n"), "%render-run <timeline|sequence> [form] [link=<template>]")
+}
diff --git a/internal/frontend/repl/session.go b/internal/frontend/repl/session.go
index 6aafbac44c..172a7b23d1 100644
--- a/internal/frontend/repl/session.go
+++ b/internal/frontend/repl/session.go
@@ -135,7 +135,8 @@ type Session struct {
 	notedBlocker blockerNote
 
 	// trace records execution steps while tracing is on, nil otherwise.
-	trace *runtime.TraceRecorder
+	trace       *runtime.TraceRecorder
+	traceSilent bool
 
 	// budgets bounds every runtime context this session creates.
 	budgets runtime.Budgets
diff --git a/internal/frontend/repl/testdata/run_render_nested.sysml b/internal/frontend/repl/testdata/run_render_nested.sysml
new file mode 100644
index 0000000000..b0f3a0a86d
--- /dev/null
+++ b/internal/frontend/repl/testdata/run_render_nested.sysml
@@ -0,0 +1,17 @@
+package NestedRun {
+    private import SI::*;
+
+    part def Controller {
+        exhibit state modes {
+            entry; then waiting;
+            state waiting;
+            transition first waiting accept after 1 [s] then done;
+        }
+    }
+
+    part def Mission {
+        part controller : Controller;
+    }
+
+    part mission : Mission;
+}
diff --git a/internal/frontend/repl/trace.go b/internal/frontend/repl/trace.go
index d55ffba8cf..d60460ab00 100644
--- a/internal/frontend/repl/trace.go
+++ b/internal/frontend/repl/trace.go
@@ -37,7 +37,7 @@ func (s *Session) noteSummary(notes []runtime.RunNote, before int) []string {
 		parts = append(parts, fmt.Sprintf("%d %s", diverged, plural(diverged, "tool answer diverged", "tool answers diverged")))
 	}
 	line := "  " + strings.Join(parts, "; ")
-	if s.trace == nil {
+	if s.trace == nil || s.traceSilent {
 		line += "; %trace on to see them"
 	}
 	return []string{line}
@@ -50,7 +50,7 @@ const tracePrefix = "[trace] "
 // Tracing reports whether execution steps are being recorded.
 func (s *Session) Tracing() bool {
 	defer s.reading()()
-	return s.trace != nil
+	return s.trace != nil && !s.traceSilent
 }
 
 // SetTracing turns recording of execution steps on or off. It takes effect at
@@ -61,13 +61,33 @@ func (s *Session) SetTracing(on bool) {
 	s.setTracing(on)
 }
 
-func (s *Session) setTracing(on bool) {
+// SetRecording records typed execution events without printing trace lines.
+func (s *Session) SetRecording(on bool) {
+	defer s.enter()()
 	switch {
 	case on && s.trace == nil:
+		s.trace = runtime.NewEventRecorder(0)
+		s.traceSilent = true
+	case !on:
+		s.trace = nil
+		s.traceSilent = false
+	}
+	s.attachTrace()
+}
+
+func (s *Session) setTracing(on bool) {
+	switch {
+	case on && (s.trace == nil || s.traceSilent):
 		s.trace = runtime.NewTraceRecorder()
+		s.traceSilent = false
 	case !on:
 		s.trace = nil
+		s.traceSilent = false
 	}
+	s.attachTrace()
+}
+
+func (s *Session) attachTrace() {
 	if s.rtCtx != nil {
 		s.rtCtx.SetTrace(s.trace)
 	}
@@ -89,7 +109,7 @@ func onOff(on bool) string {
 // drainTrace returns what was recorded since the last command, prefixed, and
 // resets the recorder so each command reports only its own steps.
 func (s *Session) drainTrace() []string {
-	if s.trace == nil {
+	if s.trace == nil || s.traceSilent {
 		return nil
 	}
 	entries := s.trace.Entries()
diff --git a/internal/ir/view/d2.go b/internal/ir/view/d2.go
index bd1cb64ac9..805e611fa2 100644
--- a/internal/ir/view/d2.go
+++ b/internal/ir/view/d2.go
@@ -25,8 +25,8 @@ func (r *Rendering) D2() (string, error) {
 // look, and asking for one is noticed. Positions and routes are kept as
 // comments, D2 laying the diagram out itself.
 func (r *Rendering) D2With(options Options) (string, error) {
-	if !r.Kind.SupportsForm(FormD2) {
-		return "", &WrongFormError{Form: FormD2, Kind: r.Kind, View: r.View}
+	if !r.supportsForm(FormD2) {
+		return "", r.wrongFormError(FormD2)
 	}
 	if err := options.Palette.check(); err != nil {
 		return "", err
diff --git a/internal/ir/view/data.go b/internal/ir/view/data.go
index 99bd8927e2..ae14f3ae9d 100644
--- a/internal/ir/view/data.go
+++ b/internal/ir/view/data.go
@@ -11,6 +11,10 @@ type Data struct {
 	// Kind is the rendering produced, and Stated how the kind was decided.
 	Kind   Kind
 	Stated string
+	// Run marks a rendering of a run's trace rather than of a view.
+	Run bool
+	// RunUntil is the clock instant through which a run rendering was recorded.
+	RunUntil float64
 	// Nodes are every node of the rendering, parents before children, each
 	// naming its parent.
 	Nodes []NodeData
@@ -19,6 +23,8 @@ type Data struct {
 	// Columns and Rows are the tabular rendering, empty for every other kind.
 	Columns []string
 	Rows    []RowData
+	// Lanes are a run timeline's object machines.
+	Lanes []Lane
 	// Canvas is the drawing surface the view states, nil for none.
 	Canvas *Canvas
 	// Notes are the note boxes drawn on the canvas, anchored to a node ID or free.
@@ -95,13 +101,16 @@ func (r *Rendering) DataFor(display Ports) Data {
 
 func (r *Rendering) data(ports *portView) Data {
 	out := Data{
-		View:    r.View,
-		Kind:    r.Kind,
-		Stated:  r.Stated,
-		Columns: r.Columns,
-		Canvas:  r.Canvas,
-		Notes:   r.Notes,
-		Notices: r.Notices,
+		View:     r.View,
+		Kind:     r.Kind,
+		Stated:   r.Stated,
+		Run:      r.Run,
+		RunUntil: r.RunUntil,
+		Columns:  r.Columns,
+		Lanes:    r.Lanes,
+		Canvas:   r.Canvas,
+		Notes:    r.Notes,
+		Notices:  r.Notices,
 	}
 	for _, root := range r.Roots {
 		out.Nodes = appendNodeData(out.Nodes, root, "", ports)
diff --git a/internal/ir/view/dot.go b/internal/ir/view/dot.go
index e3ef491ef1..350738100d 100644
--- a/internal/ir/view/dot.go
+++ b/internal/ir/view/dot.go
@@ -52,8 +52,8 @@ func (r *Rendering) DOT() (string, error) {
 // control nodes a migration made up are elided (withoutStandIns). The layout is
 // the same whatever the palette: it changes fills and borders alone.
 func (r *Rendering) DOTWith(options Options) (string, error) {
-	if !r.Kind.SupportsForm(FormDot) {
-		return "", &WrongFormError{Form: FormDot, Kind: r.Kind, View: r.View}
+	if !r.supportsForm(FormDot) {
+		return "", r.wrongFormError(FormDot)
 	}
 	if err := options.Palette.check(); err != nil {
 		return "", err
diff --git a/internal/ir/view/form.go b/internal/ir/view/form.go
index 441582a80b..b99dd939b0 100644
--- a/internal/ir/view/form.go
+++ b/internal/ir/view/form.go
@@ -65,6 +65,9 @@ const (
 
 // MachineForm is the machine-readable form of renderings of this kind.
 func (k Kind) MachineForm() Form {
+	if k == KindTimeline {
+		return FormMermaid
+	}
 	if k.Tabular() {
 		return FormMarkdown
 	}
@@ -92,7 +95,7 @@ func (k Kind) SupportsForm(form Form) bool {
 		}
 	case FormPlantUML:
 		switch k {
-		case KindTree, KindInterconnection, KindState, KindAction, KindCase, KindMixed, KindSequence, KindRequirement, KindDefinition, KindPackage:
+		case KindTree, KindInterconnection, KindState, KindAction, KindCase, KindMixed, KindSequence, KindRequirement, KindDefinition, KindPackage, KindTimeline:
 			return true
 		}
 	case FormD2:
@@ -130,11 +133,22 @@ type WrongFormError struct {
 	Form Form
 	Kind Kind
 	View string
+	run  bool
 }
 
 func (e *WrongFormError) Error() string {
+	forms := e.Kind.SupportedForms()
+	if e.run {
+		runForms := make([]Form, 0, len(forms))
+		for _, form := range forms {
+			if form != FormD2 {
+				runForms = append(runForms, form)
+			}
+		}
+		forms = runForms
+	}
 	msg := fmt.Sprintf("%s %s rendering is not written as %s; ask for %s",
-		e.Kind.article(), e.Kind, e.Form, joinForms(e.Kind.SupportedForms(), "or"))
+		e.Kind.article(), e.Kind, e.Form, joinForms(forms, "or"))
 	if e.View == "" {
 		return msg
 	}
@@ -152,6 +166,17 @@ func joinForms(forms []Form, conjunction string) string {
 
 func (e *WrongFormError) Unwrap() error { return ErrWrongForm }
 
+func (r *Rendering) supportsForm(form Form) bool {
+	if r.Run && form == FormD2 {
+		return false
+	}
+	return r.Kind.SupportsForm(form)
+}
+
+func (r *Rendering) wrongFormError(form Form) *WrongFormError {
+	return &WrongFormError{Form: form, Kind: r.Kind, View: r.View, run: r.Run}
+}
+
 // Options are what a rendering is written with beside its form. Each form
 // takes the ones that apply to it: the text form its Width, Mermaid, DOT,
 // PlantUML and D2 their Direction, Palette, Style and Unplaced, and the
@@ -202,8 +227,8 @@ func (r *Rendering) WriteWith(form Form, options Options) (string, error) {
 	case FormText:
 		return r.textWith(options), nil
 	case FormMermaid, FormMarkdown, FormDot, FormPlantUML, FormD2, FormCSV, FormTSV:
-		if !r.Kind.SupportsForm(form) {
-			return "", &WrongFormError{Form: form, Kind: r.Kind, View: r.View}
+		if !r.supportsForm(form) {
+			return "", r.wrongFormError(form)
 		}
 		switch form {
 		case FormMarkdown:
diff --git a/internal/ir/view/mermaid.go b/internal/ir/view/mermaid.go
index 568fdd9e77..3bc23a7c3f 100644
--- a/internal/ir/view/mermaid.go
+++ b/internal/ir/view/mermaid.go
@@ -39,6 +39,9 @@ func (r *Rendering) Mermaid() string {
 // returns. A rendering positioned by Layout draws the nodes the DOT form draws:
 // the placed ones, and the unplaced ones too under UnplacedStrip.
 func (r *Rendering) MermaidWith(options Options) string {
+	if r.Run && r.Kind == KindTimeline {
+		return r.runTimelineMermaid(options)
+	}
 	r = r.settleUnplaced(options.Unplaced, FormMermaid)
 	direction := options.Direction
 	var b strings.Builder
@@ -46,7 +49,9 @@ func (r *Rendering) MermaidWith(options Options) string {
 	labels.skin = skinOf(options.Style)
 	ports := r.portView(options.Ports)
 	r.writeMermaidFrontmatter(&b, labels, options, ports)
-	if r.View == "" {
+	if r.Run {
+		fmt.Fprintf(&b, "%%%% run — %s rendering", r.Kind)
+	} else if r.View == "" {
 		fmt.Fprintf(&b, "%%%% %s rendering", r.Kind)
 	} else {
 		fmt.Fprintf(&b, "%%%% %s — %s rendering", r.View, r.Kind)
@@ -490,6 +495,10 @@ func (r *Rendering) writeMermaidFrontmatter(b *strings.Builder, labels labeller,
 		fmt.Fprintf(b, "  themeCSS: %q\n",
 			".edgeLabel rect { opacity: 1 !important; } "+mermaidTitleCSS)
 	}
+	if r.Run && r.Kind == KindTimeline {
+		b.WriteString("  gantt:\n    displayMode: compact\n")
+		fmt.Fprintf(b, "    leftPadding: %d\n", runTimelineMermaidLeftPadding(r.Lanes))
+	}
 	b.WriteString("  themeVariables:\n")
 	variables := []themeVariable{
 		{"fontFamily", font},
@@ -1644,7 +1653,11 @@ func (r *Rendering) writeSequenceDiagram(b *strings.Builder, labels labeller, op
 		return
 	}
 	for _, node := range r.Roots {
-		fmt.Fprintf(b, "  participant %s as %s\n", node.ID, labels.mermaid(node))
+		label := labels.mermaid(node)
+		if r.Run {
+			label = mermaidText(runParticipantLabel(node))
+		}
+		fmt.Fprintf(b, "  participant %s as %s\n", node.ID, label)
 		if url, ok := options.Links.URL(node.Origin); ok {
 			fmt.Fprintf(b, "  link %s: Source @ %s\n", node.ID, url)
 		}
diff --git a/internal/ir/view/palette.go b/internal/ir/view/palette.go
index 7fc5373286..4b33e8007b 100644
--- a/internal/ir/view/palette.go
+++ b/internal/ir/view/palette.go
@@ -104,6 +104,9 @@ var paletteForms = []Form{FormDot, FormMermaid, FormPlantUML, FormD2}
 // SupportsPalette reports whether a rendering of the kind is drawn as nodes a
 // palette can fill: the kinds a form that fills nodes is written for.
 func (k Kind) SupportsPalette() bool {
+	if k == KindTimeline {
+		return false
+	}
 	return slices.ContainsFunc(paletteForms, k.SupportsForm)
 }
 
diff --git a/internal/ir/view/plantuml.go b/internal/ir/view/plantuml.go
index 459cd2e660..eb8bddf231 100644
--- a/internal/ir/view/plantuml.go
+++ b/internal/ir/view/plantuml.go
@@ -24,8 +24,8 @@ func (r *Rendering) PlantUML() (string, error) {
 // UnplacedStrip. Placement itself is written as comments, PlantUML having no
 // absolute positions; for pinned positions use the DOT form.
 func (r *Rendering) PlantUMLWith(options Options) (string, error) {
-	if !r.Kind.SupportsForm(FormPlantUML) {
-		return "", &WrongFormError{Form: FormPlantUML, Kind: r.Kind, View: r.View}
+	if !r.supportsForm(FormPlantUML) {
+		return "", r.wrongFormError(FormPlantUML)
 	}
 	if err := options.Palette.check(); err != nil {
 		return "", err
@@ -36,6 +36,9 @@ func (r *Rendering) PlantUMLWith(options Options) (string, error) {
 	if err := options.Ports.check(); err != nil {
 		return "", err
 	}
+	if r.Run && r.Kind == KindTimeline {
+		return r.runTimelinePlantUML(options), nil
+	}
 	r = r.settleUnplaced(options.Unplaced, FormPlantUML)
 	w := &plantumlWriter{kind: r.Kind, borders: r.Kind.paletteBorders(), fills: familyFills{palette: options.Palette, tree: r.Kind == KindTree},
 		labels: labelsOf(r.Roots, false, nil), ports: r.portView(options.Ports), links: options.Links,
@@ -72,7 +75,9 @@ func (r *Rendering) PlantUMLWith(options Options) (string, error) {
 	notices = append(notices, r.visualNotices(noFontOrEdgeStyle, true)...)
 	b := &w.b
 	b.WriteString("@startuml\n")
-	if r.View == "" {
+	if r.Run {
+		fmt.Fprintf(b, "' run — %s rendering", r.Kind)
+	} else if r.View == "" {
 		fmt.Fprintf(b, "' %s rendering", r.Kind)
 	} else {
 		fmt.Fprintf(b, "' %s — %s rendering", r.View, r.Kind)
@@ -459,7 +464,11 @@ func (w *plantumlWriter) writeSequenceDiagram(r *Rendering) {
 		return
 	}
 	for _, node := range r.Roots {
-		fmt.Fprintf(b, "participant %s as %s%s\n", plantumlQuote(w.plantumlLabel(node)), node.ID, w.decoration(node))
+		label := w.plantumlLabel(node)
+		if r.Run {
+			label = plantumlText(runParticipantLabel(node))
+		}
+		fmt.Fprintf(b, "participant %s as %s%s\n", plantumlQuote(label), node.ID, w.decoration(node))
 	}
 	for _, edge := range r.Edges {
 		w.writeArrowEdge(edge, edge.From, edge.To, true)
@@ -686,7 +695,7 @@ func plantumlText(text string) string {
 		switch {
 		case c == '\n':
 			out.WriteString(`\n`)
-		case strings.ContainsRune(`"\<>~`, c),
+		case strings.ContainsRune(`"#\<>~`, c),
 			strings.ContainsRune("*/_-[]", c) && (i > 0 && runes[i-1] == c || i+1 < len(runes) && runes[i+1] == c):
 			fmt.Fprintf(&out, "<U+%04X>", c)
 		default:
diff --git a/internal/ir/view/plantuml_test.go b/internal/ir/view/plantuml_test.go
index b3491ffe8d..2da88aa070 100644
--- a/internal/ir/view/plantuml_test.go
+++ b/internal/ir/view/plantuml_test.go
@@ -497,6 +497,7 @@ func TestPlantUMLSequencePaletteFillsParticipants(t *testing.T) {
 func TestPlantUMLEscapesLabels(t *testing.T) {
 	cases := map[string]string{
 		`say "hi"`:               `say <U+0022>hi<U+0022>`,
+		`#<id>`:                  `<U+0023><U+003C>id<U+003E>`,
 		`a\b`:                    `a<U+005C>b`,
 		"x<b>y":                  "x<U+003C>b<U+003E>y",
 		"a**b //c d__e f--g":     "a<U+002A><U+002A>b <U+002F><U+002F>c d<U+005F><U+005F>e f<U+002D><U+002D>g",
diff --git a/internal/ir/view/run_timeline.go b/internal/ir/view/run_timeline.go
new file mode 100644
index 0000000000..5b696e0d2c
--- /dev/null
+++ b/internal/ir/view/run_timeline.go
@@ -0,0 +1,331 @@
+package view
+
+import (
+	"fmt"
+	"math"
+	"sort"
+	"strconv"
+	"strings"
+	"unicode/utf8"
+)
+
+func writeRunTimelineText(b *strings.Builder, r *Rendering) {
+	if len(r.Lanes) == 0 {
+		b.WriteString(r.EmptyReason() + "\n")
+		return
+	}
+	for i, lane := range r.Lanes {
+		if i > 0 {
+			b.WriteString("\n")
+		}
+		b.WriteString(lane.Name + "\n")
+		width := 0
+		times := make([]string, len(lane.Spans))
+		for i, span := range lane.Spans {
+			times[i] = runInstant(span.From) + " .. " + runInstant(span.To)
+			width = max(width, utf8.RuneCountInString(times[i]))
+		}
+		for i, span := range lane.Spans {
+			fmt.Fprintf(b, "  %s%s  %s", times[i], strings.Repeat(" ", width-utf8.RuneCountInString(times[i])), span.State)
+			if len(span.Triggers) > 0 {
+				fmt.Fprintf(b, " (%s)", strings.Join(span.Triggers, ", "))
+			}
+			if len(span.Through) > 0 {
+				fmt.Fprintf(b, "  via %s", strings.Join(span.Through, ", "))
+			}
+			if span.Open {
+				b.WriteString("  (held at the end)")
+			}
+			b.WriteString("\n")
+		}
+		if len(lane.Transitions) > 0 {
+			b.WriteString("  transitions:\n")
+			for _, transition := range lane.Transitions {
+				fmt.Fprintf(b, "    t=%s %s -> %s", runInstant(transition.At), transition.From, transition.To)
+				if transition.Event != "" {
+					fmt.Fprintf(b, " (%s)", transition.Event)
+				}
+				b.WriteString("\n")
+			}
+		}
+		if len(lane.Marks) > 0 {
+			b.WriteString("  noted:\n")
+			for _, mark := range lane.Marks {
+				fmt.Fprintf(b, "    t=%s %s\n", runInstant(mark.At), mark.Text)
+			}
+		}
+	}
+}
+
+func (r *Rendering) runTimelineMermaid(options Options) string {
+	var b strings.Builder
+	r.writeMermaidFrontmatter(&b, labelsOf(nil, false, nil), options, portView{})
+	fmt.Fprintf(&b, "%%%% run — %s rendering", r.Kind)
+	if r.Stated != "" {
+		fmt.Fprintf(&b, " (%s)", r.Stated)
+	}
+	b.WriteString("\n")
+	notices := append([]string(nil), r.Notices...)
+	notices = append(notices, r.mermaidTimelineNotices()...)
+	for _, notice := range notices {
+		fmt.Fprintf(&b, "%%%% not represented: %s\n", notice)
+	}
+	if len(r.Lanes) == 0 {
+		fmt.Fprintf(&b, "%%%% %s\n", r.EmptyReason())
+	} else {
+		for _, lane := range r.Lanes {
+			for _, mark := range lane.Marks {
+				text := strings.NewReplacer("\r", " ", "\n", " ").Replace(mark.Text)
+				fmt.Fprintf(&b, "%%%% t=%s %s\n", runInstant(mark.At), text)
+			}
+		}
+	}
+	b.WriteString("gantt\n")
+	b.WriteString("    dateFormat x\n")
+	b.WriteString("    axisFormat %M:%S.%L\n")
+	b.WriteString("    todayMarker off\n")
+	for _, lane := range r.Lanes {
+		fmt.Fprintf(&b, "    section %s\n", ganttText(lane.Name))
+		for i, span := range lane.Spans {
+			if span.To <= span.From {
+				continue
+			}
+			label := timelineStateLabel(span)
+			fmt.Fprintf(&b, "        %s :%ss%d, %d, %d\n",
+				ganttText(label), lane.ID, i, runMilliseconds(span.From), runMilliseconds(span.To))
+		}
+	}
+	return b.String()
+}
+
+func (r *Rendering) mermaidTimelineNotices() []string {
+	var notices []string
+	fractional := !wholeMillisecond(r.RunUntil)
+	for _, lane := range r.Lanes {
+		for _, span := range lane.Spans {
+			fractional = fractional || !wholeMillisecond(span.From) || !wholeMillisecond(span.To)
+		}
+		for _, transition := range lane.Transitions {
+			fractional = fractional || !wholeMillisecond(transition.At)
+		}
+		for _, mark := range lane.Marks {
+			fractional = fractional || !wholeMillisecond(mark.At)
+		}
+	}
+	if notice := timelineZeroSpanNotice(r.Lanes); notice != "" {
+		notices = append(notices, notice)
+	}
+	if fractional {
+		notices = append(notices, "instants are rounded to the nearest millisecond")
+	}
+	if r.RunUntil >= 3600 {
+		notices = append(notices, "the axis reads minutes and seconds; it wraps past an hour")
+	}
+	for _, lane := range r.Lanes {
+		if len(lane.Marks) > 0 {
+			notices = append(notices, "Mermaid gantt draws no note; choice and guard records are comments")
+			break
+		}
+	}
+	return notices
+}
+
+func (r *Rendering) runTimelinePlantUML(options Options) string {
+	var b strings.Builder
+	b.WriteString("@startuml\n")
+	fmt.Fprintf(&b, "' run — %s rendering", r.Kind)
+	if r.Stated != "" {
+		fmt.Fprintf(&b, " (%s)", r.Stated)
+	}
+	b.WriteString("\n")
+	notices := append([]string(nil), r.Notices...)
+	if notice := timelineZeroSpanNotice(r.Lanes); notice != "" {
+		notices = append(notices, notice)
+	}
+	for _, notice := range notices {
+		fmt.Fprintf(&b, "' not represented: %s\n", strings.ReplaceAll(notice, "\n", " "))
+	}
+	if len(r.Lanes) == 0 {
+		fmt.Fprintf(&b, "' %s\n@enduml\n", r.EmptyReason())
+		return b.String()
+	}
+	fmt.Fprintf(&b, "scale 1 as %s pixels\n", strconv.FormatFloat(timelineScale(r.Lanes, r.RunUntil), 'f', -1, 64))
+	for _, lane := range r.Lanes {
+		label := plantumlTimelineLabel(options.Links, lane.Origin, lane.Name)
+		fmt.Fprintf(&b, "concise %s as %s\n", plantumlQuote(label), lane.ID)
+	}
+	var changes []timelineChange
+	until := r.RunUntil
+	for _, lane := range r.Lanes {
+		lastDrawn := -1
+		for i, span := range lane.Spans {
+			if span.To > span.From {
+				lastDrawn = i
+			}
+		}
+		for i, span := range lane.Spans {
+			if span.To <= span.From {
+				continue
+			}
+			label := plantumlTimelineLabel(options.Links, span.Origin, timelineStateLabel(span))
+			changes = append(changes, timelineChange{span.From, fmt.Sprintf("%s is %s", lane.ID, plantumlQuote(label))})
+			if !span.Open && i == lastDrawn && span.To < until {
+				changes = append(changes, timelineChange{span.To, lane.ID + " is {hidden}"})
+			}
+		}
+		for _, mark := range lane.Marks {
+			changes = append(changes, timelineChange{mark.At, fmt.Sprintf("note top of %s : %s", lane.ID, plantumlText(mark.Text))})
+		}
+	}
+	for _, lane := range r.Lanes {
+		changes = append(changes, timelineChange{at: until, line: lane.ID + " is {hidden}"})
+	}
+	changes = append(changes, timelineChange{at: until})
+	sort.SliceStable(changes, func(i, j int) bool { return changes[i].at < changes[j].at })
+	last := math.NaN()
+	for _, item := range changes {
+		if math.IsNaN(last) || item.at != last {
+			fmt.Fprintf(&b, "@%s\n", runInstant(item.at))
+			last = item.at
+		}
+		if item.line != "" {
+			b.WriteString(item.line + "\n")
+		}
+	}
+	b.WriteString("@enduml\n")
+	return b.String()
+}
+
+func plantumlTimelineLabel(links Links, origin Origin, label string) string {
+	text := plantumlText(label)
+	url, ok := links.URL(origin)
+	if !ok || !safePlantUMLLinkURL(url) {
+		return text
+	}
+	for _, r := range label {
+		if r < 0x20 && r != '\n' {
+			return text
+		}
+	}
+	text = strings.NewReplacer("[", "<U+005B>", "]", "<U+005D>").Replace(text)
+	return "[[" + url + " " + text + "]]"
+}
+
+func safePlantUMLLinkURL(url string) bool {
+	if url == "" {
+		return false
+	}
+	for i := 0; i < len(url); i++ {
+		c := url[i]
+		if c >= 'a' && c <= 'z' || c >= 'A' && c <= 'Z' || c >= '0' && c <= '9' ||
+			strings.ContainsRune("-._~:/?#@!$&'()*+,;=", rune(c)) {
+			continue
+		}
+		if c == '%' && i+2 < len(url) && plantumlHexDigit(url[i+1]) && plantumlHexDigit(url[i+2]) {
+			i += 2
+			continue
+		}
+		return false
+	}
+	return true
+}
+
+func plantumlHexDigit(c byte) bool {
+	return c >= '0' && c <= '9' || c >= 'a' && c <= 'f' || c >= 'A' && c <= 'F'
+}
+
+func timelineZeroSpanNotice(lanes []Lane) string {
+	zero := 0
+	for _, lane := range lanes {
+		for _, span := range lane.Spans {
+			if span.To <= span.From {
+				zero++
+			}
+		}
+	}
+	if zero == 0 {
+		return ""
+	}
+	verb := "are"
+	if zero == 1 {
+		verb = "is"
+	}
+	return fmt.Sprintf("%d %s held for no time %s listed in the text form",
+		zero, plural(zero, "state", "states"), verb)
+}
+
+type timelineChange struct {
+	at   float64
+	line string
+}
+
+func timelineScale(lanes []Lane, until float64) float64 {
+	const (
+		minimumSpanWidth = 140.0
+		characterWidth   = 7.0
+		labelPadding     = 24.0
+		maximumWidth     = 4000.0
+	)
+	duration := math.Max(0, until)
+	scale := 1.0
+	for _, lane := range lanes {
+		for _, span := range lane.Spans {
+			spanDuration := span.To - span.From
+			if spanDuration > 0 {
+				duration = math.Max(duration, span.To)
+				labelWidth := float64(utf8.RuneCountInString(timelineStateLabel(span)))*characterWidth + labelPadding
+				spanWidth := math.Max(minimumSpanWidth, labelWidth)
+				scale = math.Max(scale, math.Ceil(spanWidth/spanDuration))
+			}
+		}
+	}
+	if duration > 0 && scale*duration > maximumWidth {
+		scale = maximumWidth / duration
+	}
+	return scale
+}
+
+func runTimelineMermaidLeftPadding(lanes []Lane) int {
+	const (
+		defaultPadding = 75
+		characterWidth = 7
+		labelPadding   = 24
+	)
+	padding := defaultPadding
+	for _, lane := range lanes {
+		padding = max(padding, utf8.RuneCountInString(lane.Name)*characterWidth+labelPadding)
+	}
+	return padding
+}
+
+func timelineStateLabel(span Span) string {
+	label := span.State
+	if len(span.Triggers) > 0 {
+		label += " (" + strings.Join(span.Triggers, ", ") + ")"
+	}
+	return label
+}
+
+func runInstant(instant float64) string {
+	return strconv.FormatFloat(instant, 'g', -1, 64)
+}
+
+func runMilliseconds(instant float64) int64 {
+	return int64(math.Round(instant * 1000))
+}
+
+func wholeMillisecond(instant float64) bool {
+	scaled := instant * 1000
+	return math.Abs(scaled-math.Round(scaled)) < 1e-7
+}
+
+func plural(count int, singular, plural string) string {
+	if count == 1 {
+		return singular
+	}
+	return plural
+}
+
+func ganttText(text string) string {
+	return strings.NewReplacer("\r", " ", "\n", " ", ":", "#58;", "#", "#35;", ";", "#59;").Replace(text)
+}
diff --git a/internal/ir/view/run_timeline_test.go b/internal/ir/view/run_timeline_test.go
new file mode 100644
index 0000000000..962a4f2e39
--- /dev/null
+++ b/internal/ir/view/run_timeline_test.go
@@ -0,0 +1,467 @@
+package view
+
+import (
+	"errors"
+	"slices"
+	"strings"
+	"testing"
+
+	"github.com/Open-MBEE/OpenSysML/internal/syntax/source"
+)
+
+func TestTimelineKindIsOnlyAStandaloneRunKind(t *testing.T) {
+	if KindTimeline.Supported() || slices.Contains(Kinds(), KindTimeline) {
+		t.Errorf("timeline is offered as a view kind: supported=%t kinds=%v", KindTimeline.Supported(), Kinds())
+	}
+	if _, ok := PseudoViewKind("timeline"); ok {
+		t.Error("#timeline resolves to a pseudo-view")
+	}
+	if _, _, ok := ParsePseudoView("#timeline"); ok {
+		t.Error("#timeline parses as a pseudo-view")
+	}
+	if KindTimeline.MachineForm() != FormMermaid {
+		t.Errorf("timeline machine form = %s, want mermaid", KindTimeline.MachineForm())
+	}
+	for _, form := range []Form{FormText, FormMermaid, FormPlantUML} {
+		if !KindTimeline.SupportsForm(form) {
+			t.Errorf("timeline does not support %s", form)
+		}
+	}
+	for _, form := range []Form{FormMarkdown, FormDot, FormD2, FormCSV, FormTSV} {
+		rendering := &Rendering{Kind: KindTimeline, Run: true}
+		if KindTimeline.SupportsForm(form) {
+			t.Errorf("timeline supports %s", form)
+		}
+		if _, err := rendering.Write(form); !errors.Is(err, ErrWrongForm) {
+			t.Errorf("timeline in %s: error = %v, want ErrWrongForm", form, err)
+		}
+	}
+}
+
+func TestRunSequenceDoesNotSupportD2(t *testing.T) {
+	rendering := &Rendering{Kind: KindSequence, Run: true}
+	_, err := rendering.WriteWith(FormD2, Options{})
+	var wrong *WrongFormError
+	if !errors.As(err, &wrong) {
+		t.Fatalf("WriteWith(d2) = %v, want WrongFormError", err)
+	}
+	if got, want := err.Error(), "a sequence rendering is not written as d2; ask for text, mermaid or plantuml"; got != want {
+		t.Errorf("WriteWith(d2) error = %q, want %q", got, want)
+	}
+}
+
+func TestRunTimelineTextWritesLanesSpansTransitionsAndMarks(t *testing.T) {
+	rendering := &Rendering{
+		Kind: KindTimeline, Run: true, RunUntil: 4, Stated: "the trace of a run to t = 4",
+		Lanes: []Lane{{
+			ID: "l0", Name: "T::rover.Machine",
+			Spans: []Span{
+				{State: "closed", From: 0, To: 1.5},
+				{State: "open | parked", From: 1.5, To: 4, Triggers: []string{"accept Open"}, Through: []string{"a", "b"}, Open: true},
+			},
+			Transitions: []LaneTransition{{At: 1.5, From: "closed", To: "open", Event: "accept Open"}},
+			Marks:       []Mark{{At: 1.5, Kind: "choice", Text: "choice entering open: parked(entry), opening(entry)"}},
+		}},
+		Notices: []string{"one earlier record was dropped"},
+	}
+	text := rendering.Text()
+	for _, want := range []string{
+		"run - timeline rendering (the trace of a run to t = 4)",
+		"T::rover.Machine",
+		"0 .. 1.5  closed",
+		"1.5 .. 4  open | parked (accept Open)  via a, b  (held at the end)",
+		"transitions:",
+		"t=1.5 closed -> open (accept Open)",
+		"noted:",
+		"t=1.5 choice entering open: parked(entry), opening(entry)",
+		"not represented:",
+		"one earlier record was dropped",
+	} {
+		if !strings.Contains(text, want) {
+			t.Errorf("timeline text is missing %q:\n%s", want, text)
+		}
+	}
+	if !rendering.Data().Run || rendering.Data().RunUntil != 4 || len(rendering.Data().Lanes) != 1 {
+		t.Errorf("timeline data = %+v, want its run and lane", rendering.Data())
+	}
+}
+
+func TestRunTimelineMermaidWritesCompactGantt(t *testing.T) {
+	rendering := &Rendering{
+		Kind: KindTimeline, Run: true, RunUntil: 3600.5, Stated: "the trace of a run to t = 3600.5",
+		Lanes: []Lane{{
+			ID: "l0", Name: "lane: # ;",
+			Spans: []Span{
+				{State: "idle: #;", From: 0, To: 0.2505},
+				{State: "ready", From: 0.2505, To: 3600.5, Triggers: []string{"accept Go"}, Open: true},
+				{State: "instant", From: 3600.5, To: 3600.5},
+			},
+			Marks: []Mark{{At: 0.125, Kind: "guard", Text: "guard: x\nnot evaluated"}},
+		}},
+	}
+	mermaid := rendering.Mermaid()
+	for _, want := range []string{
+		"fontFamily: \"Helvetica, Arial, sans-serif\"",
+		"  gantt:\n    displayMode: compact\n    leftPadding: 87\n",
+		"%% run — timeline rendering (the trace of a run to t = 3600.5)",
+		"%% t=0.125 guard: x not evaluated",
+		"gantt",
+		"dateFormat x",
+		"axisFormat %M:%S.%L",
+		"todayMarker off",
+		"section lane#58; #35; #59;",
+		"idle#58; #35;#59;",
+		"ready (accept Go) :l0s1, 251, 3600500",
+		"1 state held for no time is listed in the text form",
+		"instants are rounded to the nearest millisecond",
+		"the axis reads minutes and seconds; it wraps past an hour",
+		"Mermaid gantt draws no note; choice and guard records are comments",
+	} {
+		if !strings.Contains(mermaid, want) {
+			t.Errorf("timeline Mermaid is missing %q:\n%s", want, mermaid)
+		}
+	}
+	if !strings.Contains(mermaid, "%% t=0.125 guard: x not evaluated\ngantt") {
+		t.Errorf("multiline mark escaped the Mermaid comment:\n%s", mermaid)
+	}
+	if strings.Contains(mermaid, ":active") {
+		t.Errorf("open timeline span uses the unstyled active tag:\n%s", mermaid)
+	}
+}
+
+func TestRunTimelineMermaidLeftPaddingKeepsDefaultMinimum(t *testing.T) {
+	rendering := &Rendering{
+		Kind: KindTimeline,
+		Run:  true,
+		Lanes: []Lane{{
+			ID: "l0", Name: "A",
+		}},
+	}
+	if got := rendering.Mermaid(); !strings.Contains(got, "    leftPadding: 75\n") {
+		t.Errorf("timeline Mermaid left padding is below the default:\n%s", got)
+	}
+}
+
+func TestRunTimelinePlantUMLWritesTimingChanges(t *testing.T) {
+	rendering := &Rendering{
+		Kind: KindTimeline, Run: true, RunUntil: 3, Stated: "the trace of a run to t = 3",
+		Lanes: []Lane{{
+			ID: "l0", Name: "Rover",
+			Spans: []Span{
+				{State: "idle", From: 0, To: 1.25},
+				{State: "moving", From: 1.25, To: 3, Triggers: []string{"accept Go"}, Open: true},
+			},
+			Marks: []Mark{{At: 1.25, Kind: "choice", Text: "choice: moving"}},
+		}},
+	}
+	puml, err := rendering.PlantUML()
+	if err != nil {
+		t.Fatalf("PlantUML: %v", err)
+	}
+	for _, want := range []string{
+		"@startuml\n' run — timeline rendering (the trace of a run to t = 3)",
+		"scale 1 as 112 pixels",
+		`concise "Rover" as l0`,
+		"@0\nl0 is \"idle\"\n",
+		"@1.25\nl0 is \"moving (accept Go)\"\nnote top of l0 : choice: moving\n",
+		"@3\nl0 is {hidden}\n@enduml",
+	} {
+		if !strings.Contains(puml, want) {
+			t.Errorf("timeline PlantUML is missing %q:\n%s", want, puml)
+		}
+	}
+	if strings.Contains(puml, "<style>") {
+		t.Errorf("timing diagram contains the graph style preamble:\n%s", puml)
+	}
+}
+
+func TestRunTimelinePlantUMLUsesRunUntilField(t *testing.T) {
+	rendering := &Rendering{
+		Kind: KindTimeline, Run: true, RunUntil: 7, Stated: "the trace of a run to t = 4",
+		Lanes: []Lane{{ID: "l0", Name: "Rover", Spans: []Span{{State: "moving", From: 1, To: 2, Open: true}}}},
+	}
+	puml, err := rendering.PlantUML()
+	if err != nil {
+		t.Fatalf("PlantUML: %v", err)
+	}
+	if !strings.Contains(puml, "@7\nl0 is {hidden}\n@enduml") {
+		t.Errorf("PlantUML ignored RunUntil:\n%s", puml)
+	}
+}
+
+func TestRunTimelinePlantUMLOmitsZeroDurationSpans(t *testing.T) {
+	rendering := &Rendering{
+		Kind: KindTimeline, Run: true, RunUntil: 2,
+		Lanes: []Lane{{ID: "l0", Name: "Rover", Spans: []Span{
+			{State: "first", From: 0, To: 1},
+			{State: "middle instant", From: 1, To: 1},
+			{State: "following", From: 1, To: 2, Open: true},
+			{State: "ending instant", From: 2, To: 2},
+		}}},
+	}
+	puml, err := rendering.PlantUML()
+	if err != nil {
+		t.Fatalf("PlantUML: %v", err)
+	}
+	for _, want := range []string{
+		"' not represented: 2 states held for no time are listed in the text form",
+		"@0\nl0 is \"first\"\n",
+		"@1\nl0 is \"following\"\n",
+		"@2\nl0 is {hidden}\n",
+	} {
+		if !strings.Contains(puml, want) {
+			t.Errorf("timeline PlantUML is missing %q:\n%s", want, puml)
+		}
+	}
+	if strings.Contains(puml, "middle instant") || strings.Contains(puml, "ending instant") {
+		t.Errorf("timeline PlantUML rendered zero-duration state labels:\n%s", puml)
+	}
+}
+
+func TestRunTimelinePlantUMLClosesBeforeTrailingZeroDurationSpan(t *testing.T) {
+	rendering := &Rendering{
+		Kind: KindTimeline, Run: true, RunUntil: 3,
+		Lanes: []Lane{{ID: "l0", Name: "Rover", Spans: []Span{
+			{State: "stopped", From: 0, To: 1},
+			{State: "instant", From: 1, To: 1},
+		}}},
+	}
+	puml, err := rendering.PlantUML()
+	if err != nil {
+		t.Fatalf("PlantUML: %v", err)
+	}
+	for _, want := range []string{
+		"@1\nl0 is {hidden}\n",
+		"@3\nl0 is {hidden}\n",
+	} {
+		if !strings.Contains(puml, want) {
+			t.Errorf("timeline PlantUML is missing %q:\n%s", want, puml)
+		}
+	}
+}
+
+func TestRunTimelinePlantUMLScaleFitsLabelsAndCapsWidth(t *testing.T) {
+	span := Span{
+		State: "acknowledged | charged", From: 0, To: 1,
+		Triggers: []string{"time", "accept Ack"},
+	}
+	lanes := []Lane{{Spans: []Span{span}}}
+	scale := timelineScale(lanes, 6)
+	labelWidth := max(140, len([]rune(timelineStateLabel(span)))*7+24)
+	if scale < float64(labelWidth) {
+		t.Errorf("scale = %g pixels/s, want at least %d pixels for the label", scale, labelWidth)
+	}
+	if width := scale * 6; width > 4000 {
+		t.Errorf("timeline width = %g pixels, want at most 4000", width)
+	}
+	longScale := timelineScale(lanes, 10_000)
+	if width := longScale * 10_000; width > 4000 {
+		t.Errorf("long timeline width = %g pixels, want at most 4000", width)
+	}
+}
+
+func TestRunTimelinePlantUMLLinksLanesAndSingleStateSpans(t *testing.T) {
+	laneOrigin := Origin{Doc: "run.sysml", Span: source.Span{Offset: 1, Len: 1}}
+	spanOrigin := Origin{Doc: "run.sysml", Span: source.Span{Offset: 2, Len: 1}}
+	rendering := &Rendering{
+		Kind: KindTimeline, Run: true, RunUntil: 3,
+		Lanes: []Lane{{
+			ID: "l0", Name: "Machine", Origin: laneOrigin,
+			Spans: []Span{
+				{State: "ready", Origin: spanOrigin, From: 0, To: 1},
+				{State: "left.waiting | right.waiting", From: 1, To: 3, Open: true},
+			},
+		}},
+	}
+	links := Links{
+		Template: "https://example.test/src/{file}#L{line}",
+		Sites: func(origin Origin) (Site, bool) {
+			return Site{File: origin.Doc, Line: origin.Span.Offset}, true
+		},
+	}
+	got, err := rendering.WriteWith(FormPlantUML, Options{Links: links})
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, want := range []string{
+		`concise "[[https://example.test/src/run.sysml#L1 Machine]]" as l0`,
+		`l0 is "[[https://example.test/src/run.sysml#L2 ready]]"`,
+		`l0 is "left.waiting | right.waiting"`,
+	} {
+		if !strings.Contains(got, want) {
+			t.Errorf("run timeline PlantUML is missing %q:\n%s", want, got)
+		}
+	}
+	if strings.Contains(got, `[[https://example.test/src/run.sysml#L0 left.waiting`) {
+		t.Errorf("multi-state span was linked:\n%s", got)
+	}
+}
+
+func TestRunTimelinePlantUMLEscapesLinkedLabels(t *testing.T) {
+	origin := Origin{Doc: "run.sysml", Span: source.Span{Offset: 1, Len: 1}}
+	rendering := &Rendering{
+		Kind: KindTimeline, Run: true, RunUntil: 1,
+		Lanes: []Lane{{
+			ID: "l0", Name: `machine # "quotes]`, Origin: origin,
+			Spans: []Span{{State: `ready # "quotes]`, Origin: origin, From: 0, To: 1, Open: true}},
+		}},
+	}
+	links := Links{
+		Template: "https://example.test/src/{file}#L{line}",
+		Sites: func(origin Origin) (Site, bool) {
+			return Site{File: origin.Doc, Line: 9}, true
+		},
+	}
+	got, err := rendering.WriteWith(FormPlantUML, Options{Links: links})
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, want := range []string{
+		`concise "[[https://example.test/src/run.sysml#L9 machine <U+0023> <U+0022>quotes<U+005D>]]" as l0`,
+		`l0 is "[[https://example.test/src/run.sysml#L9 ready <U+0023> <U+0022>quotes<U+005D>]]"`,
+	} {
+		if !strings.Contains(got, want) {
+			t.Errorf("PlantUML label is missing safe link markup %q:\n%s", want, got)
+		}
+	}
+}
+
+func TestRunTimelinePlantUMLLeavesUnsafeLabelsUnlinked(t *testing.T) {
+	origin := Origin{Doc: "run.sysml", Span: source.Span{Offset: 1, Len: 1}}
+	rendering := &Rendering{
+		Kind: KindTimeline, Run: true, RunUntil: 1,
+		Lanes: []Lane{{ID: "l0", Name: "machine\tname", Origin: origin}},
+	}
+	got, err := rendering.WriteWith(FormPlantUML, Options{Links: Links{
+		Template: "https://example.test/src/{file}#L{line}",
+		Sites: func(origin Origin) (Site, bool) {
+			return Site{File: origin.Doc, Line: 1}, true
+		},
+	}})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if strings.Contains(got, "[[") || !strings.Contains(got, "concise \"machine\tname\" as l0") {
+		t.Errorf("unsafe lane label should remain readable and unlinked:\n%s", got)
+	}
+}
+
+func TestRunTimelineUnlinkedFormsIgnoreLinks(t *testing.T) {
+	origin := Origin{Doc: "run.sysml", Span: source.Span{Offset: 1, Len: 1}}
+	rendering := &Rendering{
+		Kind: KindTimeline, Run: true, RunUntil: 1,
+		Lanes: []Lane{{ID: "l0", Name: "Machine", Origin: origin, Spans: []Span{
+			{State: "ready", Origin: origin, From: 0, To: 1, Open: true},
+		}}},
+	}
+	options := Options{Links: Links{
+		Template: "https://example.test/src/{file}#L{line}",
+		Sites: func(origin Origin) (Site, bool) {
+			return Site{File: origin.Doc, Line: 1}, true
+		},
+	}}
+	for _, form := range []Form{FormMermaid, FormText} {
+		plain, err := rendering.WriteWith(form, Options{})
+		if err != nil {
+			t.Fatal(err)
+		}
+		linked, err := rendering.WriteWith(form, options)
+		if err != nil {
+			t.Fatal(err)
+		}
+		if linked != plain {
+			t.Errorf("linked %s timeline differs from unlinked output:\nplain:\n%s\nlinked:\n%s", form, plain, linked)
+		}
+	}
+}
+
+func TestRunTimelineAndSequenceEmptyMessages(t *testing.T) {
+	timeline := &Rendering{Kind: KindTimeline, Run: true, RunUntil: 4, Stated: "the trace of a run to t = 4"}
+	if !timeline.Empty() || !timeline.blank() {
+		t.Errorf("empty timeline: Empty=%t blank=%t", timeline.Empty(), timeline.blank())
+	}
+	if got := timeline.EmptyReason(); got != "the run recorded no state; the rendering is empty" {
+		t.Errorf("timeline empty reason = %q", got)
+	}
+	if !strings.Contains(timeline.Text(), timeline.EmptyReason()) ||
+		!strings.Contains(timeline.Mermaid(), timeline.EmptyReason()) {
+		t.Error("empty timeline forms do not explain why no state is shown")
+	}
+	puml, err := timeline.PlantUML()
+	if err != nil || !strings.Contains(puml, timeline.EmptyReason()) {
+		t.Errorf("empty timeline PlantUML = %q, %v", puml, err)
+	}
+	sequence := &Rendering{Kind: KindSequence, Run: true, RunUntil: 4, Stated: "the trace of a run to t = 4"}
+	if got := sequence.EmptyReason(); got != "the run recorded no message; the rendering is empty" {
+		t.Errorf("sequence empty reason = %q", got)
+	}
+	if !strings.Contains(sequence.Text(), sequence.EmptyReason()) {
+		t.Errorf("empty sequence text does not explain why:\n%s", sequence.Text())
+	}
+}
+
+func TestRunSequenceHeadersDoNotChangeItsWriters(t *testing.T) {
+	rendering := &Rendering{
+		Kind: KindSequence, Run: true, RunUntil: 2, Stated: "the trace of a run to t = 2",
+		Roots: []*Node{{ID: "n0", Kind: "object", Name: "A"}, {ID: "n1", Kind: "object", Name: "B"}},
+		Edges: []Edge{{From: "n0", To: "n1", Label: "t=1 Ping", Kind: EdgeFlow}},
+	}
+	if got := rendering.Text(); !strings.HasPrefix(got, "run - sequence rendering (the trace of a run to t = 2)") ||
+		!strings.Contains(got, "A => B: t=1 Ping") {
+		t.Errorf("run sequence text:\n%s", got)
+	}
+	if got := rendering.Mermaid(); !strings.Contains(got, "%% run — sequence rendering (the trace of a run to t = 2)") ||
+		!strings.Contains(got, "n0->>n1: t=1 Ping") {
+		t.Errorf("run sequence Mermaid:\n%s", got)
+	}
+	puml, err := rendering.PlantUML()
+	if err != nil || !strings.Contains(puml, "' run — sequence rendering (the trace of a run to t = 2)") ||
+		!strings.Contains(puml, "n0 -> n1 : t=1 Ping") {
+		t.Errorf("run sequence PlantUML = %q, %v", puml, err)
+	}
+}
+
+func TestRunSequenceParticipantLabelsPreserveSessionPaths(t *testing.T) {
+	rendering := &Rendering{
+		Kind: KindSequence,
+		Run:  true,
+		Roots: []*Node{
+			{ID: "n0", Kind: "object", Name: "RunTimeline::mission.controller", Type: "Controller"},
+			{ID: "n1", Kind: "object", Name: "RunTimeline::mission.instrument", Type: "Instrument"},
+		},
+	}
+	mermaid := rendering.Mermaid()
+	for _, want := range []string{
+		"participant n0 as RunTimeline::mission.controller : Controller",
+		"participant n1 as RunTimeline::mission.instrument : Instrument",
+	} {
+		if !strings.Contains(mermaid, want) {
+			t.Errorf("run Mermaid is missing %q:\n%s", want, mermaid)
+		}
+	}
+	puml, err := rendering.PlantUML()
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, want := range []string{
+		`participant "RunTimeline::mission.controller : Controller" as n0`,
+		`participant "RunTimeline::mission.instrument : Instrument" as n1`,
+	} {
+		if !strings.Contains(puml, want) {
+			t.Errorf("run PlantUML is missing %q:\n%s", want, puml)
+		}
+	}
+
+	model := *rendering
+	model.Run = false
+	if got, want := model.Mermaid(), "  participant n0 as «object»<br>'mission.controller' : Controller"; !strings.Contains(got, want) {
+		t.Errorf("model Mermaid participant changed: want %q in\n%s", want, got)
+	}
+	modelPUML, err := model.PlantUML()
+	if err != nil {
+		t.Fatal(err)
+	}
+	if want := `**'mission.controller' : Controller**`; !strings.Contains(modelPUML, want) {
+		t.Errorf("model PlantUML participant changed: want %q in\n%s", want, modelPUML)
+	}
+}
diff --git a/internal/ir/view/sequence.go b/internal/ir/view/sequence.go
index 073753052d..860ebd368e 100644
--- a/internal/ir/view/sequence.go
+++ b/internal/ir/view/sequence.go
@@ -10,6 +10,20 @@ import (
 	"github.com/Open-MBEE/OpenSysML/internal/syntax/ast"
 )
 
+func runParticipantLabel(node *Node) string {
+	label := node.Name
+	if node.Type != "" {
+		if label != "" {
+			label += " : "
+		}
+		label += node.Type
+	}
+	if label == "" {
+		return node.Kind
+	}
+	return label
+}
+
 // renderSequence renders the occurrences of an interaction as lifelines and the
 // flows between them as directed messages, ordered as the model states. A
 // lifeline list is flat — a sequence diagram nests nothing — so a message
diff --git a/internal/ir/view/text.go b/internal/ir/view/text.go
index 2a07729fd6..2f9d979b0e 100644
--- a/internal/ir/view/text.go
+++ b/internal/ir/view/text.go
@@ -26,17 +26,25 @@ func (r *Rendering) TextWidth(width int) string { return r.textWith(Options{Widt
 func (r *Rendering) textWith(options Options) string {
 	width := options.Width
 	var b strings.Builder
-	if r.View == "" {
+	if r.Run {
+		fmt.Fprintf(&b, "run - %s rendering", r.Kind)
+	} else if r.View == "" {
 		fmt.Fprintf(&b, "%s rendering", r.Kind)
 	} else {
 		fmt.Fprintf(&b, "%s - %s rendering", r.View, r.Kind)
 	}
 	if r.Stated != "" {
 		fmt.Fprintf(&b, " (%s)", r.Stated)
-	} else {
+	} else if !r.Run {
 		b.WriteString(" (the view states no rendering; a tree is the default)")
 	}
 	b.WriteString("\n")
+	if r.Run && r.Kind == KindTimeline {
+		b.WriteString("\n")
+		writeRunTimelineText(&b, r)
+		writeNotices(&b, r.Notices)
+		return b.String()
+	}
 	if r.Empty() {
 		b.WriteString("\n" + r.EmptyReason() + "\n")
 		writeNotices(&b, r.Notices)
@@ -122,6 +130,14 @@ func noteText(note Note, labels map[string]string) string {
 // view whose exposed elements this kind of rendering cannot show, which the
 // notices then account for one by one.
 func (r *Rendering) EmptyReason() string {
+	if r.Run {
+		switch r.Kind {
+		case KindTimeline:
+			return "the run recorded no state; the rendering is empty"
+		case KindSequence:
+			return "the run recorded no message; the rendering is empty"
+		}
+	}
 	if r.emptyReason != "" {
 		return r.emptyReason
 	}
@@ -135,7 +151,7 @@ func (r *Rendering) EmptyReason() string {
 // blank reports whether a form that draws no picture shows nothing of the
 // rendering: it has no node, edge or row, whether or not it has pictures.
 func (r *Rendering) blank() bool {
-	return len(r.Roots) == 0 && len(r.Edges) == 0 && len(r.Rows) == 0
+	return len(r.Roots) == 0 && len(r.Edges) == 0 && len(r.Rows) == 0 && len(r.Lanes) == 0
 }
 
 // blankReason is EmptyReason or, for a rendering of pictures alone, that
diff --git a/internal/ir/view/view.go b/internal/ir/view/view.go
index fd7080dc6f..ba53196297 100644
--- a/internal/ir/view/view.go
+++ b/internal/ir/view/view.go
@@ -59,6 +59,9 @@ const (
 	// between them as ordered messages, which is
 	// StandardViewDefinitions::SequenceView.
 	KindSequence Kind = "sequence"
+	// KindTimeline renders a run's trace as each object machine's states over
+	// clock time; no view states it.
+	KindTimeline Kind = "timeline"
 	// KindGeometry is StandardViewDefinitions::GeometryView.
 	KindGeometry Kind = "geometry"
 	// KindRequirement renders exposed requirements as nodes and the
@@ -395,9 +398,8 @@ type Edge struct {
 	openFrom, openTo bool
 }
 
-// Rendering is what a view renders to: the nodes and edges of one artifact,
-// which Text and Mermaid write out. It is a value, not a live view of the
-// model: nothing in it points back into the AST.
+// Rendering is what a view or run renders to. It is a value, not a live view of
+// the model: nothing in it points back into the AST.
 type Rendering struct {
 	// View is the rendered view, by qualified name as the notation writes it.
 	View string
@@ -407,6 +409,10 @@ type Rendering struct {
 	// the standard view definition it specializes, or "" when the view states
 	// nothing and the default was used.
 	Stated string
+	// Run marks a rendering of a run's trace rather than of a view.
+	Run bool
+	// RunUntil is the clock instant through which a run rendering was recorded.
+	RunUntil float64
 	// Roots are the top-level nodes, in the order the view exposes them.
 	Roots []*Node
 	// Edges join nodes, in the order the model and the lowered graphs give them.
@@ -417,6 +423,9 @@ type Rendering struct {
 	// Rows are the rows of a tabular rendering, each holding one cell per
 	// column, in the order the view exposes the elements.
 	Rows [][]string
+	// Lanes are a timeline's object machines, in the order the run first
+	// recorded them.
+	Lanes []Lane
 	// RowOrigins is where each row's element was declared, one entry per row.
 	RowOrigins []Origin
 	// Canvas is the drawing surface the view states, nil for a view stating
@@ -442,10 +451,45 @@ type Rendering struct {
 	sites map[*Node]treeSite
 }
 
-// Empty reports whether the rendering has nothing to show: no node, edge,
-// row or picture.
+// Lane is one object machine in a run timeline.
+type Lane struct {
+	ID   string
+	Name string
+	// Origin is where the lane's state machine was declared.
+	Origin      Origin
+	Spans       []Span
+	Transitions []LaneTransition
+	Marks       []Mark
+}
+
+// Span is a state's occupancy of a lane over clock time.
+type Span struct {
+	State string
+	// Origin is where the one state shown by the span was declared.
+	Origin   Origin
+	From, To float64
+	Triggers []string
+	Through  []string
+	Open     bool
+}
+
+// LaneTransition is a transition recorded at an instant in a lane.
+type LaneTransition struct {
+	At       float64
+	From, To string
+	Event    string
+}
+
+// Mark is a choice or guard record attached to a lane at an instant.
+type Mark struct {
+	At   float64
+	Kind string
+	Text string
+}
+
+// Empty reports whether the rendering has nothing to show.
 func (r *Rendering) Empty() bool {
-	return len(r.Roots) == 0 && len(r.Edges) == 0 && len(r.Rows) == 0 && len(r.Pictures) == 0
+	return len(r.Roots) == 0 && len(r.Edges) == 0 && len(r.Rows) == 0 && len(r.Pictures) == 0 && len(r.Lanes) == 0
 }
 
 // Positioned reports whether a Layout or Route places some node of a
diff --git a/packaging/man/man1/sysml.1 b/packaging/man/man1/sysml.1
index 8849ee3b5f..1f50e3d427 100644
--- a/packaging/man/man1/sysml.1
+++ b/packaging/man/man1/sysml.1
@@ -321,9 +321,10 @@ family: okabe\-ito, tol\-bright, tol\-muted, tol\-light, brewer\-set2,
 brewer\-dark2, viridis or cividis; default black and white
 .TP
 .BR \-render\-link " \fItemplate\fP"
-Link template for rendered elements: {file} is the path as loaded; use
-absolute paths for vscode:// or file:// links. Placeholders: {file}, {line},
-{col}, {qname}, {id}
+Source link template for \-render, \-render\-all, \-render\-document,
+\-render\-documents and \-render\-run. Placeholders: {file}, {line}, {col},
+{qname}, {id}; {file} is the path as loaded (use absolute paths for vscode://
+or file:// links)
 .TP
 .BR \-render\-unplaced " \fIplacement\fP"
 Where a graph form of a view some Layout positions puts the nodes none does:
@@ -453,6 +454,10 @@ Report errors only, suppressing warnings
 Report each execution step: expression evaluation, calc invocation, action
 tokens, state transitions
 .TP
+.BR \-render\-run " \fIkind\fP=\fIpath\fP"
+Render the trace of a run as timeline or sequence into path (\- is stdout);
+form comes from \-render\-form or the path extension
+.TP
 .BR \-cpuprofile " \fIfile\fP"
 Write a CPU profile of the run to this file, for go tool pprof
 .TP
diff --git a/tests/corpus/testdata/api_json_roundtrip_expected.txt b/tests/corpus/testdata/api_json_roundtrip_expected.txt
index 1fa4960fe0..56bb743539 100644
--- a/tests/corpus/testdata/api_json_roundtrip_expected.txt
+++ b/tests/corpus/testdata/api_json_roundtrip_expected.txt
@@ -9,7 +9,7 @@
 # This is a per-file ratchet, not a claim that any verdict is right;
 # see docs/project/rdf-corpus-roundtrip.md. Regenerate with:
 #   go test ./tests/corpus -run TestCorpusAPIJSONRoundTrip -update-api-json-roundtrip
-# files: committed 51
+# files: committed 52
 # files: sysml-v2-training 100
 # files: pilot-corpora/kerml-examples 58
 # files: pilot-corpora/sysml-examples 99
@@ -258,6 +258,7 @@ stable	pseudostates-demo.sysml
 stable	rdf-interop-demo.sysml
 stable	relay-probe-demo/mission.sysml
 stable	repl-behavioral-demo.sysml
+stable	run-timeline/run-timeline.sysml
 stable	runtime-showcase/delta-v-budget.sysml
 stable	runtime-showcase/mass-rollup.sysml
 stable	runtime-showcase/mission-sequence.sysml
diff --git a/tests/corpus/testdata/corpus_roundtrip_expected.txt b/tests/corpus/testdata/corpus_roundtrip_expected.txt
index a19ea80a38..0be95899ac 100644
--- a/tests/corpus/testdata/corpus_roundtrip_expected.txt
+++ b/tests/corpus/testdata/corpus_roundtrip_expected.txt
@@ -8,7 +8,7 @@
 # is a per-file ratchet, not a claim that any verdict is right; see
 # docs/project/rdf-corpus-roundtrip.md. Regenerate with:
 #   go test ./tests/corpus -run TestCorpusRoundTrip -update-corpus-roundtrip
-# files: committed 51
+# files: committed 52
 # files: sysml-v2-training 100
 # files: pilot-corpora/kerml-examples 58
 # files: pilot-corpora/sysml-examples 99
@@ -257,6 +257,7 @@ stable	pseudostates-demo.sysml
 stable	rdf-interop-demo.sysml
 stable	relay-probe-demo/mission.sysml
 stable	repl-behavioral-demo.sysml
+stable	run-timeline/run-timeline.sysml
 stable	runtime-showcase/delta-v-budget.sysml
 stable	runtime-showcase/mass-rollup.sysml
 stable	runtime-showcase/mission-sequence.sysml
diff --git a/tests/hygiene/layering_test.go b/tests/hygiene/layering_test.go
index 6edb64a49b..7ae333be11 100644
--- a/tests/hygiene/layering_test.go
+++ b/tests/hygiene/layering_test.go
@@ -73,6 +73,7 @@ var packageLayer = map[string]string{
 	"internal/check/edit":            "check",
 
 	"internal/exec/runtime":             "exec",
+	"internal/exec/runtrace":            "exec",
 	"internal/exec/solve":               "exec",
 	"internal/exec/smt":                 "exec",
 	"internal/exec/analysis":            "exec",