@@ -36,10 +36,12 @@ T2.9 is forecasting's options on top of the split already in the core (E153): `n
 
 ### Deviations and questions
 
-- **An average, a minimum or a maximum's lag is the reference's, misaligned** (matched, a question for the orchestrator).
+- **An average's, a minimum's or a maximum's lag on its own row** (fix 1, decided by the orchestrator under KO2-70 on 2026-10-19).
   The reference's executor labels a lag through `execute_join`, which drops the examples whose window holds no value, and the engine's frame of the lags lines the rest up by position, so each value moves to the first examples rather than its own, and the last examples get none (shown: user 0's predicted row at 2023-08-01 gets no lag where its window holds 112.0).
-  The core matches it (`lag.rs`, its module docs), so the payloads are equal.
-  Fixing it (each value on its own example) is one line in `Lag::columns` and a register entry; it changes what the model is told, so it is the orchestrator's to decide (KO2-70).
+  The core puts each value on its own example (`lag.rs`'s `Lag::columns`, by the labels' mask), so these columns differ from the reference's; a sum's, a count's and every comparison of them are unchanged.
+  Held by `lag.rs`'s `a_maximum_s_values_keep_their_rows_across_gaps` and `an_average_s_value_is_on_its_own_example`, and the route test `test_an_average_s_lag_is_each_row_s_own_window` (each predicted row's lag its own window's average, read from the data; nothing else of the request differs from the old route's).
+  The 40-source differential after the fix: every payload difference is an average's, a minimum's or a maximum's lag column (or a comparison of one), none elsewhere.
+  Its register entry waits for an ID (lane b's block, P2B-1 to P2B-19, is spent) and for KO2-70 on the phase head, as does P2B-19's approval.
 - **Wording of the refused lags** (the orchestrator's note): the reference refuses `-1` with its engine's own sentence (`'lag_timesteps' cannot be negative (got -1)`), and `1.5`, `2.0` and `true` (`unsupported operand type(s) for *: 'float' and 'DateOffset'`) and `"2"` (`'<' not supported between instances of 'str' and 'int'`) with Python's TypeError text, all `INVALID_REQUEST`.
   The core route gives the same code and class, details `field: lag_timesteps` and `reason` (`negative`, `not_a_whole_number`, `not_a_number`), and the Python host says plainly: "lag_timesteps is how many past steps of the target are added as features, a whole number of zero or more; this one is refused (<reason>)" (`_rust/errors.py`'s `WORDED`; test `test_a_refused_lag_is_said_plainly_under_the_reference_s_code`).
   A lag past the time range is said as "lag_timesteps reaches further back than a time can be held (before 1677); ask for fewer steps" (P2B-18). The cases hold codes, not messages (H17).
 
@@ -199,7 +199,6 @@ def test_the_regression_s_statistic_is_recorded_as_on_the_old_route(
     [
         QUERY,
         BINARY,
-        'PREDICT AVG(orders.price, 0, 30, days) FOR EACH users.user_id',
         'PREDICT users.age FOR EACH users.user_id',
     ],
 )
@@ -217,6 +216,56 @@ def test_lag_timesteps_builds_the_request_the_old_route_builds(
     )
 
 
+def test_an_average_s_lag_is_each_row_s_own_window(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    # T2.9 fix 1 (registered, decided under KO2-70): the reference's engine
+    # lines an average's lagged values up by position, so they land on the
+    # first rows rather than their own; the core puts each on its own row.
+    # Each predicted row's lag is its own window's average, read here from
+    # the data, and nothing else of the request differs from the old route.
+    query = 'PREDICT AVG(orders.price, 0, 30, days) FOR EACH users.user_id'
+    monkeypatch.setenv(_routing.ENVIRONMENT, CORE)
+    core = _materialize(query=query, lag_timesteps=2)._payloads[0]
+    monkeypatch.delenv(_routing.ENVIRONMENT)
+    table = core['predict']['instance_table']
+    at = table['columns'].index('__kumo_arl0__')
+    connection = _connection()
+    for row, user in zip(table['rows'], [0, 1], strict=True):
+        for k, (start, end) in enumerate(
+            [('2024-01-31', '2024-03-01'), ('2024-01-01', '2024-01-31')]
+        ):
+            [(mean,)] = connection.execute(
+                'SELECT AVG(price) FROM orders WHERE user_id = ? '
+                'AND ts > ?::TIMESTAMP AND ts <= ?::TIMESTAMP',
+                [user, start, end],
+            ).fetchall()
+            got = row[at + k]
+            if mean is None:
+                assert got is None
+            else:
+                assert got == float(np.float32(mean))
+    if _old_route_needs_the_engine():
+        return
+    old = _materialize(query=query, lag_timesteps=2)._payloads[0]
+    old = json.loads(json.dumps(old, default=str))
+
+    def without_lags(payload: dict[str, Any]) -> dict[str, Any]:
+        payload = json.loads(json.dumps(payload))
+        for half in ('context', 'predict'):
+            table = payload[half]['instance_table']
+            keep = [
+                i
+                for i, c in enumerate(table['columns'])
+                if not c.startswith('__kumo_arl')
+            ]
+            table['columns'] = [table['columns'][i] for i in keep]
+            table['rows'] = [[r[i] for i in keep] for r in table['rows']]
+        return payload
+
+    assert without_lags(core) == without_lags(old)
+
+
 @pytest.mark.parametrize(
     ('value', 'reason'),
     [
 
@@ -23,13 +23,13 @@
 //! there (`execute` with `filter_na=False` over a query whose aggregation
 //! is joined, so `execute_join` drops what has no value): an aggregation
 //! (a sum or a count of every example; an average, a minimum or a maximum
-//! of only the examples whose window holds a value) or its comparison, its
-//! values in the examples' order, the first value the first example's,
-//! and an example past the values none, as the engine's frame of the steps
-//! lines them up by position (`pd.DataFrame`, then `pd.concat` with the
-//! examples). That is the reference's: an average, a minimum or a maximum
-//! moves each value to the first examples rather than its own, which this
-//! matches (T2.9's tracker).
+//! of only the examples whose window holds a value) or its comparison, each
+//! value on its own example and an example whose window holds none
+//! without one. The reference's engine lines the values up by position
+//! instead (`pd.DataFrame`, then `pd.concat` with the examples), so an
+//! average's, a minimum's or a maximum's move to the first examples rather
+//! than their own; the core puts each on its own row (T2.9 fix 1, a
+//! registered difference decided under KO2-70).
 
 use sdm_contract::{CoreError, Detail, ErrorCode, ErrorKind, Scalar};
 use sdm_engine::labels::{self, Aggregation, Constant, Labels, RelOp, Target};
@@ -190,15 +190,25 @@ impl Lag {
                         constant,
                     },
                 };
-                // The values of the examples that have one, in order, each
-                // at the position of the first examples (see the module).
-                let values = match labels::label(&target)?.labels {
-                    Labels::Float(v) => {
-                        LagValues::Float(kept.iter().map(|&at| v.get(at).copied()).collect())
-                    }
-                    Labels::Bool(v) => {
-                        LagValues::Bool(kept.iter().map(|&at| v.get(at).copied()).collect())
-                    }
+                // Each value on its own example: the labels are those of the
+                // examples `mask` marks, in order (see the module).
+                let labelled = labels::label(&target)?;
+                let mut at_example = vec![None; examples];
+                for (slot, example) in (0..examples).filter(|&e| labelled.mask[e]).enumerate() {
+                    at_example[example] = Some(slot);
+                }
+                let own = |at: usize| at_example.get(at).copied().flatten();
+                let values = match labelled.labels {
+                    Labels::Float(v) => LagValues::Float(
+                        kept.iter()
+                            .map(|&at| own(at).and_then(|i| v.get(i).copied()))
+                            .collect(),
+                    ),
+                    Labels::Bool(v) => LagValues::Bool(
+                        kept.iter()
+                            .map(|&at| own(at).and_then(|i| v.get(i).copied()))
+                            .collect(),
+                    ),
                     Labels::Int(_) | Labels::Text(_) => {
                         return Err(CoreError::new(
                             ErrorKind::Internal,
@@ -264,11 +274,12 @@ mod tests {
         );
     }
 
-    /// An average has a value only where its window holds one, and the
-    /// values line up with the first examples (the reference's frame);
-    /// a comparison of it likewise.
+    /// An average has a value only where its window holds one, each on
+    /// its own example, the first example's none (the reference's frame
+    /// would move the second's value to it; T2.9 fix 1); a comparison of
+    /// it likewise.
     #[test]
-    fn an_average_s_values_line_up_with_the_first_examples() {
+    fn an_average_s_value_is_on_its_own_example() {
         let w = window(1, days(0), days(10), &[100 * DAY, 50 * DAY]).unwrap();
         let lag = |condition| Lag {
             steps: 1,
@@ -286,18 +297,59 @@ mod tests {
         };
         assert_eq!(
             lag(None).columns(&[0, 1]).unwrap()[0].values,
-            LagValues::Float(vec![Some(3.0), None])
+            LagValues::Float(vec![None, Some(3.0)])
         );
         assert_eq!(
             lag(Some((RelOp::Gt, Some(Constant::Int(1)))))
                 .columns(&[0, 1])
                 .unwrap()[0]
                 .values,
-            LagValues::Bool(vec![Some(true), None])
+            LagValues::Bool(vec![None, Some(true)])
+        );
+        assert_eq!(
+            lag(Some((RelOp::Eq, None))).columns(&[1, 0]).unwrap()[0].values,
+            LagValues::Bool(vec![Some(false), None])
+        );
+    }
+
+    /// Examples whose windows hold a value, none, then a value, over two
+    /// steps (T2.9 fix 1): a maximum's each on its own row, a gap where a
+    /// window is empty, for the context and the entities predicted for
+    /// alike; a sum's every row.
+    #[test]
+    fn a_maximum_s_values_keep_their_rows_across_gaps() {
+        let anchors = [100 * DAY, 100 * DAY, 100 * DAY];
+        let w = window(2, days(0), days(10), &anchors).unwrap();
+        // Example 0: rows at days 85 (5.0) and 95 (7.0); example 1: none;
+        // example 2: a row at day 88 (2.0) only.
+        let rows = || Rows {
+            batches: vec![0, 0, 2],
+            values: labels::Values::Float(vec![Some(5.0), Some(7.0), Some(2.0)]),
+            times: vec![Some(85 * DAY), Some(95 * DAY), Some(88 * DAY)],
+        };
+        let lag = |aggregation| Lag {
+            steps: 2,
+            aggregation,
+            start: days(0),
+            end: days(10),
+            condition: None,
+            shifted: w.shifted.clone(),
+            rows: rows(),
+        };
+        let max = lag(Aggregation::Max).columns(&[0, 1, 2]).unwrap();
+        // __kumo_arl0__ is (90, 100], __kumo_arl1__ (80, 90].
+        assert_eq!(max[0].values, LagValues::Float(vec![Some(7.0), None, None]));
+        assert_eq!(
+            max[1].values,
+            LagValues::Float(vec![Some(5.0), None, Some(2.0)])
         );
+        // The rows a request keeps, in their own order.
+        let kept = lag(Aggregation::Max).columns(&[2, 0]).unwrap();
+        assert_eq!(kept[1].values, LagValues::Float(vec![Some(2.0), Some(5.0)]));
+        let sum = lag(Aggregation::Sum).columns(&[0, 1, 2]).unwrap();
         assert_eq!(
-            lag(Some((RelOp::Eq, None))).columns(&[1]).unwrap()[0].values,
-            LagValues::Bool(vec![None])
+            sum[1].values,
+            LagValues::Float(vec![Some(5.0), Some(0.0), Some(2.0)])
         );
     }