diff --git a/docs/architecture/ADR-0031-dsl-composition-operators.md b/docs/architecture/ADR-0031-dsl-composition-operators.md
new file mode 100644
index 0000000..0849ee3
--- /dev/null
+++ b/docs/architecture/ADR-0031-dsl-composition-operators.md
@@ -0,0 +1,151 @@
+<!--
+SPDX-FileCopyrightText: 2026 Robomous
+SPDX-License-Identifier: Apache-2.0
+-->
+
+# ADR-0031 — Lowering the DSL composition operators
+
+- **Status:** Accepted
+- **Date:** 2026-08-02
+- **Sprint:** p8-s2 (#45)
+- **Supersedes:** nothing. Builds on ADR-0030 (lowering to the IR) and on the
+  storyboard model P1 pinned (ADR-0025, ADR-0026).
+
+## Context
+
+ADR-0030 gave the DSL frontend a storyboard: one Story, one Act, one
+ManeuverGroup per phase. It handled the two easy cases — `serial` chained on the
+predecessor's completion, `parallel` left the triggers absent — and reported
+everything else.
+
+§7.6.2.1 asks for more than that. A composition can nest; it can carry a
+`duration`; `one_of` picks one of several alternatives; `wait elapsed(d)`
+introduces a phase in which nothing is specified. None of these is a runtime
+concept: the storyboard machinery the XML frontend has been driving since P1
+already does everything they need. What was missing is the *arithmetic* that
+turns a composition into start conditions.
+
+Three questions had no obvious answer:
+
+1. **How does a `duration` become anything the IR can hold?** A storyboard
+   element has no duration field, and — probed against the engine — neither of
+   the obvious tricks works. A stop trigger only cuts a phase short: an Act
+   completes as soon as its groups do, so a step-shaped action ends the phase
+   immediately whatever the stop trigger says. And a start trigger delayed on
+   the predecessor's `runningState` never fires, because the predecessor is no
+   longer running by the time the delayed lookup happens.
+2. **Which alternative does `one_of` run?** §7.6.2.1.3 says at least one must
+   hold and says nothing about which.
+3. **What ends a parallel composition?** Its members end at different times,
+   and the phase after it has to wait for all of them.
+
+## Decision
+
+### 1. Composition decides *when* a phase starts, and nothing else
+
+A composition operator contributes exactly one thing to the IR: the start
+trigger on a phase's Event. No new runtime concept, no new IR node, no change to
+the scheduler. That is what makes the two frontends share one runtime rather
+than two that resemble each other.
+
+### 2. A concrete duration is arithmetic, done at load time
+
+The storyboard starts at t = 0 and every duration that lowers is a constant, so
+a phase's absolute start time is the sum of the durations before it. That sum is
+computable while lowering, exact, and needs no feedback from the run — which is
+also why it is inside the determinism contract rather than at odds with it.
+
+Lowering therefore tracks, for each point in the `do` directive, what load time
+knows about it:
+
+- an **absolute time**, when every preceding phase had a concrete duration; and
+- a set of **groups that must have completed**, for the phases whose end only
+  the runtime knows.
+
+A trigger ANDs whichever of the two is known — a `SimulationTimeCondition` plus
+one `StoryboardElementStateCondition` per group, in a single ConditionGroup.
+A phase whose start is t = 0 with nothing to wait for gets *no* trigger, because
+`t >= 0` is a tautology and §7.6.1.1 already says a trigger-less element starts
+with its parent.
+
+**A range duration is not a value.** §7.6.2.4 lets `duration` be `[10s..30s]`,
+which constrains accepted traces rather than fixing a time; choosing a value
+from it needs a solver, and that is post-v0.0.1 (ADR-0004). It is reported and
+the phase falls back to completion chaining.
+
+### 3. A parallel join is an AND, which the trigger model already has
+
+A `ConditionGroup` is a conjunction, so "every member has finished" is one group
+with one condition per member. Members that end at a known time collapse into a
+single `SimulationTimeCondition` at the latest of them; members that end when
+their actions do each contribute their group's completion. Mixing the two is
+therefore free, and the common case — every member has a duration — reduces to
+one arithmetic comparison.
+
+§7.6.2.1.4's default overlap is `start`: members begin together and may end
+apart, which is exactly what absent start triggers already give. The other seven
+overlap kinds and the `start_to_start`/`end_to_end` offsets are reported and not
+realised in v0.0.1.
+
+### 4. The `one_of` alternative is an input, defaulting to the first
+
+§7.6.2.1.3's latitude is real, and an executor has to pick. Picking at random
+would put a hidden input into the run, which is the one thing the determinism
+contract exists to prevent — and the engine has no seed machinery to make such a
+choice reproducible even in principle.
+
+So the choice is an explicit input: `LowerOptions::alternative`, which
+`scena-run --select` feeds, naming an alternative by its label. Empty means the
+first alternative in declaration order. An alternative that is not there is an
+error listing the ones that are.
+
+This is a *lowering-time* decision, not a runtime one: the alternatives that were
+not chosen do not reach the IR at all. That keeps the engine free of a concept
+the XML side has no counterpart for.
+
+### 5. `wait elapsed(d)` lowers to nothing but the clock
+
+§7.6.2.4.2 introduces a phase of the given length in which nothing is specified.
+Nothing is what it produces: no group, no event, no action — it only advances
+the running offset the next phase starts from. An IR element that did nothing
+for `d` seconds would be a fiction, and the clock is already running.
+
+`wait` for an *event* is a different construct, and §7.6.2.5's events have no
+runtime carrier in v0.0.1; it is reported, along with `emit`, `on` and `until`.
+
+## Consequences
+
+- A DSL scenario's phases are sequenced by construction. `scena-run` runs one
+  and the trace shows each phase taking over at the second the scenario named.
+- Composition is a pure frontend concern. Adding an overlap kind, or a future
+  operator, changes lowering and nothing below it.
+- The scenario's own end becomes the storyboard's stop trigger when it is a
+  constant, so a run's element states finish rather than sit at running.
+- **A pre-existing lexer defect surfaced and was fixed here.** §7.2.2.6.7 spells
+  the range constructor `'[' expression '..' expression ']'`, and
+  §7.2.1.5.2's `float-literal ::= digit* '.' digit+` makes the leading digits
+  optional — so `[2..4]` is a race between the `..` operator and the float `.4`,
+  and the float was winning. The lexer emitted no `..` token at all and the
+  parser looked for `...`, a spelling the standard does not have. The two agreed
+  with each other, so every range in the test suite was written the wrong way and
+  nothing noticed. `duration: [10s..30s]` is what made it visible.
+
+## Alternatives considered
+
+**Give a storyboard element a duration field.** Rejected: it is a DSL concept
+with no OpenSCENARIO XML counterpart, so it would be runtime machinery only one
+frontend can reach — the opposite of the two-frontends-one-runtime rule.
+
+**Bound a phase with a stop trigger on the Act.** Probed and rejected: a stop
+trigger can only cut a phase short. An Act completes as soon as its groups do,
+so a step-shaped action ends the phase immediately, and the duration would be
+silently ignored for exactly the scenarios that are easiest to write.
+
+**Delay the start trigger on the predecessor's `runningState`.** Probed and
+rejected: the predecessor is no longer running when the delayed lookup happens,
+so the trigger never fires at all.
+
+**Pick a `one_of` alternative at random from a seeded generator.** Rejected: it
+makes the run depend on a seed the scenario does not state, and the engine has
+no seed machinery — introducing one for a frontend concept would put randomness
+inside the determinism contract for the first time.
diff --git a/docs/roadmap/coverage/osc-dsl-coverage.md b/docs/roadmap/coverage/osc-dsl-coverage.md
index 95c9ca8..6caad84 100644
--- a/docs/roadmap/coverage/osc-dsl-coverage.md
+++ b/docs/roadmap/coverage/osc-dsl-coverage.md
@@ -53,7 +53,14 @@ time is.
 | §8.8 movement actions → IR actions | §8.8.2–§8.8.4 | In | In | p8-s1 | **Landed** (`dsl_lowering_test.cpp`): `assign_speed`, `change_speed`, `remain_stationary`, `assign_position`, `change_lane`, `change_space_gap`, `change_time_gap`. `dynamic_profile` names the shape and `rate_peak` the magnitude; with no peak rate there is no number to ramp over, so the change is a Step (§7.4.1.2). Every action with no counterpart is reported by name, never silently dropped |
 | Generic actions (`move`, `drive`, `walk`) | §8.8.2.3, §8.8.3.1, §8.8.4.1 | In | In | p8-s1, p8-s3 | **Landed**: they carry no target of their own and exist to be shaped by §8.9 modifiers, so on their own they lower to nothing — "keep doing what you are doing" is what the runtime already does |
 | Struct-valued action arguments | §7.2.2.6.7 | In | In | p8-s1 | **Landed**: the DSL declares list and range constructors and no struct constructor, so a struct-valued argument names a declaration and the `keep`s on it are the value (ADR-0030 §7). A coordinate nothing constrains is reported, not assumed |
-| `do` directive → storyboard | §7.6.2.1 | In | Partial | p8-s1, p8-s2 | **Landed**: one Story, one Act, one ManeuverGroup per phase; `serial` chains a phase on its predecessor reaching completeState (§7.6.2.1.2), `parallel` leaves the triggers absent (§7.6.1.1). `one_of`, nesting, `until`, `wait`, `emit`, `call` and an invocation `duration` are reported and land in p8-s2 |
+| `do` directive → storyboard | §7.6.2.1 | In | In | p8-s1, p8-s2 | **Landed** (`dsl_lowering_test.cpp`): one Story, one Act, one ManeuverGroup per phase, nesting to any depth. A composition contributes exactly one thing — the start trigger on a phase's Event — so the runtime is unchanged (ADR-0031) |
+| Serial composition | §7.6.2.1.2 | In | In | p8-s2 | **Landed**: a member starts when its predecessor ends. With concrete durations that is an absolute `SimulationTimeCondition` computed at load; otherwise the predecessor group's completeState |
+| Parallel composition | §7.6.2.1.4 | In | In (default overlap) | p8-s2 | **Landed**: the default `overlap: start` is what absent start triggers already give, and the join is one ConditionGroup (an AND) over the members' ends. The other seven overlap kinds and `start_to_start`/`end_to_end` are reported, not realised |
+| One-of composition | §7.6.2.1.3 | In | In | p8-s2 | **Landed**: the alternative is an *input* (`LowerOptions::alternative`, fed by `scena-run --select`), defaulting to the first in declaration order. Picking at random would put a hidden input in the run, and the engine has no seed machinery (ADR-0031) |
+| `duration` on an invocation or composition | §7.6.2.4, §7.6.2.4.1 | In | Concrete only | p8-s2 | **Landed**: a constant duration becomes absolute phase boundaries; a range (`[10s..30s]`) constrains accepted traces rather than fixing a time, so it is reported and needs a solver (ADR-0004) |
+| `wait elapsed(<duration>)` | §7.6.2.4.2 | In | In | p8-s2 | **Landed**: a phase in which nothing is specified lowers to nothing — no group, no event — and only advances the offset the next phase starts from. The clock is already running |
+| `emit` / `wait @event` / `on` / `until` | §7.6.2.5 | In | Post | p8-s2 | Reported: §7.6.2.5's events are abstract control objects with no runtime carrier in v0.0.1. The trigger system has no event namespace, and inventing one would be runtime machinery only the DSL frontend can reach |
+| Range constructor `[a..b]` | §7.2.2.6.7 | In | In | p7-s1, p8-s2 | **Fixed in p8-s2** (`dsl_lexer_test.cpp`): `..` has to beat `float-literal ::= digit* '.' digit+`, whose leading digits are optional, or `[2..4]` lexes as `2`, `.`, `.4`. The lexer emitted no `..` at all and the parser looked for `...`; they agreed with each other, so nothing noticed until a duration range was written |
 | `set_map_file` → road backend | §8.5.4, §8.12.2 | In | In | p8-s1 | **Landed** (`dsl_lowering_test.cpp`, `scena_run_test.cpp`): both spellings the standard prints — `map.set_map_file("m.xodr")` (Code 61) and `keep(my_map.map_file == "m.xodr")` (Code 62). The reference travels beside the IR, as `RoadNetwork/LogicFile` does, because a road-network path is a host input not kernel state (ADR-0003) |
 | Actor type name as a modifier receiver | §7.3.12.4.1, §8.5.4 | In | n/a | p8-s1 | **Landed** (`dsl_types_test.cpp`): `map` in Code 61 names the actor *type* — the road network is a singleton no scenario declares a field for — so a bare actor type name is a receiver in its own right. A declared field of the same name still wins |
 | `scena-run` runs `.osc` | — | n/a | In | p8-s1 | **Landed** (`scena_run_test.cpp`): the extension picks the frontend, `--entry` names the §7.7.2 entry point, `-I` adds an import search path. Same options, exit codes and trace format as XML |
diff --git a/docs/user-guide/scena-run.md b/docs/user-guide/scena-run.md
index 0b01613..4ecbbbf 100644
--- a/docs/user-guide/scena-run.md
+++ b/docs/user-guide/scena-run.md
@@ -22,7 +22,7 @@ scena-run tests/golden/scenarios/gs1-cruise-baseline.xosc \
 | `--trace-format <csv\|json>` | override the format inferred from the extension |
 | `--map <file.xodr>` | road network, overriding the scenario's `RoadNetwork/LogicFile` |
 | `--replay <entity>=<file>` | drive an entity from a recorded trace |
-| `--select <alternative>` | choose a `one_of` alternative (DSL; p8-s2) |
+| `--select <alternative>` | choose a `one_of` alternative by label (`.osc` only) |
 | `--entry <scenario>` | the DSL scenario to run (`.osc` only) |
 | `-I`, `--search-path <dir>` | where DSL imports are looked up (repeatable) |
 | `--quiet` | do not print diagnostics |
@@ -52,6 +52,12 @@ error: the file declares more than one scenario; name the entry point (§7.7.2):
 `--entry second` (or `--entry demo::second`) names it. `-I` adds a directory to
 the import search path, exactly as it does for `scena-check`.
 
+A `one_of` composition offers alternatives, and §7.6.2.1.3 leaves the choice to
+the executor. `--select <label>` makes it, and without it the first alternative
+in declaration order runs — the choice is never random, because a seed the
+scenario does not state would be exactly the hidden input the determinism
+contract exists to rule out.
+
 The road network works the same way in both languages: XML names it in
 `RoadNetwork/LogicFile`, DSL in §8.5.4's `map_file` — written either as
 `map.set_map_file("m.xodr")` or as `keep(my_map.map_file == "m.xodr")`. Both
diff --git a/frontends/dsl/README.md b/frontends/dsl/README.md
index 47f52ae..7462ec8 100644
--- a/frontends/dsl/README.md
+++ b/frontends/dsl/README.md
@@ -253,6 +253,18 @@ expected. It also keeps the dependency list unchanged.
   range constructors and no struct constructor, so `assign_position(position:
   start)` reaches its numbers through the same `keep`s that make an actor
   concrete.
+- **Composition decides when a phase starts, and nothing else** (ADR-0031). A
+  concrete `duration` is arithmetic done at load — the storyboard starts at
+  t = 0, so a phase's start time is the sum of the durations before it — and a
+  parallel join is one ConditionGroup, which is already an AND. `one_of` picks
+  by label from `LowerOptions::alternative`, defaulting to the first: the engine
+  has no seed machinery, and a hidden input is what determinism forbids.
+  `wait elapsed(d)` lowers to nothing but the offset.
+- **`..` has to beat a float that starts with a dot.** §7.2.2.6.7 spells the
+  range constructor `[a '..' b]` while §7.2.1.5.2 makes a float's leading digits
+  optional, so `[2..4]` is a race the operator must win. It did not until p8-s2;
+  the lexer emitted no `..` and the parser looked for `...`, and because the two
+  agreed nothing noticed.
 - **The map file travels beside the IR.** §8.5.4's `map_file` is the DSL's
   `RoadNetwork/LogicFile`, and like it, a road-network path is a host input
   rather than kernel state — the engine reaches roads only through
diff --git a/frontends/dsl/include/scena/dsl/lower.h b/frontends/dsl/include/scena/dsl/lower.h
index 275935b..131ab64 100644
--- a/frontends/dsl/include/scena/dsl/lower.h
+++ b/frontends/dsl/include/scena/dsl/lower.h
@@ -38,6 +38,15 @@ struct LowerOptions {
     /// nothing; a file with several is reported rather than guessed at, because
     /// picking one silently would make the run depend on declaration order.
     std::string entry_point;
+
+    /// The `one_of` alternative to run, by its label (§7.6.2.1.3).
+    ///
+    /// The standard says at least one alternative must hold and says nothing
+    /// about which, so an executor picks. Picking at random would put a hidden
+    /// input in the run, which is what the determinism contract exists to
+    /// prevent — so the choice is an explicit input, and empty means the first
+    /// alternative in declaration order.
+    std::string alternative;
 };
 
 /// What lowering produced: the IR plus the host-side references that are not
diff --git a/frontends/dsl/src/lexer.cpp b/frontends/dsl/src/lexer.cpp
index c36e71e..26fed81 100644
--- a/frontends/dsl/src/lexer.cpp
+++ b/frontends/dsl/src/lexer.cpp
@@ -64,7 +64,13 @@ constexpr std::array<std::string_view, 74> kReservedWords{
 /// The multi-character operators of Table 5, longest first: §7.2.1.5 says
 /// "tokens comprise the longest possible match that forms a legal token".
 constexpr std::array<std::string_view, 8> kMultiCharOperators{
-    "...", "->", "=>", "==", "!=", "<=", ">=", "::",
+    // `..` is the range constructor's own spelling (§7.2.2.6.7's
+    // `'[' expression '..' expression ']'`). It has to be matched before a
+    // float is: without it `[2..4]` lexes as `2`, `.`, `.4` — the second dot is
+    // swallowed by `float-literal ::= digit* '.' digit+`, whose leading digits
+    // are optional. Table 5 lists neither this operator nor `::`; the grammar
+    // productions are what the tokens have to serve.
+    "..", "->", "=>", "==", "!=", "<=", ">=", "::",
 };
 
 /// The single-character operators and delimiters of Table 5.
diff --git a/frontends/dsl/src/lower.cpp b/frontends/dsl/src/lower.cpp
index 59eef89..fe363ad 100644
--- a/frontends/dsl/src/lower.cpp
+++ b/frontends/dsl/src/lower.cpp
@@ -24,6 +24,7 @@
 
 #include "scena/dsl/lower.h"
 
+#include <algorithm>
 #include <map>
 #include <memory>
 #include <optional>
@@ -42,6 +43,7 @@
 #include "scena/ir/entity_types.h"
 #include "scena/ir/evaluation_context.h"
 #include "scena/ir/position.h"
+#include "scena/ir/rule.h"
 #include "scena/ir/storyboard.h"
 #include "scena/ir/trigger.h"
 
@@ -399,6 +401,11 @@ struct Behaviors {
     const ExpressionContext& context;
     const std::vector<Binding>& bindings;
     std::set<std::string> entities;
+    /// The `one_of` alternative to run, by label; empty means the first.
+    std::string alternative;
+    /// Phase names already used, so siblings stay unique: the runtime
+    /// addresses storyboard elements by name path.
+    std::set<std::string> taken;
     DiagnosticSink& sink;
 
     void warn(const SourceRange& at, std::string message) {
@@ -604,28 +611,22 @@ struct Behaviors {
 
     /// Reports the parts of an invocation that p8-s2 and p8-s3 will lower.
     void report_deferred(const DoMember& member) {
-        for (const Argument& argument : member.arguments) {
-            if (argument.name == "duration") {
-                warn(argument.range,
-                     "an invocation 'duration' bounds the phase and is lowered in p8-s2 (#45), "
-                     "§7.6.2.5.3");
-            }
-        }
         for (const ModifierApplication& modifier : member.with.modifiers) {
             warn(modifier.range,
                  "movement modifier '" + modifier.name + "' is lowered in p8-s3 (#46), §8.9");
         }
         for (const EventSpec& until : member.with.until) {
             (void)until;
-            warn(member.range, "'until' ends the invocation at an event and is lowered in p8-s2 "
-                               "(#45), §7.6.2.5.4");
+            // §7.6.2.5.4 ends the invocation *exactly* at an event, and the
+            // events it names have no runtime carrier in v0.0.1.
+            warn(member.range, "'until' ends the invocation at an event, which has no runtime "
+                               "carrier in v0.0.1 (§7.6.2.5.4)");
         }
     }
 
     /// A name for the phase that is unique among its siblings, because the
     /// runtime addresses storyboard elements by name path.
-    std::string phase_name(const DoMember& member, std::size_t index,
-                           std::set<std::string>& taken) {
+    std::string phase_name(const DoMember& member, std::size_t index) {
         std::string name =
             member.label.empty() ? "phase_" + std::to_string(index + 1) : member.label;
         std::string candidate = name;
@@ -645,77 +646,328 @@ struct Behaviors {
     /// "starts when its predecessor ends" already has in the runtime;
     /// `parallel` leaves the triggers absent, so every phase starts with the
     /// Act (§7.6.1.1). Everything else about composition is p8-s2 (#45).
-    void build(const DoMember& root, const std::string& story_name, ir::Storyboard& out) {
-        std::vector<const DoMember*> phases;
-        bool serial = true;
-        if (root.kind == DoMemberKind::Composition) {
-            if (root.composition == CompositionOperator::OneOf) {
-                warn(root.range, "'one_of' selects one alternative and is lowered in p8-s2 (#45), "
-                                 "§7.6.2.1.3");
-                return;
-            }
-            serial = root.composition == CompositionOperator::Serial;
-            for (const Argument& argument : root.composition_arguments) {
-                warn(argument.range,
-                     "composition argument '" +
-                         (argument.name.empty() ? std::string("(positional)") : argument.name) +
-                         "' is lowered in p8-s2 (#45), §7.6.2.1");
-            }
-            for (const DoMemberPtr& member : root.members) {
-                if (member != nullptr) {
-                    phases.push_back(member.get());
+    /// Where a phase begins or ends, as far as *load time* can know it.
+    ///
+    /// A concrete `duration` makes the time arithmetic: the storyboard starts
+    /// at t = 0 and every duration that lowers is a constant, so an absolute
+    /// time is exact and needs no runtime feedback. When a phase ends by its
+    /// actions finishing instead, the only thing load time can say is "when
+    /// that group completes". A trigger ANDs whatever of the two is known,
+    /// which is what makes a parallel join expressible: a ConditionGroup is an
+    /// AND, so "all members done" is one group with one condition per member.
+    struct TimePoint {
+        std::optional<double> at;       ///< absolute simulation time [s]
+        std::vector<std::string> after; ///< groups that must all be complete
+
+        [[nodiscard]] bool unset() const { return !at.has_value() && after.empty(); }
+    };
+
+    /// The trigger a TimePoint asks for, or none when it is "with the parent".
+    [[nodiscard]] std::optional<ir::Trigger> trigger_for(const TimePoint& point) const {
+        if (point.unset() || (point.after.empty() && *point.at <= 0.0)) {
+            // §7.6.1.1: an element with no start trigger starts with its
+            // parent, which is what "at t = 0" means — and `t >= 0` as a
+            // condition would be a tautology in the IR rather than a fact.
+            return std::nullopt;
+        }
+        ir::ConditionGroup group;
+        if (point.at.has_value()) {
+            ir::TriggerCondition condition;
+            condition.expression =
+                std::make_shared<ir::SimulationTimeCondition>(*point.at, ir::Rule::GreaterOrEqual);
+            group.conditions.push_back(std::move(condition));
+        }
+        for (const std::string& element : point.after) {
+            ir::TriggerCondition condition;
+            condition.expression = std::make_shared<ir::StoryboardElementStateCondition>(
+                ir::StoryboardElementType::ManeuverGroup, element,
+                ir::StoryboardElementState::CompleteState);
+            group.conditions.push_back(std::move(condition));
+        }
+        ir::Trigger trigger;
+        trigger.groups.push_back(std::move(group));
+        return trigger;
+    }
+
+    /// Both points reached: the later time, and every completion either wanted.
+    [[nodiscard]] static TimePoint both(TimePoint left, const TimePoint& right) {
+        if (right.at.has_value()) {
+            left.at = left.at.has_value() ? std::max(*left.at, *right.at) : right.at;
+        }
+        for (const std::string& element : right.after) {
+            left.after.push_back(element);
+        }
+        return left;
+    }
+
+    /// A concrete `duration` argument, or none.
+    ///
+    /// §7.6.2.4 lets a duration be a range, which is a constraint on accepted
+    /// traces rather than a value — choosing one needs a solver, which is
+    /// post-v0.0.1 (ADR-0004). A constant is a value, and lowers.
+    [[nodiscard]] std::optional<double> duration_of(const std::vector<Argument>& arguments,
+                                                    const std::string& what) {
+        for (const Argument& argument : arguments) {
+            if (argument.name != "duration" || argument.value == nullptr) {
+                continue;
+            }
+            Value value;
+            if (evaluate_constant(program, *argument.value, context, value) && value.is_numeric()) {
+                return value.as_double();
+            }
+            warn(argument.range, "the duration of " + what +
+                                     " is not a single value, so it bounds accepted traces rather "
+                                     "than fixing a time (§7.6.2.4); it is not lowered");
+            return std::nullopt;
+        }
+        return std::nullopt;
+    }
+
+    /// The `elapsed(<duration>)` of a `wait` directive, or none.
+    [[nodiscard]] std::optional<double> elapsed_of(const EventSpec& event) {
+        if (event.kind != EventConditionKind::Elapsed || event.expression == nullptr) {
+            return std::nullopt;
+        }
+        Value value;
+        if (evaluate_constant(program, *event.expression, context, value) && value.is_numeric()) {
+            return value.as_double();
+        }
+        return std::nullopt;
+    }
+
+    /// Reports the composition arguments §7.6.2.1.4 defines but v0.0.1 does not
+    /// realise. `overlap: start` is the default and is what absent triggers
+    /// already give, so only a *different* overlap is worth a word.
+    void report_composition_arguments(const DoMember& composition) {
+        for (const Argument& argument : composition.composition_arguments) {
+            if (argument.name == "duration") {
+                continue; // read by duration_of
+            }
+            if (argument.name == "overlap" && argument.value != nullptr) {
+                Value value;
+                if (evaluate_constant(program, *argument.value, context, value) &&
+                    value.kind == Value::Kind::Enum) {
+                    // The default is `start`, which is exactly "every member
+                    // starts with its parent" — nothing to do.
+                    const std::string named = argument_enum_name(value);
+                    if (named.empty() || named == "start") {
+                        continue;
+                    }
+                    warn(argument.range, "parallel overlap '" + named +
+                                             "' is not realised in v0.0.1; members start together "
+                                             "and end when their actions do (§7.6.2.1.4)");
+                    continue;
                 }
             }
-        } else {
-            phases.push_back(&root);
+            warn(argument.range,
+                 "composition argument '" +
+                     (argument.name.empty() ? std::string("(positional)") : argument.name) +
+                     "' is not realised in v0.0.1 (§7.6.2.1.4)");
         }
+    }
 
-        ir::Act act;
-        act.name = "act";
-        std::set<std::string> taken;
-        std::string previous;
-        for (std::size_t index = 0; index < phases.size(); ++index) {
-            const DoMember& member = *phases[index];
-            if (member.kind != DoMemberKind::Invocation) {
-                warn(member.range,
-                     "only a behavior invocation is lowered in p8-s1; nested composition, 'wait', "
-                     "'emit' and 'call' are p8-s2 (#45), §7.6.2.5");
-                continue;
+    [[nodiscard]] std::string argument_enum_name(const Value& value) const {
+        if (value.kind != Value::Kind::Enum || value.type == kInvalidType) {
+            return {};
+        }
+        for (const EnumMemberInfo& member : program.types[value.type].enum_members) {
+            if (member.value == value.enum_value) {
+                return member.name;
             }
-            std::string actor;
-            TypeId actor_type = kInvalidType;
-            if (!actor_of(member, actor, actor_type)) {
+        }
+        return {};
+    }
+
+    /// The alternative a `one_of` runs.
+    ///
+    /// §7.6.2.1.3 says at least one alternative must hold, and says nothing
+    /// about which — so an executor picks. Picking at random would put a hidden
+    /// input in the run, so the choice is an *input*: `LowerOptions::alternative`
+    /// (which `scena-run --select` feeds), defaulting to the first alternative
+    /// in declaration order.
+    [[nodiscard]] const DoMember* chosen_alternative(const DoMember& composition) {
+        const DoMember* first = nullptr;
+        for (const DoMemberPtr& member : composition.members) {
+            if (member == nullptr) {
                 continue;
             }
-            report_deferred(member);
-            std::vector<std::shared_ptr<ir::Action>> actions =
-                actions_of(member, actor, actor_type);
-            if (actions.empty()) {
-                continue; // nothing to run; whoever decided that has said why
+            if (first == nullptr) {
+                first = member.get();
             }
+            if (!alternative.empty() && member->label == alternative) {
+                return member.get();
+            }
+        }
+        if (!alternative.empty()) {
+            std::string message = "'" + alternative +
+                                  "' is not an alternative of this one_of (§7.6.2.1.3); it offers:";
+            for (const DoMemberPtr& member : composition.members) {
+                if (member != nullptr) {
+                    message +=
+                        " " + (member->label.empty() ? std::string("(unlabelled)") : member->label);
+                }
+            }
+            error(composition.range, std::move(message));
+            return nullptr;
+        }
+        return first;
+    }
+
+    /// Lowers one `do` member starting at `start`, and answers where it ends.
+    TimePoint lower_member(const DoMember& member, const TimePoint& start, ir::Act& act) {
+        switch (member.kind) {
+        case DoMemberKind::Composition:
+            return lower_composition(member, start, act);
+        case DoMemberKind::Wait:
+            return lower_wait(member, start);
+        case DoMemberKind::Invocation:
+            return lower_invocation(member, start, act);
+        case DoMemberKind::Emit:
+        case DoMemberKind::Call:
+            break;
+        }
+        // §7.6.2.5.2's emit and §7.3.7's call are zero-time directives whose
+        // meaning is an event or a method call, neither of which the runtime
+        // has a carrier for yet.
+        warn(member.range, "'" + std::string(member.kind == DoMemberKind::Emit ? "emit" : "call") +
+                               "' is a zero-time directive with no runtime carrier in v0.0.1 "
+                               "(§7.6.2.5)");
+        return start;
+    }
+
+    TimePoint lower_composition(const DoMember& composition, const TimePoint& start, ir::Act& act) {
+        report_composition_arguments(composition);
+        const std::optional<double> bound =
+            duration_of(composition.composition_arguments, "this composition");
+
+        TimePoint end = start;
+        if (composition.composition == CompositionOperator::Serial) {
+            for (const DoMemberPtr& member : composition.members) {
+                if (member != nullptr) {
+                    end = lower_member(*member, end, act);
+                }
+            }
+        } else if (composition.composition == CompositionOperator::Parallel) {
+            // §7.6.2.1.4's default overlap is `start`: every member begins with
+            // the composition. It ends when all of them have.
+            TimePoint joined;
+            bool any = false;
+            for (const DoMemberPtr& member : composition.members) {
+                if (member == nullptr) {
+                    continue;
+                }
+                const TimePoint member_end = lower_member(*member, start, act);
+                joined = any ? both(std::move(joined), member_end) : member_end;
+                any = true;
+            }
+            end = any ? joined : start;
+        } else {
+            const DoMember* alternative_member = chosen_alternative(composition);
+            if (alternative_member != nullptr) {
+                end = lower_member(*alternative_member, start, act);
+            }
+        }
+
+        if (bound.has_value()) {
+            // A composition duration bounds the whole composition from its own
+            // start (§7.6.2.1.2), so it only fixes an end time when the start
+            // itself is a time.
+            if (start.at.has_value()) {
+                end.at = *start.at + *bound;
+                end.after.clear();
+            } else {
+                warn(composition.range,
+                     "this composition's duration is measured from a start no constant fixes, so "
+                     "it does not bound an absolute time (§7.6.2.4)");
+            }
+        }
+        return end;
+    }
+
+    TimePoint lower_wait(const DoMember& member, const TimePoint& start) {
+        // §7.6.2.4.2: `wait elapsed(d)` adds a phase of length d in which
+        // nothing is specified. Nothing is exactly what it lowers to — the
+        // clock is what advances, and the clock is already running.
+        const std::optional<double> elapsed = elapsed_of(member.event);
+        if (elapsed.has_value()) {
+            if (start.at.has_value()) {
+                TimePoint end = start;
+                end.at = *start.at + *elapsed;
+                end.after.clear();
+                return end;
+            }
+            warn(member.range, "'wait elapsed' follows a phase whose end no constant fixes, so the "
+                               "wait has no absolute end (§7.6.2.4.2)");
+            return start;
+        }
+        warn(member.range, "only 'wait elapsed(<duration>)' is lowered in v0.0.1; waiting for an "
+                           "event needs the event carrier §7.6.2.5 has no runtime counterpart for");
+        return start;
+    }
 
-            const std::string name = phase_name(member, index, taken);
-            ir::Event event;
-            event.name = name;
-            event.actions = std::move(actions);
-            if (serial && !previous.empty()) {
-                event.start_trigger =
-                    ir::make_trigger(std::make_shared<ir::StoryboardElementStateCondition>(
-                        ir::StoryboardElementType::ManeuverGroup, previous,
-                        ir::StoryboardElementState::CompleteState));
+    TimePoint lower_invocation(const DoMember& member, const TimePoint& start, ir::Act& act) {
+        std::string actor;
+        TypeId actor_type = kInvalidType;
+        if (!actor_of(member, actor, actor_type)) {
+            return start;
+        }
+        report_deferred(member);
+        const std::optional<double> duration = duration_of(member.arguments, "this invocation");
+        std::vector<std::shared_ptr<ir::Action>> actions = actions_of(member, actor, actor_type);
+
+        TimePoint end = start;
+        if (duration.has_value()) {
+            if (start.at.has_value()) {
+                end.at = *start.at + *duration;
+                end.after.clear();
+            } else {
+                warn(member.range,
+                     "this invocation's duration is measured from a start no constant fixes, so it "
+                     "does not bound an absolute time (§7.6.2.4.1)");
             }
+        }
+        if (actions.empty()) {
+            // Nothing to run — a generic action, or one already reported. The
+            // phase still takes its duration, because the actor is still doing
+            // something for that long.
+            return end;
+        }
 
-            ir::Maneuver maneuver;
-            maneuver.name = name;
-            maneuver.events.push_back(std::move(event));
+        const std::string name = phase_name(member, act.groups.size());
+        ir::Event event;
+        event.name = name;
+        event.actions = std::move(actions);
+        event.start_trigger = trigger_for(start);
 
-            ir::ManeuverGroup group;
-            group.name = name;
-            group.actors.push_back(actor);
-            group.maneuvers.push_back(std::move(maneuver));
-            act.groups.push_back(std::move(group));
-            previous = name;
+        ir::Maneuver maneuver;
+        maneuver.name = name;
+        maneuver.events.push_back(std::move(event));
+
+        ir::ManeuverGroup group;
+        group.name = name;
+        group.actors.push_back(actor);
+        group.maneuvers.push_back(std::move(maneuver));
+        act.groups.push_back(std::move(group));
+
+        if (!duration.has_value() || !start.at.has_value()) {
+            // The phase ends when its actions do, and only the runtime knows
+            // when that is.
+            end.at = start.at.has_value() && duration.has_value() ? end.at : std::nullopt;
+            end.after = {name};
         }
+        return end;
+    }
+
+    /// The `do` directive as a storyboard.
+    ///
+    /// One Story, one Act, and one ManeuverGroup per phase — the group is where
+    /// an actor lives, so a group per phase keeps each invocation's actor with
+    /// its actions. Composition decides only *when* a phase starts, which is a
+    /// start trigger on its Event; the runtime is unchanged.
+    void build(const DoMember& root, const std::string& story_name, ir::Storyboard& out) {
+        ir::Act act;
+        act.name = "act";
+        const TimePoint end = lower_member(root, TimePoint{0.0, {}}, act);
 
         if (act.groups.empty()) {
             return; // an empty Act would be an init-time validation error
@@ -724,6 +976,13 @@ struct Behaviors {
         story.name = story_name;
         story.acts.push_back(std::move(act));
         out.stories.push_back(std::move(story));
+
+        // §7.6.2: the scenario ends when its `do` directive ends. When that
+        // moment is a constant the storyboard can say so, which is what makes
+        // the run's element states finish rather than hang at running.
+        if (end.at.has_value() && end.after.empty() && *end.at > 0.0) {
+            out.stop_trigger = trigger_for(end);
+        }
     }
 };
 
@@ -937,7 +1196,8 @@ Status lower(const Program& program, const LoadResult& loaded, const LowerOption
         }
     }
 
-    Behaviors behaviors{program, library, root->path, context, bindings, {}, sink};
+    Behaviors behaviors{program, library, root->path, context, bindings, {}, options.alternative,
+                        {},      sink};
     for (const ir::Entity& entity : out.entities) {
         behaviors.entities.insert(entity.id);
     }
diff --git a/frontends/dsl/src/parser.cpp b/frontends/dsl/src/parser.cpp
index 53bed95..039c9cd 100644
--- a/frontends/dsl/src/parser.cpp
+++ b/frontends/dsl/src/parser.cpp
@@ -640,7 +640,7 @@ ExprPtr Parser::parse_primary() {
         // Either a list constructor or the `[a..b]` range form (§7.2.2.6.7).
         advance();
         ExprPtr first = parse_expression();
-        if (at_op("...")) {
+        if (at_op("..")) {
             advance();
             expr->kind = ExprKind::RangeConstructor;
             expr->operands = {std::move(first), parse_expression()};
diff --git a/frontends/dsl/tests/dsl_constraint_test.cpp b/frontends/dsl/tests/dsl_constraint_test.cpp
index e3f9431..ef37a92 100644
--- a/frontends/dsl/tests/dsl_constraint_test.cpp
+++ b/frontends/dsl/tests/dsl_constraint_test.cpp
@@ -207,7 +207,7 @@ TEST(DslConstraintTest, AConjunctionOfBindingsIsAccepted) {
 
 TEST(DslConstraintTest, AMembershipBindingIsAccepted) {
     const std::vector<scena::Diagnostic> diagnostics =
-        check("    v: speed\n    keep(v in [10.0kph...30.0kph])\n");
+        check("    v: speed\n    keep(v in [10.0kph..30.0kph])\n");
     EXPECT_FALSE(has_error(diagnostics));
     EXPECT_FALSE(notes_unsupported(diagnostics));
 }
diff --git a/frontends/dsl/tests/dsl_expression_test.cpp b/frontends/dsl/tests/dsl_expression_test.cpp
index 4ea89f3..1dde14e 100644
--- a/frontends/dsl/tests/dsl_expression_test.cpp
+++ b/frontends/dsl/tests/dsl_expression_test.cpp
@@ -386,10 +386,10 @@ TEST(DslExpressionTest, IndexingSomethingThatIsNotAListIsReported) {
 
 TEST(DslExpressionTest, RangeConstructorsTakeBothFormsAndACommonBase) {
     Program program = host_program("    r: range of float\n    s: range of speed\n");
-    EXPECT_EQ(type_name_of(program, "[1.5...3.5]"), "range of float");
+    EXPECT_EQ(type_name_of(program, "[1.5..3.5]"), "range of float");
     EXPECT_EQ(type_name_of(program, "range(1.5, 3.5)"), "range of float");
     // §7.4.2.8.1: one float and one int converts to float.
-    EXPECT_EQ(type_name_of(program, "[10...20.5]"), "range of float");
+    EXPECT_EQ(type_name_of(program, "[10..20.5]"), "range of float");
 }
 
 TEST(DslExpressionTest, RangeBoundOperatorsYieldTheBaseType) {
@@ -402,7 +402,7 @@ TEST(DslExpressionTest, RangeBoundOperatorsYieldTheBaseType) {
 TEST(DslExpressionTest, ARangeOverTwoDifferentPhysicalTypesIsReported) {
     Program program = host_program("    v: speed\n    d: length\n");
     DiagnosticSink sink;
-    EXPECT_EQ(type_of_expression(program, "[1.0kph...2.0m]", sink), kInvalidType);
+    EXPECT_EQ(type_of_expression(program, "[1.0kph..2.0m]", sink), kInvalidType);
     EXPECT_TRUE(mentions(sink.diagnostics(), "§7.4.2.8.1"));
 }
 
@@ -549,8 +549,8 @@ TEST(DslExpressionTest, RangeBoundsAreOrderedByValue) {
     Program program = host_program("    a: int\n");
     Value forward;
     Value backward;
-    ASSERT_TRUE(fold(program, "[1.0...5.0]", forward));
-    ASSERT_TRUE(fold(program, "[5.0...1.0]", backward));
+    ASSERT_TRUE(fold(program, "[1.0..5.0]", forward));
+    ASSERT_TRUE(fold(program, "[5.0..1.0]", backward));
     ASSERT_EQ(forward.items.size(), 2U);
     EXPECT_EQ(forward.items[0].as_double(), 1.0);
     EXPECT_EQ(backward.items[0].as_double(), 1.0);
@@ -560,9 +560,9 @@ TEST(DslExpressionTest, RangeBoundsAreOrderedByValue) {
 TEST(DslExpressionTest, MembershipFoldsOverListsAndRanges) {
     Program program = host_program("    a: int\n");
     Value value;
-    ASSERT_TRUE(fold(program, "3.0 in [1.0...5.0]", value));
+    ASSERT_TRUE(fold(program, "3.0 in [1.0..5.0]", value));
     EXPECT_TRUE(value.boolean);
-    ASSERT_TRUE(fold(program, "7.0 in [1.0...5.0]", value));
+    ASSERT_TRUE(fold(program, "7.0 in [1.0..5.0]", value));
     EXPECT_FALSE(value.boolean);
     ASSERT_TRUE(fold(program, "2 in [1, 2, 3]", value));
     EXPECT_TRUE(value.boolean);
diff --git a/frontends/dsl/tests/dsl_lexer_test.cpp b/frontends/dsl/tests/dsl_lexer_test.cpp
index 4b295cc..9bee7c9 100644
--- a/frontends/dsl/tests/dsl_lexer_test.cpp
+++ b/frontends/dsl/tests/dsl_lexer_test.cpp
@@ -504,6 +504,28 @@ scenario dut.cut_in:
     EXPECT_GT(indents, 0);
 }
 
+TEST(DslLexerTest, TheRangeOperatorWinsOverAFloatThatStartsWithADot) {
+    // §7.2.2.6.7 spells the range constructor `'[' expression '..' expression
+    // ']'`, and §7.2.1.5.2's `float-literal ::= digit* '.' digit+` makes the
+    // leading digits optional — so `[2..4]` is a race between `..` and `.4`,
+    // and the operator has to win or the standard's own spelling does not lex.
+    // Table 5 lists neither `..` nor `::`; the grammar productions decide.
+    const std::vector<Token> tokens = lex_ok("[2..4]");
+    ASSERT_EQ(tokens.size(), 7U); // [ 2 .. 4 ] NEWLINE EOF
+    EXPECT_EQ(tokens[1].text, "2");
+    EXPECT_EQ(tokens[2].text, "..");
+    EXPECT_EQ(tokens[3].text, "4");
+}
+
+TEST(DslLexerTest, ARangeOfPhysicalLiteralsLexesToo) {
+    // The form the specification actually writes durations in (§7.6.2.4).
+    const std::vector<Token> tokens = lex_ok("[10s..30s]");
+    ASSERT_EQ(tokens.size(), 7U);
+    EXPECT_EQ(tokens[1].text, "10s");
+    EXPECT_EQ(tokens[2].text, "..");
+    EXPECT_EQ(tokens[3].text, "30s");
+}
+
 TEST(DslLexerTest, LexingIsDeterministicAcrossRepeats) {
     // The frontend's output reaches the IR, so it is inside the bit-identity
     // contract exactly as the XML frontend's is.
diff --git a/frontends/dsl/tests/dsl_lowering_test.cpp b/frontends/dsl/tests/dsl_lowering_test.cpp
index fd22ef5..7d9c097 100644
--- a/frontends/dsl/tests/dsl_lowering_test.cpp
+++ b/frontends/dsl/tests/dsl_lowering_test.cpp
@@ -35,6 +35,7 @@
 #include "scena/dsl/lower.h"
 #include "scena/dsl/types.h"
 #include "scena/ir/action.h"
+#include "scena/ir/condition.h"
 #include "scena/ir/entity.h"
 #include "scena/ir/position.h"
 #include "scena/ir/scenario.h"
@@ -64,7 +65,8 @@ struct Lowered {
 
 /// Checks `source`, then lowers it. Both statuses are recorded rather than
 /// asserted, so a test can pin either half.
-void run(std::string_view source, Lowered& out, const std::string& entry_point = {}) {
+void run(std::string_view source, Lowered& out, const std::string& entry_point = {},
+         const std::string& alternative = {}) {
     out.check_status = scena::dsl::check_source(source, "<test>", LoadOptions{}, out.loaded,
                                                 out.program, out.check_sink);
     if (out.check_status != Status::Ok) {
@@ -72,6 +74,7 @@ void run(std::string_view source, Lowered& out, const std::string& entry_point =
     }
     LowerOptions options;
     options.entry_point = entry_point;
+    options.alternative = alternative;
     out.status = scena::dsl::lower(out.program, out.loaded, options, out.lowered, out.sink);
 }
 
@@ -639,32 +642,204 @@ TEST(DslLoweringTest, AnUnlabelledPhaseGetsItsPositionAsAName) {
     EXPECT_EQ(lowered[1].name, "phase_2");
 }
 
-TEST(DslLoweringTest, OneOfIsReportedAsBelongingToTheNextSprint) {
+// --- composition (§7.6.2.1) -------------------------------------------------
+
+/// The start condition of a phase, rendered as text so a test can read it.
+std::string trigger_text(const Phase& phase) {
+    if (phase.event == nullptr || !phase.event->start_trigger.has_value()) {
+        return "(with parent)";
+    }
+    std::string out;
+    for (const scena::ir::ConditionGroup& group : phase.event->start_trigger->groups) {
+        for (const scena::ir::TriggerCondition& condition : group.conditions) {
+            if (const auto* time = dynamic_cast<const scena::ir::SimulationTimeCondition*>(
+                    condition.expression.get())) {
+                out += "t>=" + std::to_string(time->value()).substr(0, 4) + " ";
+            } else if (const auto* element =
+                           dynamic_cast<const scena::ir::StoryboardElementStateCondition*>(
+                               condition.expression.get())) {
+                out += element->element_ref() + " complete ";
+            }
+        }
+    }
+    return out;
+}
+
+TEST(DslLoweringTest, ConcreteDurationsBecomeAbsoluteStartTimes) {
+    // The storyboard starts at t = 0 and every duration that lowers is a
+    // constant, so a phase's start time is the sum of the ones before it —
+    // arithmetic load time can do, with no runtime feedback.
+    Lowered result;
+    run(std::string(kPrelude).append(
+            "scenario go:\n"
+            "    ego: vehicle\n"
+            "    do serial:\n"
+            "        a: ego.assign_speed(speed: 10mps, duration: 4s)\n"
+            "        b: ego.change_speed(target: 20mps, rate_peak: 2.0, duration: 6s)\n"),
+        result);
+    ASSERT_EQ(result.check_status, Status::Ok) << first_message(result.check_sink);
+    ASSERT_EQ(result.status, Status::Ok) << first_message(result.sink);
+    const std::vector<Phase> lowered = phases(result.lowered.scenario);
+    ASSERT_EQ(lowered.size(), 2U);
+    // The first phase starts with its parent: `t >= 0` would be a tautology.
+    EXPECT_EQ(trigger_text(lowered[0]), "(with parent)");
+    EXPECT_EQ(trigger_text(lowered[1]), "t>=4.00 ");
+    // The scenario ends when its `do` directive does, and here that is a
+    // constant, so the storyboard can say so.
+    ASSERT_TRUE(result.lowered.scenario.storyboard.stop_trigger.has_value());
+}
+
+TEST(DslLoweringTest, APhaseWithoutADurationChainsOnCompletionInstead) {
     Lowered result;
     run(std::string(kPrelude).append("scenario go:\n"
                                      "    ego: vehicle\n"
-                                     "    do one_of:\n"
+                                     "    do serial:\n"
                                      "        a: ego.assign_speed(speed: 10mps)\n"
-                                     "        b: ego.assign_speed(speed: 20mps)\n"),
+                                     "        b: ego.remain_stationary()\n"),
         result);
     ASSERT_EQ(result.status, Status::Ok) << first_message(result.sink);
-    EXPECT_TRUE(sink_says(result.sink, "one_of"));
-    EXPECT_TRUE(result.lowered.scenario.storyboard.stories.empty());
+    const std::vector<Phase> lowered = phases(result.lowered.scenario);
+    ASSERT_EQ(lowered.size(), 2U);
+    EXPECT_EQ(trigger_text(lowered[1]), "a complete ");
+    // Nothing fixes when the run ends, so nothing claims to.
+    EXPECT_FALSE(result.lowered.scenario.storyboard.stop_trigger.has_value());
+}
+
+TEST(DslLoweringTest, AParallelCompositionEndsWhenItsLastMemberDoes) {
+    // §7.6.2.1.4's default overlap is `start`: members begin together and may
+    // end apart, so what follows waits for the last of them.
+    Lowered result;
+    run(std::string(kPrelude).append(
+            "scenario go:\n"
+            "    ego: vehicle\n"
+            "    lead: vehicle\n"
+            "    do serial:\n"
+            "        setup: ego.assign_speed(speed: 10mps, duration: 2s)\n"
+            "        both: parallel:\n"
+            "            x: ego.change_speed(target: 20mps, rate_peak: 2.0, duration: 5s)\n"
+            "            y: lead.assign_speed(speed: 30mps, duration: 3s)\n"
+            "        after: ego.remain_stationary()\n"),
+        result);
+    ASSERT_EQ(result.check_status, Status::Ok) << first_message(result.check_sink);
+    ASSERT_EQ(result.status, Status::Ok) << first_message(result.sink);
+    const std::vector<Phase> lowered = phases(result.lowered.scenario);
+    ASSERT_EQ(lowered.size(), 4U);
+    // Both members of the parallel start when the composition does ...
+    EXPECT_EQ(trigger_text(lowered[1]), "t>=2.00 ");
+    EXPECT_EQ(trigger_text(lowered[2]), "t>=2.00 ");
+    EXPECT_EQ(lowered[1].actor, "ego");
+    EXPECT_EQ(lowered[2].actor, "lead");
+    // ... and the phase after it waits for the longer of the two (2 + 5).
+    EXPECT_EQ(trigger_text(lowered[3]), "t>=7.00 ");
+}
+
+TEST(DslLoweringTest, AParallelJoinAndsTheMembersThatEndOnCompletion) {
+    // A ConditionGroup is an AND, which is what makes "all members done"
+    // expressible when their end times are not constants.
+    Lowered result;
+    run(std::string(kPrelude).append("scenario go:\n"
+                                     "    ego: vehicle\n"
+                                     "    lead: vehicle\n"
+                                     "    do serial:\n"
+                                     "        both: parallel:\n"
+                                     "            x: ego.assign_speed(speed: 10mps)\n"
+                                     "            y: lead.assign_speed(speed: 30mps)\n"
+                                     "        after: ego.remain_stationary()\n"),
+        result);
+    ASSERT_EQ(result.check_status, Status::Ok) << first_message(result.check_sink);
+    ASSERT_EQ(result.status, Status::Ok) << first_message(result.sink);
+    const std::vector<Phase> lowered = phases(result.lowered.scenario);
+    ASSERT_EQ(lowered.size(), 3U);
+    EXPECT_EQ(trigger_text(lowered[2]), "x complete y complete ");
+}
+
+TEST(DslLoweringTest, WaitElapsedAdvancesTheClockAndNothingElse) {
+    // §7.6.2.4.2: a phase of the given length in which nothing is specified.
+    // Nothing is exactly what it lowers to — the clock is already running.
+    Lowered result;
+    run(std::string(kPrelude).append("scenario go:\n"
+                                     "    ego: vehicle\n"
+                                     "    do serial:\n"
+                                     "        a: ego.assign_speed(speed: 10mps, duration: 2s)\n"
+                                     "        wait elapsed(3s)\n"
+                                     "        b: ego.remain_stationary()\n"),
+        result);
+    ASSERT_EQ(result.check_status, Status::Ok) << first_message(result.check_sink);
+    ASSERT_EQ(result.status, Status::Ok) << first_message(result.sink);
+    const std::vector<Phase> lowered = phases(result.lowered.scenario);
+    ASSERT_EQ(lowered.size(), 2U);
+    EXPECT_EQ(trigger_text(lowered[1]), "t>=5.00 ");
+}
+
+TEST(DslLoweringTest, OneOfRunsItsFirstAlternativeUnlessOneIsNamed) {
+    // §7.6.2.1.3 says at least one alternative must hold and says nothing about
+    // which, so the choice is an input rather than a coin toss.
+    const std::string source =
+        std::string(kPrelude).append("scenario go:\n"
+                                     "    ego: vehicle\n"
+                                     "    do one_of:\n"
+                                     "        slow: ego.assign_speed(speed: 10mps)\n"
+                                     "        fast: ego.assign_speed(speed: 30mps)\n");
+    Lowered first;
+    run(source, first);
+    ASSERT_EQ(first.status, Status::Ok) << first_message(first.sink);
+    ASSERT_EQ(phases(first.lowered.scenario).size(), 1U);
+    EXPECT_EQ(phases(first.lowered.scenario)[0].name, "slow");
+}
+
+TEST(DslLoweringTest, AnAlternativeThatIsNotThereIsReported) {
+    Lowered result;
+    run(std::string(kPrelude).append("scenario go:\n"
+                                     "    ego: vehicle\n"
+                                     "    do one_of:\n"
+                                     "        slow: ego.assign_speed(speed: 10mps)\n"
+                                     "        fast: ego.assign_speed(speed: 30mps)\n"),
+        result, "", "nope");
+    EXPECT_EQ(result.status, Status::ValidationError);
+    EXPECT_TRUE(sink_says(result.sink, "not an alternative"));
+}
+
+TEST(DslLoweringTest, ARangeDurationBoundsTracesRatherThanFixingATime) {
+    // §7.6.2.4's range is a constraint on accepted traces; choosing a value
+    // from it needs a solver, which is post-v0.0.1 (ADR-0004).
+    Lowered result;
+    run(std::string(kPrelude).append(
+            "scenario go:\n"
+            "    ego: vehicle\n"
+            "    do a: ego.assign_speed(speed: 10mps, duration: [2s..4s])\n"),
+        result);
+    ASSERT_EQ(result.check_status, Status::Ok) << first_message(result.check_sink);
+    ASSERT_EQ(result.status, Status::Ok) << first_message(result.sink);
+    EXPECT_TRUE(sink_says(result.sink, "not a single value"));
+    EXPECT_FALSE(result.lowered.scenario.storyboard.stop_trigger.has_value());
+}
+
+TEST(DslLoweringTest, ANonDefaultParallelOverlapIsReported) {
+    Lowered result;
+    run(std::string(kPrelude).append("scenario go:\n"
+                                     "    ego: vehicle\n"
+                                     "    lead: vehicle\n"
+                                     "    do parallel(overlap: equal):\n"
+                                     "        x: ego.assign_speed(speed: 10mps)\n"
+                                     "        y: lead.assign_speed(speed: 30mps)\n"),
+        result);
+    ASSERT_EQ(result.check_status, Status::Ok) << first_message(result.check_sink);
+    ASSERT_EQ(result.status, Status::Ok) << first_message(result.sink);
+    EXPECT_TRUE(sink_says(result.sink, "overlap 'equal'"));
 }
 
-TEST(DslLoweringTest, ModifiersAndInvocationDurationsAreReportedAsDeferred) {
-    // Both are real constructs of the invocation, and both belong to a later
+TEST(DslLoweringTest, ModifiersAreReportedAsDeferred) {
+    // A modifier is a real construct of the invocation that belongs to a later
     // sprint. Reporting beats silently running a scenario that says more than
     // the engine was told.
     Lowered result;
     run(std::string(kPrelude).append("scenario go:\n"
                                      "    ego: vehicle\n"
-                                     "    do phase: ego.drive(duration: 5s) with:\n"
+                                     "    do phase: ego.drive() with:\n"
                                      "        speed(speed: 30kph)\n"),
         result);
     ASSERT_EQ(result.check_status, Status::Ok) << first_message(result.check_sink);
     ASSERT_EQ(result.status, Status::Ok) << first_message(result.sink);
-    EXPECT_TRUE(sink_says(result.sink, "p8-s2 (#45)"));
     EXPECT_TRUE(sink_says(result.sink, "p8-s3 (#46)"));
 }
 
diff --git a/frontends/dsl/tests/dsl_parser_test.cpp b/frontends/dsl/tests/dsl_parser_test.cpp
index ae534eb..830f5fe 100644
--- a/frontends/dsl/tests/dsl_parser_test.cpp
+++ b/frontends/dsl/tests/dsl_parser_test.cpp
@@ -176,7 +176,7 @@ TEST(DslParserTest, EnumsDeclareMembersWithOptionalValues) {
 }
 
 TEST(DslParserTest, AnEnumExtensionIsMarkedAsOne) {
-    // §7.2.2.2.6: enum-type-extension ::= 'extend' enum-name ':' '[' ... ']'
+    // §7.2.2.2.6: enum-type-extension ::= 'extend' enum-name ':' '[' .. ']'
     const File file = parse_ok("extend side: [up, down]\n");
     ASSERT_EQ(file.declarations.size(), 1U);
     EXPECT_EQ(file.declarations[0].kind, Declaration::Kind::Enum);
@@ -573,7 +573,7 @@ TEST(DslParserTest, ListAndRangeConstructorsTakeBothForms) {
     EXPECT_EQ(list->kind, ExprKind::ListConstructor);
     EXPECT_EQ(list->operands.size(), 3U);
     // range-constructor ::= 'range' '(' a ',' b ')' | '[' a '..' b ']'
-    const auto bracket_range = parse_expr("[1...5]");
+    const auto bracket_range = parse_expr("[1..5]");
     EXPECT_EQ(bracket_range->kind, ExprKind::RangeConstructor);
     EXPECT_EQ(bracket_range->operands.size(), 2U);
     const auto call_range = parse_expr("range(1, 5)");
@@ -596,7 +596,7 @@ TEST(DslParserTest, ItIsAPrimaryExpression) {
 }
 
 TEST(DslParserTest, InIsARelationalOperator) {
-    const auto expr = parse_expr("x in [1...5]");
+    const auto expr = parse_expr("x in [1..5]");
     ASSERT_EQ(expr->kind, ExprKind::Binary);
     EXPECT_EQ(expr->text, "in");
 }
diff --git a/tools/scena-run/src/main.cpp b/tools/scena-run/src/main.cpp
index 31f9cb1..0715e61 100644
--- a/tools/scena-run/src/main.cpp
+++ b/tools/scena-run/src/main.cpp
@@ -98,7 +98,7 @@ usage: scena-run <scenario> [options]
   --trace-format <csv|json>  override the format inferred from the extension
   --map <file.xodr>          road network, overriding the scenario's LogicFile
   --replay <entity>=<file>   drive a host-controlled entity from a trace file
-  --select <alternative>     choose a one_of alternative by name (DSL, p8-s2)
+  --select <alternative>     choose a one_of alternative by label (.osc only)
   --entry <scenario>         the DSL scenario to run (.osc only)
   -I, --search-path <dir>    where DSL imports are looked up (repeatable)
   --quiet                    do not print diagnostics to stderr
@@ -438,12 +438,12 @@ int main(int argc, char** argv) {
     }
     const Options& options = *parsed;
 
-    if (!options.select.empty()) {
-        // Accepted and reported rather than silently ignored: one_of alternatives
-        // are a DSL construct and arrive with p8-s2 (#45).
+    if (!options.select.empty() && options.scenario.extension() != ".osc") {
+        // Accepted and reported rather than silently ignored: `one_of` is a DSL
+        // construct, so the option means nothing to an XML scenario.
         if (!options.quiet) {
-            std::cerr << "warning: --select has no effect yet; one_of alternatives arrive with "
-                         "the DSL execution pillar (p8-s2)\n";
+            std::cerr << "warning: --select names a one_of alternative, which only an "
+                         "OpenSCENARIO DSL scenario has\n";
         }
     }
 
@@ -464,6 +464,7 @@ int main(int argc, char** argv) {
         if (loaded == scena::Status::Ok) {
             scena::dsl::LowerOptions lower_options;
             lower_options.entry_point = options.entry;
+            lower_options.alternative = options.select;
             scena::dsl::LowerResult lowered;
             loaded = scena::dsl::lower(program, files, lower_options, lowered, load_sink);
             scenario = std::move(lowered.scenario);
diff --git a/tools/scena-run/tests/scena_run_test.cpp b/tools/scena-run/tests/scena_run_test.cpp
index 6646af1..b1402a9 100644
--- a/tools/scena-run/tests/scena_run_test.cpp
+++ b/tools/scena-run/tests/scena_run_test.cpp
@@ -299,16 +299,6 @@ TEST(ScenaRunTest, ReplayDrivesAHostControlledEntity) {
     }
 }
 
-TEST(ScenaRunTest, SelectIsAcceptedAndReportedAsNotYetActive) {
-    std::string output;
-    ASSERT_EQ(run("\"" + golden("gs1-cruise-baseline.xosc").string() +
-                      "\" --dt 0.1 --duration 0.2 --select alt",
-                  output),
-              0)
-        << output;
-    EXPECT_NE(output.find("--select has no effect yet"), std::string::npos);
-}
-
 // --- the DSL frontend (p8-s1, #44) -----------------------------------------
 
 /// Writes a DSL scenario to a temporary file and returns its path. The source
@@ -411,6 +401,84 @@ scenario mapped:
     EXPECT_NE(output.find("no_such_map.xodr"), std::string::npos) << output;
 }
 
+// --- composition operators (p8-s2, #45) ------------------------------------
+
+TEST(ScenaRunTest, SelectSaysSoWhenTheScenarioHasNoAlternatives) {
+    // `one_of` is a DSL construct, so the option means nothing to XML — said
+    // out loud rather than ignored.
+    std::string output;
+    ASSERT_EQ(run("\"" + golden("gs1-cruise-baseline.xosc").string() +
+                      "\" --dt 0.1 --duration 0.2 --select alt",
+                  output),
+              0)
+        << output;
+    EXPECT_NE(output.find("--select names a one_of alternative"), std::string::npos);
+}
+
+TEST(ScenaRunTest, SelectChoosesAOneOfAlternative) {
+    // §7.6.2.1.3 leaves the choice to the executor. Making it an input is what
+    // keeps the run reproducible; the default is the first alternative.
+    const fs::path scenario = dsl_file("scena_run_one_of.osc",
+                                       R"(import osc.standard.all
+
+namespace demo use std, stdtypes
+
+scenario pick:
+    ego: vehicle
+    do one_of:
+        slow: ego.assign_speed(speed: 10mps)
+        fast: ego.assign_speed(speed: 30mps)
+)");
+    const fs::path first = temp_file("scena_run_one_of_first.csv");
+    std::string output;
+    ASSERT_EQ(run("\"" + scenario.string() + "\" --dt 0.1 --duration 0.2 --trace \"" +
+                      first.string() + "\"",
+                  output),
+              0)
+        << output;
+    ASSERT_GT(read_lines(first).size(), 1U);
+    EXPECT_NE(read_lines(first)[1].find(",10"), std::string::npos) << read_lines(first)[1];
+
+    const fs::path chosen = temp_file("scena_run_one_of_fast.csv");
+    ASSERT_EQ(run("\"" + scenario.string() + "\" --dt 0.1 --duration 0.2 --select fast --trace \"" +
+                      chosen.string() + "\"",
+                  output),
+              0)
+        << output;
+    ASSERT_GT(read_lines(chosen).size(), 1U);
+    EXPECT_NE(read_lines(chosen)[1].find(",30"), std::string::npos) << read_lines(chosen)[1];
+}
+
+TEST(ScenaRunTest, ADslScenarioSequencesItsPhasesByDuration) {
+    // The p8-s2 exit criterion end to end: a serial composition with concrete
+    // durations turns into absolute phase boundaries in the trace.
+    const fs::path scenario = dsl_file("scena_run_phases.osc",
+                                       R"(import osc.standard.all
+
+namespace demo use std, stdtypes
+
+scenario phases:
+    ego: vehicle
+    do serial:
+        cruise: ego.assign_speed(speed: 10mps, duration: 1s)
+        stop: ego.remain_stationary()
+)");
+    const fs::path trace = temp_file("scena_run_phases.csv");
+    std::string output;
+    ASSERT_EQ(run("\"" + scenario.string() + "\" --dt 0.1 --duration 2 --trace \"" +
+                      trace.string() + "\"",
+                  output),
+              0)
+        << output;
+    const std::vector<std::string> lines = read_lines(trace);
+    ASSERT_EQ(lines.size(), 21U);
+    // Phase 1 holds 10 m/s ...
+    EXPECT_EQ(lines[1], "0.1,ego,1,0,0,0,10");
+    // ... and phase 2 takes over at t = 1 s, exactly where the duration said:
+    // 10 m covered in that second, then standing still for the rest of the run.
+    EXPECT_EQ(lines.back(), "2,ego,10,0,0,0,0");
+}
+
 TEST(ScenaRunTest, QuietSuppressesDiagnosticsButNotFailures) {
     std::string output;
     EXPECT_EQ(run("no/such/scenario.xosc --quiet", output), 3);