@@ -214,3 +214,29 @@ test('merge cost does not grow with a run capture count', () => {
     platform: 'ios',
   });
 });
+
+test('merging summaries whose p95 equals max keeps p50 <= p95 <= max', () => {
+  const slowTail = { count: 4, p50Ms: 200, p95Ms: 1_000, maxMs: 1_000, slowThresholdMs: 1_500 };
+  const merged = mergeSnapshotDiagnostics([{ stats: slowTail }, { stats: VALID_STATS }])?.stats;
+  expect(merged).toMatchObject({ count: 8, p50Ms: 200, p95Ms: 1_000, maxMs: 1_000 });
+  expect(readSnapshotDiagnosticsSummary({ stats: merged })?.stats).toEqual(merged);
+});
+
+test('every merge of valid summaries is itself a valid summary', () => {
+  let seed = 7;
+  const next = () => (seed = (seed * 1_103_515_245 + 12_345) & 0x7fffffff) / 0x7fffffff;
+  for (let round = 0; round < 500; round += 1) {
+    const runs = Array.from({ length: 1 + Math.floor(next() * 4) }, () => {
+      const [p50Ms, p95Ms, maxMs] = [next(), next(), next()]
+        .map((value) => Math.floor(value * 2_000))
+        .sort((left, right) => left - right) as [number, number, number];
+      const count = 1 + Math.floor(next() * 9);
+      return {
+        stats: { count, p50Ms, p95Ms: next() < 0.3 ? maxMs : p95Ms, maxMs, slowThresholdMs: 1_500 },
+      };
+    });
+    const merged = mergeSnapshotDiagnostics(runs)?.stats;
+    expect(merged && merged.p50Ms <= merged.p95Ms && merged.p95Ms <= merged.maxMs).toBe(true);
+    expect(merged?.count).toBe(runs.reduce((sum, run) => sum + run.stats.count, 0));
+  }
+});
@@ -274,7 +274,9 @@ type WeightedTimingSample = { durationMs: number; weight: number; platform?: Pub
 
 /**
  * One run's summary as at most three weighted points: its p50 stands for every capture below its
- * p95. The weights sum to `count`, so the merge costs O(runs) whatever each run's capture count.
+ * p95. This is the same multiset the earlier per-sample reconstruction built (count - 2 copies of
+ * p50, then p95 and max), so merged percentiles are unchanged; the weights sum to `count`, so the
+ * merge costs O(runs) whatever each run's capture count.
  */
 function weightedSamplesFromStats(stats: SnapshotTimingStats): WeightedTimingSample[] {
   const { count, platform } = stats;
 
@@ -352,3 +352,43 @@ test('an admitted ref operation whose interactor lacks the member is a runtime c
     });
   }
 });
+
+test('hover follows the touch rule: unadvertised is not bound, advertised without a member is a contract error', async () => {
+  // Without facts for hover, neither leg is bound: the command layer refuses from the fact
+  // (UNSUPPORTED_OPERATION with the longpress hint), and no interactor is consulted.
+  const unadvertised = bindLocalTouchInteractor({
+    device,
+    signal: new AbortController().signal,
+    resolveInteractor: async () => ({}) as unknown as Interactor,
+    facts,
+    pause: async () => {},
+  });
+  expect(unadvertised.hoverPoint).toBeUndefined();
+  expect(unadvertised.hoverRef).toBeUndefined();
+
+  const advertised = bindLocalTouchInteractor({
+    device,
+    signal: new AbortController().signal,
+    resolveInteractor: async () => ({}) as unknown as Interactor,
+    facts: touchRuntimeOperationFacts({
+      unsupported: unavailable,
+      tap: available,
+      tapRef: available,
+      longPress: available,
+      fill: available,
+      fillRef: available,
+      hover: available,
+      hoverRef: available,
+    }),
+    pause: async () => {},
+  });
+  for (const run of [
+    () => advertised.hoverPoint!({ point: { x: 1, y: 2 }, execution: { requestId: 'hover' } }),
+    () => advertised.hoverRef!({ ref: '@e4', execution: { requestId: 'hover-ref' } }),
+  ]) {
+    await expect(run()).rejects.toMatchObject({
+      code: 'COMMAND_FAILED',
+      details: { reason: 'runtime-contract-invalid' },
+    });
+  }
+});
@@ -96,6 +96,16 @@ test('rotation caps events.ndjson while cursors stay absolute across the retaine
     ['event 38'],
   );
   assert.equal(tail.nextCursor, '39');
+  // endCursor is absolute like nextCursor, whichever retained file the scan stopped in.
+  assert.equal(tail.endCursor, '39');
+  assert.equal(
+    readSessionEventLog(eventLogPath, { cursor: String(earliest), limit: 2 }).endCursor,
+    String(earliest + 2),
+  );
+  assert.equal(
+    readSessionEventLog(eventLogPath, { cursor: String(earliest), limit: 500 }).endCursor,
+    '40',
+  );
   assert.deepEqual(summaries(eventLogPath, tail.nextCursor, 1), ['event 39']);
 
   const expired = readError(eventLogPath, '0');