final edits maybe?

execution.bs

@@ -5491,7 +5491,10 @@ template<class Initializer>
     associated environment is equal to the environment associated with the
     receiver used to create it. The lifetime of an asynchronous operation's
     associated operation state does not depend on the lifetimes of either the
-    sender or the receiver from which it was created. A sender <dfn lt="send"
+    sender or the receiver from which it was created. A sender is started when
+    it is connected to a receiver and the resulting asynchronous operation is
+    started. A sender's async result is the async result of an asynchronous
+    operation created by connecting it to a receiver. A sender <dfn lt="send"
     export=true>sends</dfn> its results by way of the asynchronous operation(s)
     it produces, and a receiver <dfn lt="receive" export=true>receives</dfn>
     those results. A sender is either valid or invalid; it becomes invalid
@@ -7847,12 +7850,19 @@ namespace std::execution {
         execution back to the execution resource on which `sndr` completed.
 
 2. The name `on` denotes a pipeable sender adaptor object. For subexpressions
-    `sch` and `sndr`, if `decltype((sch))` does not satisfy `scheduler`, or
-    `decltype((sndr))` does not satisfy `sender`, `on(sch, sndr)` is ill-formed.
-    If `sndr` is a pipeable sender adaptor closure object, `on(sch, sndr)` is
-    ambiguous with the partial application of the overload described below.
+    `sch` and `sndr`, `on(sch, sndr)` is ill-formed if any of the following
+    are `true`:
+
+    * If `decltype((sch))` does not satisfy `scheduler`, or
+
+    * If `decltype((sndr))` does not satisfy `sender` and `sndr` is not
+      a pipeable sender adaptor closure object ([exec.adapt.objects]), or
+
+    * If `decltype((sndr))` satisfies `sender` and `sndr` is also
+      a pipeable sender adaptor closure object.
 
-3. Otherwise, the expression `on(sch, sndr)` is expression-equivalent to:
+3. Otherwise, if `decltype((sndr))` satisfies `sender`, the expression `on(sch,
+    sndr)` is expression-equivalent to:
 
     <pre highlight="c++">
     transform_sender(
@@ -9467,7 +9477,7 @@ namespace std::execution {
 
 ## Execution contexts <b>[exec.ctx]</b> ## {#spec-execution.contexts}
 
-### `run_loop` <b>[exec.run.loop]</b> ### {#spec-execution.contexts.run_loop}
+### `execution::run_loop` <b>[exec.run.loop]</b> ### {#spec-execution.contexts.run_loop}
 
 1. A `run_loop` is an execution resource on which work can be scheduled. It
     maintains a thread-safe first-in-first-out queue of work. Its `run()`
@@ -9822,7 +9832,7 @@ void finish();
         * <i>Mandates:</i> <code><i>is-awaitable</i>&lt;A, Promise></code> is
             `true`, where `A` is the type of the expression above.
 
-    2. Otherwise, `void(p), expr` if <code><i>is-awaitable</i>&lt;Expr, <i>U</i>></code>
+    2. Otherwise, `(void(p), expr)` if <code><i>is-awaitable</i>&lt;Expr, <i>U</i>></code>
         is `true`, where <i>`U`</i> is an unspecified class type that
         is not `Promise` and that lacks a member named `await_transform`.
 
@@ -9835,7 +9845,7 @@ void finish();
     3. Otherwise, <code><i>sender-awaitable</i>{expr, p}</code> if
         <code><i>awaitable-sender</i>&lt;Expr, Promise></code> is `true`.
 
-    4. Otherwise, `void(p), expr`.
+    4. Otherwise, `(void(p), expr)`.
 
     except that the evaluations of `expr` and `p` are indeterminately sequenced.