diff --git a/.github/workflows/ios.yml b/.github/workflows/ios.yml
index 25cbf5644..851fd81b6 100644
--- a/.github/workflows/ios.yml
+++ b/.github/workflows/ios.yml
@@ -31,6 +31,7 @@ jobs:
       AGENT_DEVICE_STATE_DIR: ${{ github.workspace }}/.tmp/agent-device-state
       AGENT_DEVICE_IOS_RUNNER_DERIVED_PATH: ${{ github.workspace }}/.tmp/ios-runner-derived
       AGENT_DEVICE_IOS_PREPARE_TIMEOUT_MS: '420000'
+      AGENT_DEVICE_XCUITEST_INCLUDE_UNIT_TESTS: '1'
     steps:
       - name: Checkout
         uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
@@ -56,6 +57,17 @@ jobs:
           runtime-version: ${{ env.IOS_RUNTIME_VERSION }}
           preferred-device-name: iPhone 17 Pro
 
+      - name: Run iOS runner gesture and lifecycle regressions
+        run: |
+          XCTESTRUN_PATH="$(find "$AGENT_DEVICE_IOS_RUNNER_DERIVED_PATH/Build/Products" -maxdepth 1 -name '*.xctestrun' -print -quit)"
+          test -n "$XCTESTRUN_PATH"
+          xcodebuild test-without-building \
+            -xctestrun "$XCTESTRUN_PATH" \
+            -destination "platform=iOS Simulator,id=${{ steps.ios-simulator.outputs.simulator-udid }}" \
+            -only-testing:AgentDeviceRunnerUITests/RunnerTests/testSinglePointerFlingFallsBackToXCTestCoordinateDragWhenPrivateSynthesisFails \
+            -only-testing:AgentDeviceRunnerUITests/RunnerTests/testMissingBundleCommandInvalidatesCompleteCachedTargetState \
+            -only-testing:AgentDeviceRunnerUITests/RunnerTests/testCachedTargetInvalidationClearsProcessBoundState
+
       - name: Prepare iOS runner
         run: |
           pnpm clean:daemon
diff --git a/AGENTS.md b/AGENTS.md
index 9ad1a517a..c568cd260 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -61,6 +61,7 @@ Single-context repo. Read `CONTEXT.md` for domain language and testing/architect
   - prefer deep modules over mechanical splits: extract when it improves locality for a concept callers already need, not just to reduce line count.
 - Before finalizing a code change, do one tightening pass over touched and directly adjacent areas: drop obsolete code, redundant tests, stale helpers/fixtures, and needless duplication made unnecessary by the change.
 - Prefer existing helpers. Add a helper only when it reduces real repetition or clarifies domain behavior.
+- Prefer composition at platform boundaries: public aliases normalize into shared primitives, and providers contribute transport/device bindings instead of cloning interaction runtimes.
 - When adding new guidance, examples, schemas, or command metadata, decide whether it belongs in the command surface, CLI grammar, CLI help, MCP projection, or daemon runtime before editing.
 - Prefer updating existing domain vocabulary in `CONTEXT.md` when naming a new durable module concept. Do not coin parallel names in docs, tests, and code.
 
diff --git a/CONTEXT.md b/CONTEXT.md
index a06cf80d8..b6a47f6e2 100644
--- a/CONTEXT.md
+++ b/CONTEXT.md
@@ -47,6 +47,8 @@
 - Runner command traits: per-command-type classification for iOS/macOS runner lifecycle behavior, distinct from the public command surface and daemon command registry. The Swift runner traits classify interaction, read-only, and runner-lifecycle axes for XCTest execution; Swift resolves the alert command as read-only only for its `get` action. The TypeScript runner command traits classify daemon-side runner send/recovery policy such as read-only retry routing, readiness probes, and recent-healthy-mutation preflight skips; the TypeScript table is command-type keyed and currently classifies alert as read-only for daemon retry policy. Each side keeps one source of truth keyed by runner command type.
 - Coordinate-first resolved element activation: iOS/macOS runner interaction pattern where a selector or text query resolves the semantic `XCUIElement`, then activation uses the element's resolved center coordinate when a frame is available. This keeps target selection semantic while avoiding `XCUIElement.tap()` post-action element re-resolution after normal navigation. tvOS remains focus/remote-driven.
 - Interaction dispatch path: one concrete route an interaction command takes to the device (runtime selector/ref resolution, direct iOS selector, native ref via web clickRef, coordinate, maestro non-hittable fallback). Every path classifies every guarantee in the ADR 0011 registry.
+- Gesture plan: typed, platform-neutral normalization of one- or two-contact gesture intent into bounded pointer trajectories. Contact topology is separate from motion; two-contact intent remains pan/pinch/rotate/transform even when native injection shares one executor. See ADR 0013.
+- Multi-touch geometry: the internal initial span and angle plus centroid translation, scale, and rotation used to build both contact trajectories. Geometry is viewport-aware and fails early when the requested motion cannot fit; it is not a public tuning surface.
 - Guarantee cell: one (dispatch path, guarantee) entry in `src/contracts/interaction-guarantees.ts`, classified as runtime/runner/delegated/inapplicable/waived. Completeness is a compile error; honesty is gate-tested.
 - Owned waiver: a `gap:`-prefixed waived cell carrying a `trackingIssue` URL. Waivers are diffable debt with an owner, never folklore.
 - Parity table: golden JSON fixture under `contracts/fixtures/` consumed by both vitest and the runner's gated Swift tests, so a cross-language rule (e.g. tap-point policy) cannot drift silently. Change the rule only via the table.
diff --git a/android-multitouch-helper/README.md b/android-multitouch-helper/README.md
index 320c52ad7..e5266fcca 100644
--- a/android-multitouch-helper/README.md
+++ b/android-multitouch-helper/README.md
@@ -18,7 +18,16 @@ sh ./scripts/build-android-multitouch-helper.sh "$VERSION" .tmp/android-multitou
 ## Run
 
 ```sh
-PAYLOAD="$(printf '%s' '{"kind":"transform","x":672,"y":1500,"dx":80,"dy":-40,"scale":1.8,"degrees":35,"durationMs":700}' | base64)"
+PAYLOAD_JSON='{
+  "protocol":"android-multitouch-helper-v1",
+  "kind":"transform",
+  "durationMs":32,
+  "pointers":[
+    {"pointerId":0,"samples":[{"offsetMs":0,"x":120,"y":180},{"offsetMs":16,"x":130,"y":175},{"offsetMs":32,"x":140,"y":170}]},
+    {"pointerId":1,"samples":[{"offsetMs":0,"x":120,"y":260},{"offsetMs":16,"x":135,"y":270},{"offsetMs":32,"x":150,"y":280}]}
+  ]
+}'
+PAYLOAD="$(printf '%s' "$PAYLOAD_JSON" | base64)"
 adb install -r -t ".tmp/android-multitouch-helper/agent-device-android-multitouch-helper-$VERSION.apk"
 adb shell am instrument -w \
   -e payloadBase64 "$PAYLOAD" \
@@ -30,12 +39,19 @@ adb shell am instrument -w \
 The APK emits instrumentation result records using
 `agentDeviceProtocol=android-multitouch-helper-v1`.
 
+Before planning a gesture, the runtime invokes the same instrumentation with
+`-e mode viewport`. That read-only mode waits for `UiAutomation` window state and returns the
+active application window bounds, falling back to the active accessibility root when Android does
+not expose interactive-window metadata. It does not use or cache the physical display size.
+
 Successful results include:
 
 - `ok=true`
 - `helperApiVersion=1`
-- `kind` (`swipe`, `pinch`, `rotate`, or `transform`)
+- `kind` (`swipe` for one planned pointer path or `transform` for two)
 - `injectedEvents`
 - `elapsedMs`
 
+Viewport results use `kind=viewport` plus `x`, `y`, `width`, and `height`.
+
 Failures return `ok=false`, `errorType`, and `message`.
diff --git a/android-multitouch-helper/src/main/java/com/callstack/agentdevice/multitouchhelper/MultiTouchInstrumentation.java b/android-multitouch-helper/src/main/java/com/callstack/agentdevice/multitouchhelper/MultiTouchInstrumentation.java
index f6952d318..234f6c3aa 100644
--- a/android-multitouch-helper/src/main/java/com/callstack/agentdevice/multitouchhelper/MultiTouchInstrumentation.java
+++ b/android-multitouch-helper/src/main/java/com/callstack/agentdevice/multitouchhelper/MultiTouchInstrumentation.java
@@ -7,18 +7,20 @@
 import android.util.Base64;
 import android.view.InputDevice;
 import android.view.MotionEvent;
+import android.view.accessibility.AccessibilityNodeInfo;
+import android.view.accessibility.AccessibilityWindowInfo;
+import android.graphics.Rect;
 import java.nio.charset.StandardCharsets;
+import java.util.List;
+import java.util.concurrent.TimeoutException;
+import org.json.JSONArray;
 import org.json.JSONObject;
 
 public final class MultiTouchInstrumentation extends Instrumentation {
   private static final String PROTOCOL = "android-multitouch-helper-v1";
   private static final String HELPER_API_VERSION = "1";
-  private static final int DEFAULT_RADIUS = 160;
-  private static final int MIN_RADIUS = 24;
-  private static final int MAX_RADIUS = 1200;
   private static final int MIN_DURATION_MS = 16;
   private static final int MAX_DURATION_MS = 10_000;
-  private static final int MOVE_FRAME_INTERVAL_MS = 16;
   private Bundle arguments;
 
   @Override
@@ -36,10 +38,21 @@ public void onStart() {
     result.putString("helperApiVersion", HELPER_API_VERSION);
     try {
       long startedAtMs = System.currentTimeMillis();
-      GestureSpec spec = readSpec(arguments);
-      int injectedEvents = injectGesture(spec);
+      if ("viewport".equals(arguments.getString("mode", "gesture"))) {
+        Rect viewport = readActiveApplicationViewport();
+        result.putString("ok", "true");
+        result.putString("kind", "viewport");
+        result.putString("x", Integer.toString(viewport.left));
+        result.putString("y", Integer.toString(viewport.top));
+        result.putString("width", Integer.toString(viewport.width()));
+        result.putString("height", Integer.toString(viewport.height()));
+        finish(0, result);
+        return;
+      }
+      GesturePlan plan = readPlan(arguments);
+      int injectedEvents = injectPlan(plan);
       result.putString("ok", "true");
-      result.putString("kind", spec.kind);
+      result.putString("kind", plan.kind);
       result.putString("injectedEvents", Integer.toString(injectedEvents));
       result.putString("elapsedMs", Long.toString(System.currentTimeMillis() - startedAtMs));
       finish(0, result);
@@ -53,11 +66,46 @@ public void onStart() {
     }
   }
 
-  private GestureSpec readSpec(Bundle arguments) throws Exception {
-    String payloadBase64 = arguments.getString("payloadBase64", "");
-    if (payloadBase64.isEmpty()) {
-      throw new IllegalArgumentException("Missing payloadBase64");
+  @SuppressWarnings("deprecation")
+  private Rect readActiveApplicationViewport() {
+    UiAutomation automation = getUiAutomation();
+    try {
+      automation.waitForIdle(100, 2_000);
+    } catch (TimeoutException ignored) {
+      // Window/root state can still be usable when the app is animating continuously.
+    }
+    List<AccessibilityWindowInfo> windows = automation.getWindows();
+    AccessibilityWindowInfo fallback = null;
+    for (AccessibilityWindowInfo window : windows) {
+      if (window.getType() != AccessibilityWindowInfo.TYPE_APPLICATION) continue;
+      if (window.isActive() || window.isFocused()) {
+        Rect bounds = new Rect();
+        window.getBoundsInScreen(bounds);
+        if (!bounds.isEmpty()) return bounds;
+      }
+      if (fallback == null) fallback = window;
+    }
+    AccessibilityNodeInfo activeRoot = automation.getRootInActiveWindow();
+    if (activeRoot != null) {
+      try {
+        Rect bounds = new Rect();
+        activeRoot.getBoundsInScreen(bounds);
+        if (!bounds.isEmpty()) return bounds;
+      } finally {
+        activeRoot.recycle();
+      }
+    }
+    if (fallback != null) {
+      Rect bounds = new Rect();
+      fallback.getBoundsInScreen(bounds);
+      if (!bounds.isEmpty()) return bounds;
     }
+    throw new IllegalStateException("Active application interaction viewport is unavailable");
+  }
+
+  private GesturePlan readPlan(Bundle arguments) throws Exception {
+    String payloadBase64 = arguments.getString("payloadBase64", "");
+    if (payloadBase64.isEmpty()) throw new IllegalArgumentException("Missing payloadBase64");
     String json =
         new String(Base64.decode(payloadBase64, Base64.DEFAULT), StandardCharsets.UTF_8);
     JSONObject payload = new JSONObject(json);
@@ -66,148 +114,136 @@ private GestureSpec readSpec(Bundle arguments) throws Exception {
       throw new IllegalArgumentException("Unsupported protocol: " + protocol);
     }
     String kind = payload.getString("kind");
-    if (!"swipe".equals(kind)
-        && !"pinch".equals(kind)
-        && !"rotate".equals(kind)
-        && !"transform".equals(kind)) {
+    if (!"swipe".equals(kind) && !"transform".equals(kind)) {
       throw new IllegalArgumentException("Unsupported kind: " + kind);
     }
-    int x = "swipe".equals(kind) ? payload.getInt("x1") : payload.getInt("x");
-    int y = "swipe".equals(kind) ? payload.getInt("y1") : payload.getInt("y");
-    int dx = payload.optInt("dx", 0);
-    int dy = payload.optInt("dy", 0);
-    int x2 = payload.optInt("x2", x + dx);
-    int y2 = payload.optInt("y2", y + dy);
-    int durationMs = clamp(payload.optInt("durationMs", 300), MIN_DURATION_MS, MAX_DURATION_MS);
-    int radius = clamp(payload.optInt("radius", DEFAULT_RADIUS), MIN_RADIUS, MAX_RADIUS);
-    double scale = payload.optDouble("scale", 1.0d);
-    double degrees = payload.optDouble("degrees", 0.0d);
-    if (("pinch".equals(kind) || "transform".equals(kind)) && (!isFinite(scale) || scale <= 0)) {
-      throw new IllegalArgumentException("Scale must be > 0");
-    }
-    if (("rotate".equals(kind) || "transform".equals(kind)) && !isFinite(degrees)) {
-      throw new IllegalArgumentException("Degrees must be finite");
-    }
-    return new GestureSpec(kind, x, y, dx, dy, x2, y2, durationMs, scale, degrees, radius);
+    int durationMs = requireDuration(payload.getInt("durationMs"));
+    PointerPath[] pointers = readPointers(payload.getJSONArray("pointers"), kind, durationMs);
+    return new GesturePlan(kind, durationMs, pointers);
   }
 
-  private int injectGesture(GestureSpec spec) {
-    if ("swipe".equals(spec.kind)) {
-      return injectSinglePointerGesture(spec);
-    }
+  private int injectPlan(GesturePlan plan) {
     UiAutomation automation = getUiAutomation();
     long downTime = SystemClock.uptimeMillis();
     long eventTime = downTime;
-    PointerPair start = pointerPairAt(spec, 0);
-    PointerPair end = pointerPairAt(spec, 1);
-    PointerPair activePointers = start.firstOnly();
+    PointerState active = pointerStateAt(plan, 0).firstOnly();
     int count = 0;
-
     try {
-      injectScheduledEvent(
-          automation,
-          motionEvent(downTime, eventTime, MotionEvent.ACTION_DOWN, activePointers),
-          true);
-      count += 1;
-      eventTime += 8;
-      injectScheduledEvent(
-          automation,
-          motionEvent(
-              downTime,
-              eventTime,
-              MotionEvent.ACTION_POINTER_DOWN | (1 << MotionEvent.ACTION_POINTER_INDEX_SHIFT),
-              start),
-          true);
-      count += 1;
-      activePointers = start;
-
-      int frameCount =
-          Math.max(3, Math.round(spec.durationMs / (float) MOVE_FRAME_INTERVAL_MS));
-      for (int index = 1; index < frameCount; index += 1) {
-        double t = (double) index / (double) frameCount;
-        PointerPair frame = pointerPairAt(spec, t);
-        eventTime = downTime + Math.round(spec.durationMs * t);
-        injectScheduledEvent(
+      for (PointerEventSchedule.Step step :
+          PointerEventSchedule.create(plan.pointers.length, sampleOffsets(plan))) {
+        active = pointerStateAt(plan, step.sampleIndex);
+        if (step.pointerCount == 1) active = active.firstOnly();
+        eventTime = downTime + step.offsetMs;
+        inject(
             automation,
-            motionEvent(downTime, eventTime, MotionEvent.ACTION_MOVE, frame),
-            false);
+            motionEvent(downTime, eventTime, motionEventAction(step.action), active),
+            step.action != PointerEventSchedule.Action.MOVE);
         count += 1;
-        activePointers = frame;
       }
-
-      eventTime = downTime + spec.durationMs;
-      injectScheduledEvent(
-          automation,
-          motionEvent(
-              downTime,
-              eventTime,
-              MotionEvent.ACTION_POINTER_UP | (1 << MotionEvent.ACTION_POINTER_INDEX_SHIFT),
-              end),
-          true);
-      count += 1;
-      activePointers = end.firstOnly();
-      injectScheduledEvent(
-          automation,
-          motionEvent(downTime, eventTime + 8, MotionEvent.ACTION_UP, activePointers),
-          true);
-      count += 1;
       return count;
     } catch (RuntimeException error) {
-      if (count > 0) {
-        injectCancel(automation, downTime, eventTime + 16, activePointers);
-      }
+      if (count > 0) injectCancel(automation, downTime, eventTime + 16, active);
       throw error;
     }
   }
 
-  private int injectSinglePointerGesture(GestureSpec spec) {
-    UiAutomation automation = getUiAutomation();
-    long downTime = SystemClock.uptimeMillis();
-    long eventTime = downTime;
-    PointerPair activePointer = pointerPairAt(spec, 0);
-    int count = 0;
+  private static long[] sampleOffsets(GesturePlan plan) {
+    PointerSample[] samples = plan.pointers[0].samples;
+    long[] offsets = new long[samples.length];
+    for (int index = 0; index < samples.length; index += 1) {
+      offsets[index] = samples[index].offsetMs;
+    }
+    return offsets;
+  }
 
-    try {
-      injectScheduledEvent(
-          automation,
-          motionEvent(downTime, eventTime, MotionEvent.ACTION_DOWN, activePointer),
-          true);
-      count += 1;
+  private static int motionEventAction(PointerEventSchedule.Action action) {
+    switch (action) {
+      case DOWN:
+        return MotionEvent.ACTION_DOWN;
+      case POINTER_DOWN:
+        return MotionEvent.ACTION_POINTER_DOWN | (1 << MotionEvent.ACTION_POINTER_INDEX_SHIFT);
+      case MOVE:
+        return MotionEvent.ACTION_MOVE;
+      case POINTER_UP:
+        return MotionEvent.ACTION_POINTER_UP | (1 << MotionEvent.ACTION_POINTER_INDEX_SHIFT);
+      case UP:
+        return MotionEvent.ACTION_UP;
+      default:
+        throw new IllegalArgumentException("Unsupported pointer event action: " + action);
+    }
+  }
 
-      int frameCount =
-          Math.max(3, Math.round(spec.durationMs / (float) MOVE_FRAME_INTERVAL_MS));
-      for (int index = 1; index < frameCount; index += 1) {
-        double t = (double) index / (double) frameCount;
-        PointerPair frame = pointerPairAt(spec, t);
-        eventTime = downTime + Math.round(spec.durationMs * t);
-        injectScheduledEvent(
-            automation,
-            motionEvent(downTime, eventTime, MotionEvent.ACTION_MOVE, frame),
-            false);
-        count += 1;
-        activePointer = frame;
+  private static PointerPath[] readPointers(JSONArray pointers, String kind, int durationMs)
+      throws Exception {
+    int expectedCount = "swipe".equals(kind) ? 1 : 2;
+    if (pointers.length() != expectedCount) {
+      throw new IllegalArgumentException(
+          "Planned " + kind + " gesture requires exactly " + expectedCount + " pointer paths");
+    }
+    PointerPath[] result = new PointerPath[expectedCount];
+    for (int pointerIndex = 0; pointerIndex < expectedCount; pointerIndex += 1) {
+      JSONObject pointer = pointers.getJSONObject(pointerIndex);
+      if (pointer.getInt("pointerId") != pointerIndex) {
+        throw new IllegalArgumentException("Planned pointer ids must be ordered from 0");
       }
+      JSONArray samples = pointer.getJSONArray("samples");
+      if (samples.length() < 2) {
+        throw new IllegalArgumentException("Planned pointer path requires at least two samples");
+      }
+      PointerSample[] parsed = new PointerSample[samples.length()];
+      long previousOffsetMs = -1;
+      for (int sampleIndex = 0; sampleIndex < samples.length(); sampleIndex += 1) {
+        JSONObject sample = samples.getJSONObject(sampleIndex);
+        double rawOffsetMs = sample.getDouble("offsetMs");
+        double x = sample.getDouble("x");
+        double y = sample.getDouble("y");
+        if (!finite(rawOffsetMs) || rawOffsetMs != Math.rint(rawOffsetMs)) {
+          throw new IllegalArgumentException("Planned sample offsetMs must be a finite integer");
+        }
+        if (!finite(x) || !finite(y)) {
+          throw new IllegalArgumentException("Planned sample coordinates must be finite");
+        }
+        long offsetMs = (long) rawOffsetMs;
+        if (offsetMs <= previousOffsetMs) {
+          throw new IllegalArgumentException("Planned sample offsets must be strictly increasing");
+        }
+        parsed[sampleIndex] = new PointerSample(offsetMs, (float) x, (float) y);
+        previousOffsetMs = offsetMs;
+      }
+      if (parsed[0].offsetMs != 0 || parsed[parsed.length - 1].offsetMs != durationMs) {
+        throw new IllegalArgumentException("Pointer path must start at 0 and end at durationMs");
+      }
+      result[pointerIndex] = new PointerPath(parsed);
+    }
+    if (expectedCount == 2) assertMatchingSamples(result[0], result[1]);
+    return result;
+  }
 
-      eventTime = downTime + spec.durationMs;
-      activePointer = pointerPairAt(spec, 1);
-      injectScheduledEvent(
-          automation,
-          motionEvent(downTime, eventTime, MotionEvent.ACTION_UP, activePointer),
-          true);
-      count += 1;
-      return count;
-    } catch (RuntimeException error) {
-      if (count > 0) {
-        injectCancel(automation, downTime, eventTime + 16, activePointer);
+  private static void assertMatchingSamples(PointerPath first, PointerPath second) {
+    if (first.samples.length != second.samples.length) {
+      throw new IllegalArgumentException("Planned pointer paths must have matching samples");
+    }
+    for (int index = 0; index < first.samples.length; index += 1) {
+      if (first.samples[index].offsetMs != second.samples[index].offsetMs) {
+        throw new IllegalArgumentException("Planned pointer sample offsets must match");
       }
-      throw error;
     }
   }
 
-  private static void injectScheduledEvent(
-      UiAutomation automation, MotionEvent event, boolean waitForDispatch) {
+  private static PointerState pointerStateAt(GesturePlan plan, int sampleIndex) {
+    int pointerCount = plan.pointers.length;
+    float[] x = new float[pointerCount];
+    float[] y = new float[pointerCount];
+    for (int index = 0; index < pointerCount; index += 1) {
+      PointerSample sample = plan.pointers[index].samples[sampleIndex];
+      x[index] = sample.x;
+      y[index] = sample.y;
+    }
+    return new PointerState(x, y);
+  }
+
+  private static void inject(UiAutomation automation, MotionEvent event, boolean waitForDispatch) {
     try {
-      // Event timestamps alone do not pace UiAutomation injection; recognizers need real time.
       sleepUntil(event.getEventTime());
       if (!automation.injectInputEvent(event, waitForDispatch)) {
         throw new IllegalStateException("injectInputEvent returned false");
@@ -219,34 +255,33 @@ private static void injectScheduledEvent(
 
   private static void sleepUntil(long targetUptimeMs) {
     long delayMs = targetUptimeMs - SystemClock.uptimeMillis();
-    if (delayMs > 0) {
-      SystemClock.sleep(delayMs);
-    }
+    if (delayMs > 0) SystemClock.sleep(delayMs);
   }
 
   private static void injectCancel(
-      UiAutomation automation, long downTime, long eventTime, PointerPair pair) {
+      UiAutomation automation, long downTime, long eventTime, PointerState pointers) {
     try {
-      injectScheduledEvent(
+      inject(
           automation,
-          motionEvent(downTime, eventTime, MotionEvent.ACTION_CANCEL, pair),
+          motionEvent(downTime, eventTime, MotionEvent.ACTION_CANCEL, pointers),
           true);
     } catch (RuntimeException ignored) {
-      // Best-effort cleanup; preserve the original injection failure.
+      // Preserve the original injection failure.
     }
   }
 
-  private static MotionEvent motionEvent(long downTime, long eventTime, int action, PointerPair pair) {
+  private static MotionEvent motionEvent(
+      long downTime, long eventTime, int action, PointerState pointers) {
     MotionEvent.PointerProperties[] properties =
-        new MotionEvent.PointerProperties[pair.pointerCount];
-    MotionEvent.PointerCoords[] coords = new MotionEvent.PointerCoords[pair.pointerCount];
-    for (int index = 0; index < pair.pointerCount; index += 1) {
+        new MotionEvent.PointerProperties[pointers.count];
+    MotionEvent.PointerCoords[] coords = new MotionEvent.PointerCoords[pointers.count];
+    for (int index = 0; index < pointers.count; index += 1) {
       properties[index] = new MotionEvent.PointerProperties();
       properties[index].id = index;
       properties[index].toolType = MotionEvent.TOOL_TYPE_FINGER;
       coords[index] = new MotionEvent.PointerCoords();
-      coords[index].x = pair.x[index];
-      coords[index].y = pair.y[index];
+      coords[index].x = pointers.x[index];
+      coords[index].y = pointers.y[index];
       coords[index].pressure = 1.0f;
       coords[index].size = 1.0f;
     }
@@ -255,7 +290,7 @@ private static MotionEvent motionEvent(long downTime, long eventTime, int action
             downTime,
             eventTime,
             action,
-            pair.pointerCount,
+            pointers.count,
             properties,
             coords,
             0,
@@ -270,112 +305,62 @@ private static MotionEvent motionEvent(long downTime, long eventTime, int action
     return event;
   }
 
-  private static PointerPair pointerPairAt(GestureSpec spec, double t) {
-    if ("swipe".equals(spec.kind)) {
-      return new PointerPair(
-          new float[] {(float) (spec.x + (spec.x2 - spec.x) * t)},
-          new float[] {(float) (spec.y + (spec.y2 - spec.y) * t)});
+  private static int requireDuration(int value) {
+    if (value < MIN_DURATION_MS || value > MAX_DURATION_MS) {
+      throw new IllegalArgumentException("durationMs must be between 16 and 10000");
     }
-    if ("pinch".equals(spec.kind)) {
-      double startRadius = spec.radius / Math.max(spec.scale, 1.0d);
-      double endRadius = spec.radius;
-      if (spec.scale < 1.0d) {
-        startRadius = spec.radius;
-        endRadius = spec.radius * spec.scale;
-      }
-      double radius = startRadius + (endRadius - startRadius) * t;
-      return new PointerPair(
-          new float[] {(float) (spec.x - radius), (float) (spec.x + radius)},
-          new float[] {(float) spec.y, (float) spec.y});
-    }
-    double centerX = spec.x;
-    double centerY = spec.y;
-    double radius = spec.radius;
-    if ("transform".equals(spec.kind)) {
-      centerX = spec.x + spec.dx * t;
-      centerY = spec.y + spec.dy * t;
-      double startRadius = spec.radius / Math.max(spec.scale, 1.0d);
-      double endRadius = spec.radius;
-      if (spec.scale < 1.0d) {
-        startRadius = spec.radius;
-        endRadius = spec.radius * spec.scale;
-      }
-      radius = startRadius + (endRadius - startRadius) * t;
-    }
-    double angle = Math.toRadians(-90 + spec.degrees * t);
-    return new PointerPair(
-        new float[] {
-          (float) (centerX + Math.cos(angle) * radius),
-          (float) (centerX - Math.cos(angle) * radius)
-        },
-        new float[] {
-          (float) (centerY + Math.sin(angle) * radius),
-          (float) (centerY - Math.sin(angle) * radius)
-        });
-  }
-
-  private static int clamp(int value, int min, int max) {
-    return Math.min(Math.max(value, min), max);
+    return value;
   }
 
-  private static boolean isFinite(double value) {
+  private static boolean finite(double value) {
     return !Double.isNaN(value) && !Double.isInfinite(value);
   }
 
-  private static final class GestureSpec {
+  private static final class GesturePlan {
     final String kind;
-    final int x;
-    final int y;
-    final int dx;
-    final int dy;
-    final int x2;
-    final int y2;
     final int durationMs;
-    final double scale;
-    final double degrees;
-    final int radius;
+    final PointerPath[] pointers;
 
-    GestureSpec(
-        String kind,
-        int x,
-        int y,
-        int dx,
-        int dy,
-        int x2,
-        int y2,
-        int durationMs,
-        double scale,
-        double degrees,
-        int radius) {
+    GesturePlan(String kind, int durationMs, PointerPath[] pointers) {
       this.kind = kind;
+      this.durationMs = durationMs;
+      this.pointers = pointers;
+    }
+  }
+
+  private static final class PointerPath {
+    final PointerSample[] samples;
+
+    PointerPath(PointerSample[] samples) {
+      this.samples = samples;
+    }
+  }
+
+  private static final class PointerSample {
+    final long offsetMs;
+    final float x;
+    final float y;
+
+    PointerSample(long offsetMs, float x, float y) {
+      this.offsetMs = offsetMs;
       this.x = x;
       this.y = y;
-      this.dx = dx;
-      this.dy = dy;
-      this.x2 = x2;
-      this.y2 = y2;
-      this.durationMs = durationMs;
-      this.scale = scale;
-      this.degrees = degrees;
-      this.radius = radius;
     }
   }
 
-  private static final class PointerPair {
-    final int pointerCount;
+  private static final class PointerState {
+    final int count;
     final float[] x;
     final float[] y;
 
-    PointerPair(float[] x, float[] y) {
-      this.pointerCount = x.length;
+    PointerState(float[] x, float[] y) {
+      this.count = x.length;
       this.x = x;
       this.y = y;
     }
 
-    PointerPair firstOnly() {
-      return new PointerPair(
-          new float[] {x[0]},
-          new float[] {y[0]});
+    PointerState firstOnly() {
+      return new PointerState(new float[] {x[0]}, new float[] {y[0]});
     }
   }
 }
diff --git a/android-multitouch-helper/src/main/java/com/callstack/agentdevice/multitouchhelper/PointerEventSchedule.java b/android-multitouch-helper/src/main/java/com/callstack/agentdevice/multitouchhelper/PointerEventSchedule.java
new file mode 100644
index 000000000..04ea478f7
--- /dev/null
+++ b/android-multitouch-helper/src/main/java/com/callstack/agentdevice/multitouchhelper/PointerEventSchedule.java
@@ -0,0 +1,62 @@
+package com.callstack.agentdevice.multitouchhelper;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/** Defines the platform-independent event order consumed by Android touch injection. */
+final class PointerEventSchedule {
+  private static final long POINTER_LIFT_DELAY_MS = 8;
+
+  enum Action {
+    DOWN,
+    POINTER_DOWN,
+    MOVE,
+    POINTER_UP,
+    UP
+  }
+
+  static final class Step {
+    final Action action;
+    final int sampleIndex;
+    final int pointerCount;
+    final long offsetMs;
+
+    Step(Action action, int sampleIndex, int pointerCount, long offsetMs) {
+      this.action = action;
+      this.sampleIndex = sampleIndex;
+      this.pointerCount = pointerCount;
+      this.offsetMs = offsetMs;
+    }
+  }
+
+  private PointerEventSchedule() {}
+
+  static List<Step> create(int pointerCount, long[] sampleOffsetsMs) {
+    if (pointerCount != 1 && pointerCount != 2) {
+      throw new IllegalArgumentException("Pointer event schedule requires one or two pointers");
+    }
+    if (sampleOffsetsMs.length < 2) {
+      throw new IllegalArgumentException("Pointer event schedule requires at least two samples");
+    }
+
+    int lastIndex = sampleOffsetsMs.length - 1;
+    List<Step> steps = new ArrayList<>(sampleOffsetsMs.length + (pointerCount == 1 ? 1 : 3));
+    steps.add(new Step(Action.DOWN, 0, 1, 0));
+    if (pointerCount == 2) {
+      long pointerDownOffset = Math.max(1, Math.min(8, sampleOffsetsMs[1] - 1));
+      steps.add(new Step(Action.POINTER_DOWN, 0, 2, pointerDownOffset));
+    }
+    for (int sampleIndex = 1; sampleIndex <= lastIndex; sampleIndex += 1) {
+      steps.add(
+          new Step(Action.MOVE, sampleIndex, pointerCount, sampleOffsetsMs[sampleIndex]));
+    }
+    if (pointerCount == 2) {
+      steps.add(
+          new Step(Action.POINTER_UP, lastIndex, 2, sampleOffsetsMs[lastIndex]));
+    }
+    long finalUpOffset =
+        sampleOffsetsMs[lastIndex] + (pointerCount == 2 ? POINTER_LIFT_DELAY_MS : 0);
+    steps.add(new Step(Action.UP, lastIndex, 1, finalUpOffset));
+    return steps;
+  }
+}
diff --git a/android-multitouch-helper/src/test/java/com/callstack/agentdevice/multitouchhelper/PointerEventScheduleTest.java b/android-multitouch-helper/src/test/java/com/callstack/agentdevice/multitouchhelper/PointerEventScheduleTest.java
new file mode 100644
index 000000000..e4bb1f90e
--- /dev/null
+++ b/android-multitouch-helper/src/test/java/com/callstack/agentdevice/multitouchhelper/PointerEventScheduleTest.java
@@ -0,0 +1,45 @@
+package com.callstack.agentdevice.multitouchhelper;
+
+import java.util.List;
+
+public final class PointerEventScheduleTest {
+  private PointerEventScheduleTest() {}
+
+  public static void main(String[] args) {
+    assertSteps(
+        PointerEventSchedule.create(1, new long[] {0, 16, 32}),
+        "DOWN:0:1:0",
+        "MOVE:1:1:16",
+        "MOVE:2:1:32",
+        "UP:2:1:32");
+    assertSteps(
+        PointerEventSchedule.create(2, new long[] {0, 16, 32}),
+        "DOWN:0:1:0",
+        "POINTER_DOWN:0:2:8",
+        "MOVE:1:2:16",
+        "MOVE:2:2:32",
+        "POINTER_UP:2:2:32",
+        "UP:2:1:40");
+  }
+
+  private static void assertSteps(List<PointerEventSchedule.Step> actual, String... expected) {
+    if (actual.size() != expected.length) {
+      throw new AssertionError("Expected " + expected.length + " steps, got " + actual.size());
+    }
+    for (int index = 0; index < expected.length; index += 1) {
+      PointerEventSchedule.Step step = actual.get(index);
+      String description =
+          step.action
+              + ":"
+              + step.sampleIndex
+              + ":"
+              + step.pointerCount
+              + ":"
+              + step.offsetMs;
+      if (!expected[index].equals(description)) {
+        throw new AssertionError(
+            "Step " + index + ": expected " + expected[index] + ", got " + description);
+      }
+    }
+  }
+}
diff --git a/apple-runner/AgentDeviceRunner/AgentDeviceRunnerUITests/RunnerAXSnapshotBridge.h b/apple-runner/AgentDeviceRunner/AgentDeviceRunnerUITests/RunnerAXSnapshotBridge.h
index 24d95de74..9f4ae95e0 100644
--- a/apple-runner/AgentDeviceRunner/AgentDeviceRunnerUITests/RunnerAXSnapshotBridge.h
+++ b/apple-runner/AgentDeviceRunner/AgentDeviceRunnerUITests/RunnerAXSnapshotBridge.h
@@ -9,6 +9,8 @@ NS_ASSUME_NONNULL_BEGIN
                                                     maxDepth:(NSInteger)maxDepth
                                                     maxNodes:(NSInteger)maxNodes;
 
++ (NSInteger)processIdentifierForApplication:(XCUIApplication *)application;
+
 @end
 
 NS_ASSUME_NONNULL_END
diff --git a/apple-runner/AgentDeviceRunner/AgentDeviceRunnerUITests/RunnerAXSnapshotBridge.m b/apple-runner/AgentDeviceRunner/AgentDeviceRunnerUITests/RunnerAXSnapshotBridge.m
index b6a34db49..8fe3f6bd3 100644
--- a/apple-runner/AgentDeviceRunner/AgentDeviceRunnerUITests/RunnerAXSnapshotBridge.m
+++ b/apple-runner/AgentDeviceRunner/AgentDeviceRunnerUITests/RunnerAXSnapshotBridge.m
@@ -164,6 +164,11 @@ + (NSInteger)integerFrom:(id)target selectorName:(NSString *)selectorName
   return send(target, selector);
 }
 
++ (NSInteger)processIdentifierForApplication:(XCUIApplication *)application
+{
+  return [self integerFrom:application selectorName:@"processID"];
+}
+
 + (id)accessibilityApplicationForApplication:(XCUIApplication *)application axClient:(id)axClient
 {
   NSInteger targetProcessID = [self integerFrom:application selectorName:@"processID"];
diff --git a/apple-runner/AgentDeviceRunner/AgentDeviceRunnerUITests/RunnerSynthesizedGesture.h b/apple-runner/AgentDeviceRunner/AgentDeviceRunnerUITests/RunnerSynthesizedGesture.h
index fc2ca9a8a..8eb12ed7e 100644
--- a/apple-runner/AgentDeviceRunner/AgentDeviceRunnerUITests/RunnerSynthesizedGesture.h
+++ b/apple-runner/AgentDeviceRunner/AgentDeviceRunnerUITests/RunnerSynthesizedGesture.h
@@ -4,16 +4,6 @@ NS_ASSUME_NONNULL_BEGIN
 
 @interface RunnerSynthesizedGesture : NSObject
 
-+ (NSString * _Nullable)synthesizeTransformWithApplication:(id)application
-                                                         x:(double)x
-                                                         y:(double)y
-                                                        dx:(double)dx
-                                                        dy:(double)dy
-                                                     scale:(double)scale
-                                                   degrees:(double)degrees
-                                                    radius:(double)radius
-                                                durationMs:(double)durationMs;
-
 + (NSString * _Nullable)synthesizeSwipeWithApplication:(id)application
                                                     x:(double)x
                                                     y:(double)y
@@ -32,6 +22,11 @@ NS_ASSUME_NONNULL_BEGIN
                                                    x:(double)x
                                                    y:(double)y;
 
+// Each pointer is an ordered array of { x, y, offsetMs } samples. The first sample
+// starts contact; subsequent samples move it; all pointers lift at their final offset.
++ (NSString * _Nullable)synthesizeGestureWithApplication:(id)application
+                                          pointerSamples:(NSArray<NSArray<NSDictionary<NSString *, NSNumber *> *> *> *)pointerSamples;
+
 // UIInterfaceOrientation of the app (1 portrait, 2 upsideDown, 3 landscapeRight,
 // 4 landscapeLeft), or 0 if unreadable.
 + (NSInteger)interfaceOrientationForApplication:(id)application;
diff --git a/apple-runner/AgentDeviceRunner/AgentDeviceRunnerUITests/RunnerSynthesizedGesture.m b/apple-runner/AgentDeviceRunner/AgentDeviceRunnerUITests/RunnerSynthesizedGesture.m
index 2b7056fdb..dd87a0c0e 100644
--- a/apple-runner/AgentDeviceRunner/AgentDeviceRunnerUITests/RunnerSynthesizedGesture.m
+++ b/apple-runner/AgentDeviceRunner/AgentDeviceRunnerUITests/RunnerSynthesizedGesture.m
@@ -1,7 +1,6 @@
 #import "RunnerSynthesizedGesture.h"
 
 #import <CoreGraphics/CoreGraphics.h>
-#import <math.h>
 #import <objc/message.h>
 
 typedef NSInteger (*RunnerMsgSendInteger)(id, SEL);
@@ -41,19 +40,6 @@ typedef id (*RunnerDragPointerPathFactory)(
 static NSString * _Nullable RunnerRequireClass(Class cls, NSString *className);
 static NSString * _Nullable RunnerRequireSelector(Class cls, SEL selector, NSString *selectorName);
 static NSString * _Nullable RunnerRequireApplicationSelector(id application, SEL selector, NSString *selectorName);
-static id RunnerPointerPath(
-  const RunnerXCTestEventBridge *bridge,
-  CGPoint start,
-  double x,
-  double y,
-  double dx,
-  double dy,
-  double scale,
-  double degrees,
-  double radius,
-  double durationMs,
-  double side
-);
 static id RunnerSwipePointerPath(
   const RunnerXCTestEventBridge *bridge,
   CGPoint start,
@@ -74,54 +60,16 @@ static id RunnerContinuousDragPointerPath(
   NSString *recordName,
   RunnerDragPointerPathFactory pathFactory
 );
-// XCTest's synthesized swipe convention moves to the endpoint in 100 ms, then holds there for
-// the requested duration. The fast movement is what distinguishes a swipe from a slow pan for
-// nested UIKit gesture recognizers.
+// XCTest's proven swipe profile reaches the endpoint in 100 ms, then holds for the planned
+// fling duration. Fast movement is what lets UIKit distinguish a fling from a timed pan.
 static const NSTimeInterval RunnerSwipeMovementDurationSeconds = 0.1;
 static id RunnerTapPointerPath(
   const RunnerXCTestEventBridge *bridge,
   CGPoint point
 );
-static CGPoint RunnerPointerPointAt(
-  double x,
-  double y,
-  double dx,
-  double dy,
-  double scale,
-  double degrees,
-  double baseRadius,
-  double t,
-  double side
-);
 
 @implementation RunnerSynthesizedGesture
 
-+ (NSString * _Nullable)synthesizeTransformWithApplication:(id)application
-                                                         x:(double)x
-                                                         y:(double)y
-                                                        dx:(double)dx
-                                                        dy:(double)dy
-                                                     scale:(double)scale
-                                                   degrees:(double)degrees
-                                                    radius:(double)radius
-                                                durationMs:(double)durationMs {
-  @try {
-    return [self trySynthesizeTransformWithApplication:application
-                                                     x:x
-                                                     y:y
-                                                    dx:dx
-                                                    dy:dy
-                                                 scale:scale
-                                               degrees:degrees
-                                                radius:radius
-                                            durationMs:durationMs];
-  } @catch (NSException *exception) {
-    NSString *name = exception.name ?: @"NSException";
-    NSString *reason = exception.reason ?: @"private XCTest event synthesis failed";
-    return [NSString stringWithFormat:@"%@: %@", name, reason];
-  }
-}
-
 + (NSString * _Nullable)synthesizeSwipeWithApplication:(id)application
                                                     x:(double)x
                                                     y:(double)y
@@ -178,76 +126,84 @@ + (NSString * _Nullable)synthesizeTapWithApplication:(id)application
   }
 }
 
-+ (NSInteger)interfaceOrientationForApplication:(id)application {
-  SEL selector = NSSelectorFromString(@"interfaceOrientation");
-  if (![application respondsToSelector:selector]) {
-    return 0;  // UIInterfaceOrientationUnknown
-  }
-  return ((RunnerMsgSendInteger)objc_msgSend)(application, selector);
-}
-
-+ (NSString * _Nullable)trySynthesizeTransformWithApplication:(id)application
-                                                            x:(double)x
-                                                            y:(double)y
-                                                           dx:(double)dx
-                                                           dy:(double)dy
-                                                        scale:(double)scale
-                                                      degrees:(double)degrees
-                                                       radius:(double)radius
-                                                   durationMs:(double)durationMs {
-  RunnerXCTestEventBridge bridge;
-  NSString *missing = RunnerResolveXCTestEventBridge(application, &bridge);
-  if (missing != nil) {
-    return missing;
-  }
-
-  NSInteger interfaceOrientation =
-    ((RunnerMsgSendInteger)objc_msgSend)(application, bridge.interfaceOrientationSelector);
-  NSInteger targetProcessID = ((RunnerMsgSendInteger)objc_msgSend)(application, bridge.processIDSelector);
-  if (targetProcessID <= 0) {
-    return @"private XCTest event synthesis unavailable: could not resolve target process ID";
-  }
-
-  id record = ((RunnerMsgSendInitRecord)objc_msgSend)(
-    [bridge.recordClass alloc],
-    bridge.initRecordSelector,
-    @"agent-device-transform",
-    interfaceOrientation
-  );
-  if (record == nil) {
-    return @"private XCTest event synthesis failed: could not create event record";
-  }
-  ((RunnerMsgSendSetInteger)objc_msgSend)(record, bridge.setTargetProcessIDSelector, targetProcessID);
++ (NSString * _Nullable)synthesizeGestureWithApplication:(id)application
+                                          pointerSamples:(NSArray<NSArray<NSDictionary<NSString *, NSNumber *> *> *> *)pointerSamples {
+  @try {
+    RunnerXCTestEventBridge bridge;
+    NSString *missing = RunnerResolveXCTestEventBridge(application, &bridge);
+    if (missing != nil) return missing;
+
+    NSInteger interfaceOrientation =
+      ((RunnerMsgSendInteger)objc_msgSend)(application, bridge.interfaceOrientationSelector);
+    NSInteger targetProcessID =
+      ((RunnerMsgSendInteger)objc_msgSend)(application, bridge.processIDSelector);
+    if (targetProcessID <= 0) {
+      return @"private XCTest event synthesis unavailable: could not resolve target process ID";
+    }
 
-  double sides[] = {1.0, -1.0};
-  for (int index = 0; index < 2; index += 1) {
-    double side = sides[index];
-    id path = RunnerPointerPath(
-      &bridge,
-      RunnerPointerPointAt(x, y, dx, dy, scale, degrees, radius, 0.0, side),
-      x,
-      y,
-      dx,
-      dy,
-      scale,
-      degrees,
-      radius,
-      durationMs,
-      side
+    id record = ((RunnerMsgSendInitRecord)objc_msgSend)(
+      [bridge.recordClass alloc],
+      bridge.initRecordSelector,
+      @"agent-device-gesture-plan",
+      interfaceOrientation
     );
-    if (path == nil) {
-      return @"private XCTest event synthesis failed: could not create pointer path";
+    if (record == nil) {
+      return @"private XCTest event synthesis failed: could not create event record";
+    }
+    ((RunnerMsgSendSetInteger)objc_msgSend)(record, bridge.setTargetProcessIDSelector, targetProcessID);
+
+    for (NSArray<NSDictionary<NSString *, NSNumber *> *> *samples in pointerSamples) {
+      NSDictionary<NSString *, NSNumber *> *first = samples.firstObject;
+      if (first == nil) return @"private XCTest event synthesis failed: empty pointer path";
+      CGPoint start = CGPointMake(first[@"x"].doubleValue, first[@"y"].doubleValue);
+      id path = ((RunnerMsgSendInitPath)objc_msgSend)(
+        [bridge.pathClass alloc],
+        bridge.initPathSelector,
+        start,
+        first[@"offsetMs"].doubleValue / 1000.0
+      );
+      if (path == nil) {
+        return @"private XCTest event synthesis failed: could not create pointer path";
+      }
+      for (NSUInteger index = 1; index < samples.count; index += 1) {
+        NSDictionary<NSString *, NSNumber *> *sample = samples[index];
+        CGPoint point = CGPointMake(sample[@"x"].doubleValue, sample[@"y"].doubleValue);
+        ((RunnerMsgSendPathMove)objc_msgSend)(
+          path,
+          bridge.moveSelector,
+          point,
+          sample[@"offsetMs"].doubleValue / 1000.0
+        );
+      }
+      NSDictionary<NSString *, NSNumber *> *last = samples.lastObject;
+      ((RunnerMsgSendPathOffset)objc_msgSend)(
+        path,
+        bridge.liftSelector,
+        last[@"offsetMs"].doubleValue / 1000.0
+      );
+      ((RunnerMsgSendAddPath)objc_msgSend)(record, bridge.addPathSelector, path);
+    }
+
+    NSError *error = nil;
+    BOOL ok = ((RunnerMsgSendSynthesize)objc_msgSend)(record, bridge.synthesizeSelector, &error);
+    if (!ok) {
+      NSString *detail = error.localizedDescription ?: @"synthesizeWithError returned false";
+      return [NSString stringWithFormat:@"private XCTest event synthesis failed: %@", detail];
     }
-    ((RunnerMsgSendAddPath)objc_msgSend)(record, bridge.addPathSelector, path);
+    return nil;
+  } @catch (NSException *exception) {
+    NSString *name = exception.name ?: @"NSException";
+    NSString *reason = exception.reason ?: @"private XCTest event synthesis failed";
+    return [NSString stringWithFormat:@"%@: %@", name, reason];
   }
+}
 
-  NSError *error = nil;
-  BOOL ok = ((RunnerMsgSendSynthesize)objc_msgSend)(record, bridge.synthesizeSelector, &error);
-  if (!ok) {
-    NSString *detail = error.localizedDescription ?: @"synthesizeWithError returned false";
-    return [NSString stringWithFormat:@"private XCTest event synthesis failed: %@", detail];
++ (NSInteger)interfaceOrientationForApplication:(id)application {
+  SEL selector = NSSelectorFromString(@"interfaceOrientation");
+  if (![application respondsToSelector:selector]) {
+    return 0;  // UIInterfaceOrientationUnknown
   }
-  return nil;
+  return ((RunnerMsgSendInteger)objc_msgSend)(application, selector);
 }
 
 static NSString * _Nullable RunnerTrySynthesizeDrag(
@@ -426,37 +382,6 @@ + (NSString * _Nullable)trySynthesizeTapWithApplication:(id)application
   return nil;
 }
 
-static id RunnerPointerPath(
-  const RunnerXCTestEventBridge *bridge,
-  CGPoint start,
-  double x,
-  double y,
-  double dx,
-  double dy,
-  double scale,
-  double degrees,
-  double radius,
-  double durationMs,
-  double side
-) {
-  id path =
-    ((RunnerMsgSendInitPath)objc_msgSend)([bridge->pathClass alloc], bridge->initPathSelector, start, 0.0);
-  if (path == nil) {
-    return nil;
-  }
-
-  int frameCount = MAX(3, (int)(durationMs / 16.0));
-  NSTimeInterval durationSeconds = durationMs / 1000.0;
-  for (int index = 1; index <= frameCount; index += 1) {
-    double t = (double)index / (double)frameCount;
-    CGPoint point = RunnerPointerPointAt(x, y, dx, dy, scale, degrees, radius, t, side);
-    NSTimeInterval offset = durationSeconds * t;
-    ((RunnerMsgSendPathMove)objc_msgSend)(path, bridge->moveSelector, point, offset);
-  }
-
-  ((RunnerMsgSendPathOffset)objc_msgSend)(path, bridge->liftSelector, durationSeconds);
-  return path;
-}
 
 static id RunnerSwipePointerPath(
   const RunnerXCTestEventBridge *bridge,
@@ -477,7 +402,6 @@ static id RunnerSwipePointerPath(
     end,
     RunnerSwipeMovementDurationSeconds
   );
-
   ((RunnerMsgSendPathOffset)objc_msgSend)(
     path,
     bridge->liftSelector,
@@ -527,28 +451,4 @@ static id RunnerTapPointerPath(
   return path;
 }
 
-static CGPoint RunnerPointerPointAt(
-  double x,
-  double y,
-  double dx,
-  double dy,
-  double scale,
-  double degrees,
-  double baseRadius,
-  double t,
-  double side
-) {
-  double centerX = x + dx * t;
-  double centerY = y + dy * t;
-  double startRadius = baseRadius / MAX(scale, 1.0);
-  double endRadius = baseRadius;
-  if (scale < 1.0) {
-    startRadius = baseRadius;
-    endRadius = baseRadius * scale;
-  }
-  double radius = startRadius + (endRadius - startRadius) * t;
-  double angle = (-M_PI_2) + (degrees * M_PI / 180.0) * t;
-  return CGPointMake(centerX + cos(angle) * radius * side, centerY + sin(angle) * radius * side);
-}
-
 @end
diff --git a/apple-runner/AgentDeviceRunner/AgentDeviceRunnerUITests/RunnerTests+CommandExecution.swift b/apple-runner/AgentDeviceRunner/AgentDeviceRunnerUITests/RunnerTests+CommandExecution.swift
index 6bf820edd..c9852205d 100644
--- a/apple-runner/AgentDeviceRunner/AgentDeviceRunnerUITests/RunnerTests+CommandExecution.swift
+++ b/apple-runner/AgentDeviceRunner/AgentDeviceRunnerUITests/RunnerTests+CommandExecution.swift
@@ -1,5 +1,23 @@
 import XCTest
 
+#if AGENT_DEVICE_RUNNER_UNIT_TESTS && os(iOS)
+import ObjectiveC.runtime
+
+private final class RunnerSynthesizedSwipeFailureStub: NSObject {
+  @objc(synthesizeSwipeWithApplication:x:y:x2:y2:durationMs:)
+  class func synthesizeSwipe(
+    application: XCUIApplication,
+    x: Double,
+    y: Double,
+    x2: Double,
+    y2: Double,
+    durationMs: Double
+  ) -> String? {
+    "forced private synthesis failure"
+  }
+}
+#endif
+
 extension RunnerTests {
   // MARK: - Main Thread Dispatch
 
@@ -58,7 +76,7 @@ extension RunnerTests {
 
   /// Runs a gesture action with uniform timing capture. Touch gestures pass `idleTimeout: true`
   /// (the default) to run inside the scroll idle-timeout + quiescence-skip wrapper; synthesis
-  /// gestures (pinch/rotate/transform) pass `false` because RunnerSynthesizedGesture governs its
+  /// pointer-plan gestures pass `false` because RunnerSynthesizedGesture governs their
   /// own timing. Returns the captured timing and the action's outcome.
   ///
   /// NOTE: a new SYNTHESIS gesture must pass `idleTimeout: false` — the default `true` would wrap
@@ -133,6 +151,24 @@ extension RunnerTests {
     return Response(ok: true, data: data)
   }
 
+  /// Gesture plans already return canonical centroid endpoints from the portable runtime.
+  /// Keep runner timing/fallback diagnostics, but do not leak the coordinate-drag adapter's
+  /// visualization frame into only the fast-fling response shape.
+  private func canonicalPlannedGestureResponse(_ response: Response) -> Response {
+    guard response.ok, let data = response.data else { return response }
+    return Response(
+      ok: true,
+      data: DataPayload(
+        message: data.message,
+        gestureStartUptimeMs: data.gestureStartUptimeMs,
+        gestureEndUptimeMs: data.gestureEndUptimeMs,
+        gestureFallback: data.gestureFallback,
+        gestureFallbackMessage: data.gestureFallbackMessage,
+        gestureFallbackHint: data.gestureFallbackHint
+      )
+    )
+  }
+
 #if AGENT_DEVICE_RUNNER_UNIT_TESTS
   func testGestureResponseIncludesSynthesizedTapFallbackDiagnostics() {
     let response = gestureResponse(
@@ -165,6 +201,89 @@ extension RunnerTests {
     XCTAssertEqual(response.data?.maestroNonHittableCoordinateFallbackUsed, true)
   }
 
+  func testCanonicalPlannedGestureResponseOmitsDragFrameAndPreservesDiagnostics() {
+    let response = gestureResponse(
+      message: "fling",
+      timing: (gestureStartUptimeMs: 1, gestureEndUptimeMs: 2),
+      frame: .drag(
+        DragVisualizationFrame(
+          x: 160,
+          y: 150,
+          x2: 40,
+          y2: 150,
+          referenceWidth: 200,
+          referenceHeight: 300
+        )
+      ),
+      fallback: GestureFallback(
+        strategy: "xctest-coordinate-drag",
+        message: "Private synthesis unavailable",
+        hint: "Using XCTest coordinate fallback."
+      )
+    )
+
+    let canonical = canonicalPlannedGestureResponse(response)
+
+    XCTAssertEqual(canonical.data?.gestureStartUptimeMs, 1)
+    XCTAssertEqual(canonical.data?.gestureEndUptimeMs, 2)
+    XCTAssertEqual(canonical.data?.gestureFallback, "xctest-coordinate-drag")
+    XCTAssertEqual(canonical.data?.gestureFallbackMessage, "Private synthesis unavailable")
+    XCTAssertEqual(canonical.data?.gestureFallbackHint, "Using XCTest coordinate fallback.")
+    XCTAssertNil(canonical.data?.x)
+    XCTAssertNil(canonical.data?.y)
+    XCTAssertNil(canonical.data?.x2)
+    XCTAssertNil(canonical.data?.y2)
+    XCTAssertNil(canonical.data?.referenceWidth)
+    XCTAssertNil(canonical.data?.referenceHeight)
+  }
+
+#if os(iOS)
+  func testSinglePointerFlingFallsBackToXCTestCoordinateDragWhenPrivateSynthesisFails() throws {
+    let selector = NSSelectorFromString(
+      "synthesizeSwipeWithApplication:x:y:x2:y2:durationMs:"
+    )
+    guard
+      let synthesizedSwipeMethod = class_getClassMethod(RunnerSynthesizedGesture.self, selector),
+      let failureStubMethod = class_getClassMethod(RunnerSynthesizedSwipeFailureStub.self, selector)
+    else {
+      XCTFail("unable to install synthesized swipe failure stub")
+      return
+    }
+    let originalImplementation = method_getImplementation(synthesizedSwipeMethod)
+    method_setImplementation(
+      synthesizedSwipeMethod,
+      method_getImplementation(failureStubMethod)
+    )
+    app.launch()
+    runnerAccessibilityHealth = .healthy
+    defer {
+      method_setImplementation(synthesizedSwipeMethod, originalImplementation)
+      invalidateCachedTarget(reason: "unit_test_cleanup")
+      app.terminate()
+    }
+    let command = try runnerCommandFixture(
+      """
+      {"command":"gesture","commandId":"gesture-fling-fallback","gesturePlan":{"topology":"single","intent":"fling","durationMs":100,"viewport":{"x":0,"y":0,"width":200,"height":300},"pointers":[{"pointerId":0,"samples":[{"offsetMs":0,"point":{"x":160,"y":150}},{"offsetMs":100,"point":{"x":40,"y":150}}]}]}}
+      """
+    )
+
+    let response = try executeOnMainPrepared(command: command, activeApp: app)
+
+    XCTAssertTrue(response.ok)
+    XCTAssertEqual(response.data?.message, "fling")
+    XCTAssertEqual(response.data?.gestureFallback, "xctest-coordinate-drag")
+    XCTAssertEqual(response.data?.gestureFallbackMessage, "forced private synthesis failure")
+    XCTAssertEqual(
+      response.data?.gestureFallbackHint,
+      "Private XCTest event synthesis is required for AX-free coordinate drag on iOS; update Xcode if this persists."
+    )
+    XCTAssertNil(response.data?.x)
+    XCTAssertNil(response.data?.y)
+    XCTAssertNil(response.data?.x2)
+    XCTAssertNil(response.data?.y2)
+  }
+#endif
+
   func testXCTestRecordedFailureResponseFailsMutatingSuccesses() throws {
     let command = try runnerCommandFixture(#"{"command":"tap","commandId":"tap-1"}"#)
     let response = Response(ok: true, data: DataPayload(message: "tapped"))
@@ -196,6 +315,28 @@ extension RunnerTests {
     XCTAssertNil(xctestRecordedFailureResponse(command: tapCommand, response: runnerFatalResponse))
   }
 
+  func testMissingBundleCommandInvalidatesCompleteCachedTargetState() throws {
+    app.launch()
+    currentApp = app
+    currentBundleId = "com.example.stale-target"
+    currentAppProcessIdentifier = 42
+    snapshotXCTestPenaltyWarmupExemptionPending = true
+    defer {
+      invalidateCachedTarget(reason: "unit_test_cleanup")
+      app.terminate()
+    }
+    let command = try runnerCommandFixture(
+      #"{"command":"snapshot","commandId":"snapshot-without-bundle"}"#
+    )
+
+    _ = prepareActiveCommandContext(command: command)
+
+    XCTAssertNil(currentApp)
+    XCTAssertNil(currentBundleId)
+    XCTAssertNil(currentAppProcessIdentifier)
+    XCTAssertFalse(snapshotXCTestPenaltyWarmupExemptionPending)
+  }
+
   func testSkipAppActivationPreflightOnlyIncludesCoordinateOnlySynthesizedTaps() throws {
     currentApp = app
     currentBundleId = nil
@@ -264,7 +405,7 @@ extension RunnerTests {
       """
       {"command":"sequence","commandId":"seq-1","steps":[
         {"kind":"tap","x":10,"y":20,"synthesized":true},
-        {"kind":"drag","x":10,"y":200,"x2":10,"y2":100,"synthesized":true}
+        {"kind":"longPress","x":10,"y":200,"durationMs":300}
       ]}
       """
     )
@@ -945,11 +1086,12 @@ extension RunnerTests {
       if let bundleId = requestedBundleId {
         if currentBundleId != bundleId || currentApp == nil {
           _ = activateTarget(bundleId: bundleId, reason: "bundle_changed")
+        } else {
+          refreshCachedTargetIfProcessChanged(bundleId: bundleId)
         }
       } else {
         // Do not reuse stale bundle targets when the caller does not explicitly request one.
-        currentApp = nil
-        currentBundleId = nil
+        invalidateCachedTarget(reason: "missing_app_bundle")
       }
 
       activeApp = currentApp ?? app
@@ -1150,7 +1292,6 @@ extension RunnerTests {
         durationMs: command.durationMs,
         synthesized: command.synthesized == true,
         message: "dragged",
-        dragSemantics: command.dragSemantics,
         synthesizedPolicyKind: .synthesizedDrag
       )
     case .scroll:
@@ -1470,79 +1611,53 @@ extension RunnerTests {
         return Response(ok: false, error: ErrorPayload(message: "alert not found"))
       }
       return handleAlert(alert, action: action)
-    case .pinch:
-      guard let scale = command.scale, scale > 0 else {
-        return Response(ok: false, error: ErrorPayload(message: "pinch requires scale > 0"))
-      }
-      let (timing, outcome) = performGesture(activeApp, idleTimeout: false) {
-        pinch(app: activeApp, scale: scale, x: command.x, y: command.y)
-      }
-      if let response = unsupportedResponse(for: outcome) {
-        return response
-      }
-      return gestureResponse(message: "pinched", timing: timing)
-    case .sequence:
-      return executeSequence(command: command, activeApp: activeApp)
-    case .rotateGesture:
-      guard let degrees = command.degrees, degrees.isFinite else {
-        return Response(ok: false, error: ErrorPayload(message: "rotateGesture requires degrees"))
-      }
-      let velocity = command.velocity ?? (degrees >= 0 ? 1.0 : -1.0)
-      guard velocity.isFinite && velocity != 0 else {
-        return Response(ok: false, error: ErrorPayload(message: "rotateGesture velocity must be non-zero"))
-      }
-      let (timing, outcome) = performGesture(activeApp, idleTimeout: false) {
-        rotateGesture(
-          app: activeApp,
-          degrees: degrees,
-          x: command.x,
-          y: command.y,
-          velocity: velocity
+    case .gesture:
+      guard let plan = command.gesturePlan else {
+        return Response(
+          ok: false,
+          error: ErrorPayload(code: "INVALID_ARGS", message: "gesture requires gesturePlan")
         )
       }
-      if let response = unsupportedResponse(for: outcome) {
-        return response
-      }
-      return gestureResponse(message: "rotatedGesture", timing: timing)
-    case .transformGesture:
-      guard
-        let x = command.x,
-        let y = command.y,
-        let dx = command.dx,
-        let dy = command.dy,
-        x.isFinite,
-        y.isFinite,
-        dx.isFinite,
-        dy.isFinite
-      else {
-        return Response(ok: false, error: ErrorPayload(message: "transformGesture requires finite x y dx dy"))
-      }
-      guard let scale = command.scale, scale.isFinite, scale > 0 else {
-        return Response(ok: false, error: ErrorPayload(message: "transformGesture requires scale > 0"))
-      }
-      guard let degrees = command.degrees, degrees.isFinite else {
-        return Response(ok: false, error: ErrorPayload(message: "transformGesture requires finite degrees"))
+      if let validationError = plannedGestureValidationError(plan) {
+        return Response(
+          ok: false,
+          error: ErrorPayload(code: "INVALID_ARGS", message: validationError)
+        )
       }
-      let durationMs = command.durationMs ?? 300
-      guard durationMs.isFinite && durationMs >= 16 else {
-        return Response(ok: false, error: ErrorPayload(message: "transformGesture durationMs must be >= 16"))
+      if plannedGestureExecution(for: plan) == .fastSwipe {
+        // Validation above guarantees a non-empty, single-pointer path for this execution kind.
+        let first = plan.pointers[0].samples.first!.point
+        let last = plan.pointers[0].samples.last!.point
+        return canonicalPlannedGestureResponse(
+          executeDragGesture(
+            activeApp: activeApp,
+            x: first.x,
+            y: first.y,
+            x2: last.x,
+            y2: last.y,
+            durationMs: plan.durationMs,
+            synthesized: true,
+            message: plan.intent,
+            synthesizedPolicyKind: .synthesizedDrag,
+            synthesizedProfile: .fastSwipe
+          )
+        )
       }
       let (timing, outcome) = performGesture(activeApp, idleTimeout: false) {
-        transformGesture(
-          app: activeApp,
-          x: x,
-          y: y,
-          dx: dx,
-          dy: dy,
-          scale: scale,
-          degrees: degrees,
-          durationMs: durationMs
-        )
+        sampledPlannedGesture(app: activeApp, plan: plan)
       }
       if let response = unsupportedResponse(for: outcome) {
         return response
       }
-      return gestureResponse(message: "transformedGesture", timing: timing)
+      return gestureResponse(message: plan.intent, timing: timing)
+    case .gestureViewport:
+      let frame = resolvedTouchReferenceFrame(app: activeApp, appFrame: activeApp.frame)
+      guard !frame.isNull, !frame.isInfinite, !frame.isEmpty else {
+        return Response(ok: false, error: ErrorPayload(code: "COMMAND_FAILED", message: "Active app interaction viewport is unavailable"))
+      }
+      return Response(ok: true, data: DataPayload(message: "gestureViewport", x: frame.minX, y: frame.minY, x2: frame.width, y2: frame.height))
+    case .sequence:
+      return executeSequence(command: command, activeApp: activeApp)
     }
   }
 
@@ -1558,9 +1673,9 @@ extension RunnerTests {
     durationMs: Double?,
     synthesized: Bool,
     message: String,
-    dragSemantics: SynthesizedDragSemantics? = nil,
     synthesizedContext: SynthesizedCoordinateContext? = nil,
-    synthesizedPolicyKind: SynthesizedGesturePolicyKind
+    synthesizedPolicyKind: SynthesizedGesturePolicyKind,
+    synthesizedProfile: SynthesizedDragProfile = .continuous
   ) -> Response {
     let commandName = dragCommandName(message: message)
     guard x.isFinite, y.isFinite, x2.isFinite, y2.isFinite else {
@@ -1577,9 +1692,9 @@ extension RunnerTests {
       y2: y2,
       durationMs: durationMs,
       message: message,
-      dragSemantics: dragSemantics,
       context: synthesizedContext,
-      policyKind: synthesizedPolicyKind
+      policyKind: synthesizedPolicyKind,
+      profile: synthesizedProfile
     ) {
       return synthesizedResponse
     }
@@ -1603,7 +1718,7 @@ extension RunnerTests {
           x2: dragPoints.x2,
           y2: dragPoints.y2,
           durationMs: durationMs,
-          semantics: dragSemantics,
+          profile: synthesizedProfile,
           context: context
         )
       }
@@ -1644,9 +1759,9 @@ extension RunnerTests {
     y2: Double,
     durationMs: Double?,
     message: String,
-    dragSemantics: SynthesizedDragSemantics?,
     context: SynthesizedCoordinateContext?,
-    policyKind: SynthesizedGesturePolicyKind
+    policyKind: SynthesizedGesturePolicyKind,
+    profile: SynthesizedDragProfile
   ) -> Response? {
 #if os(iOS)
     let policy = synthesizedGesturePolicy(policyKind)
@@ -1698,7 +1813,7 @@ extension RunnerTests {
         x2: plan.points.x2,
         y2: plan.points.y2,
         durationMs: durationMs,
-        semantics: dragSemantics,
+        profile: profile,
         context: plan.context
       )
     }
diff --git a/apple-runner/AgentDeviceRunner/AgentDeviceRunnerUITests/RunnerTests+CommandJournal.swift b/apple-runner/AgentDeviceRunner/AgentDeviceRunnerUITests/RunnerTests+CommandJournal.swift
index 1132e0254..5168192f9 100644
--- a/apple-runner/AgentDeviceRunner/AgentDeviceRunnerUITests/RunnerTests+CommandJournal.swift
+++ b/apple-runner/AgentDeviceRunner/AgentDeviceRunnerUITests/RunnerTests+CommandJournal.swift
@@ -146,7 +146,7 @@ final class RunnerCommandJournal {
     case .tap, .mouseClick, .longPress, .drag,
          .remotePress, .type, .swipe, .scroll, .desktopScroll, .findText, .querySelector, .readText, .back,
          .backInApp, .backSystem, .home, .rotate, .appSwitcher, .keyboardDismiss, .keyboardReturn,
-         .alert, .pinch, .sequence, .rotateGesture, .transformGesture, .recordStart, .recordStop,
+         .alert, .sequence, .gesture, .gestureViewport, .recordStart, .recordStop,
          .status, .uptime, .shutdown:
       return true
     }
@@ -383,7 +383,7 @@ extension RunnerTests {
                          gestureStartUptimeMs: 100, gestureEndUptimeMs: 120),
       SequenceStepResult(ok: true, kind: "tap", errorCode: nil, errorMessage: nil,
                          gestureStartUptimeMs: 130, gestureEndUptimeMs: 150),
-      SequenceStepResult(ok: false, kind: "drag", errorCode: "UNSUPPORTED_OPERATION",
+      SequenceStepResult(ok: false, kind: "longPress", errorCode: "UNSUPPORTED_OPERATION",
                          errorMessage: longError, gestureStartUptimeMs: 160, gestureEndUptimeMs: 180),
     ]
 
diff --git a/apple-runner/AgentDeviceRunner/AgentDeviceRunnerUITests/RunnerTests+Interaction.swift b/apple-runner/AgentDeviceRunner/AgentDeviceRunnerUITests/RunnerTests+Interaction.swift
index c41a95f6a..14c85a40b 100644
--- a/apple-runner/AgentDeviceRunner/AgentDeviceRunnerUITests/RunnerTests+Interaction.swift
+++ b/apple-runner/AgentDeviceRunner/AgentDeviceRunnerUITests/RunnerTests+Interaction.swift
@@ -13,6 +13,16 @@ private enum RunnerInterfaceOrientation {
 }
 
 extension RunnerTests {
+  enum PlannedGestureExecution: Equatable {
+    case fastSwipe
+    case sampled
+  }
+
+  enum SynthesizedDragProfile {
+    case continuous
+    case fastSwipe
+  }
+
   struct TouchVisualizationFrame {
     let x: Double
     let y: Double
@@ -775,7 +785,7 @@ extension RunnerTests {
     x2: Double,
     y2: Double,
     durationMs: Double,
-    semantics: SynthesizedDragSemantics?,
+    profile: SynthesizedDragProfile = .continuous,
     context: SynthesizedCoordinateContext? = nil
   ) -> RunnerInteractionOutcome {
 #if os(iOS)
@@ -795,8 +805,9 @@ extension RunnerTests {
     let frame = context.referenceFrame
     let start = nativeSynthesizedPoint(orientedX: x, orientedY: y, in: frame, interfaceOrientation: orientation)
     let end = nativeSynthesizedPoint(orientedX: x2, orientedY: y2, in: frame, interfaceOrientation: orientation)
-    let message = if semantics == .swipe {
-      RunnerSynthesizedGesture.synthesizeSwipe(
+    let message = switch profile {
+    case .continuous:
+      RunnerSynthesizedGesture.synthesizeContinuousDrag(
         withApplication: app,
         x: Double(start.x),
         y: Double(start.y),
@@ -804,8 +815,8 @@ extension RunnerTests {
         y2: Double(end.y),
         durationMs: durationMs
       )
-    } else {
-      RunnerSynthesizedGesture.synthesizeContinuousDrag(
+    case .fastSwipe:
+      RunnerSynthesizedGesture.synthesizeSwipe(
         withApplication: app,
         x: Double(start.x),
         y: Double(start.y),
@@ -1166,125 +1177,134 @@ extension RunnerTests {
     }
   }
 
-  func pinch(app: XCUIApplication, scale: Double, x: Double?, y: Double?) -> RunnerInteractionOutcome {
-#if os(iOS)
-    // A coordinate tap+drag is a single-finger gesture: React Native reads it as a pan
-    // and the pinch scale never changes (#629). Drive the two-finger XCTest synthesis
-    // path (the same one transformGesture uses) with zero translation/rotation so RN's
-    // pinch recognizer actually fires.
-    let frame = interactionRoot(app: app).frame
-    let centerX = x ?? Double(frame.midX)
-    let centerY = y ?? Double(frame.midY)
-    return transformGesture(
-      app: app,
-      x: centerX,
-      y: centerY,
-      dx: 0,
-      dy: 0,
-      scale: scale,
-      degrees: 0,
-      durationMs: 300
-    )
-#elseif os(tvOS)
-    return .unsupported(
-      message: "pinch is not supported on tvOS",
-      hint: "tvOS has no touch input; pinch requires a touchscreen (run on iOS)."
-    )
-#else
-    return .unsupported(
-      message: "pinch is not supported on macOS",
-      hint: "macOS automation has no multi-touch input; pinch requires a touchscreen (run on iOS)."
-    )
-#endif
+  func plannedGestureValidationError(_ plan: RunnerGesturePlan) -> String? {
+    guard plan.topology == "single" || plan.topology == "two" else {
+      return "planned gesture topology must be single or two"
+    }
+    let supportedIntent = plan.topology == "single"
+      ? plan.intent == "fling" || plan.intent == "pan"
+      : plan.intent == "pan" || plan.intent == "pinch" || plan.intent == "rotate"
+        || plan.intent == "transform"
+    guard supportedIntent else { return "planned gesture has unsupported intent for its topology" }
+    guard plan.durationMs.isFinite, plan.durationMs >= 16, plan.durationMs <= 10_000 else {
+      return "planned gesture durationMs must be between 16 and 10000"
+    }
+    let viewport = plan.viewport
+    guard viewport.x.isFinite, viewport.y.isFinite, viewport.width.isFinite,
+      viewport.height.isFinite, viewport.width > 0, viewport.height > 0
+    else {
+      return "planned gesture viewport must be finite and positive"
+    }
+    let expectedPointerCount = plan.topology == "single" ? 1 : 2
+    guard plan.pointers.count == expectedPointerCount else {
+      return "planned gesture pointer count does not match topology"
+    }
+    for (index, pointer) in plan.pointers.enumerated() where pointer.pointerId != index {
+      return "planned gesture requires ordered pointer ids"
+    }
+    let firstSamples = plan.pointers[0].samples
+    guard firstSamples.count >= 2 else { return "planned pointer paths require at least two samples" }
+    for pointer in plan.pointers {
+      guard pointer.samples.count == firstSamples.count else {
+        return "planned pointer paths require matching samples"
+      }
+      var previousOffset = -1.0
+      for (index, sample) in pointer.samples.enumerated() {
+        guard sample.offsetMs.isFinite,
+          sample.offsetMs == firstSamples[index].offsetMs,
+          sample.offsetMs > previousOffset
+        else {
+          return "planned pointer sample offsets must match and strictly increase"
+        }
+        let point = sample.point
+        guard point.x.isFinite, point.y.isFinite,
+          point.x >= viewport.x,
+          point.x <= viewport.x + viewport.width,
+          point.y >= viewport.y,
+          point.y <= viewport.y + viewport.height
+        else {
+          return "planned pointer sample lies outside the viewport"
+        }
+        previousOffset = sample.offsetMs
+      }
+      guard pointer.samples.first?.offsetMs == 0,
+        pointer.samples.last?.offsetMs == plan.durationMs
+      else {
+        return "planned pointer paths must start at 0 and end at durationMs"
+      }
+    }
+    if plan.topology == "two" {
+      guard let firstStart = firstSamples.first?.point,
+        let secondStart = plan.pointers[1].samples.first?.point,
+        hypot(firstStart.x - secondStart.x, firstStart.y - secondStart.y) > 0
+      else {
+        return "planned pointer paths require a positive initial span"
+      }
+    }
+    return nil
   }
 
-  func rotateGesture(app: XCUIApplication, degrees: Double, x: Double?, y: Double?, velocity: Double) -> RunnerInteractionOutcome {
-#if os(iOS)
-    // Drive the two-finger XCTest synthesis path (the same one pinch/transformGesture use, #634)
-    // with zero translation/scale so React Native's rotation recognizer actually fires. The native
-    // XCUIElement.rotate(withVelocity:) injects a single synthetic rotation that RN's gesture
-    // handler does not read reliably — the same class of problem #629/#634 fixed for pinch.
-    // velocity is unused on iOS (synthesis speed is governed by durationMs); the wire contract
-    // keeps it for compatibility and direction is carried entirely by the sign of `degrees`.
-    let frame = interactionRoot(app: app).frame
-    let centerX = x ?? Double(frame.midX)
-    let centerY = y ?? Double(frame.midY)
-    return transformGesture(
-      app: app,
-      x: centerX,
-      y: centerY,
-      dx: 0,
-      dy: 0,
-      scale: 1,
-      degrees: degrees,
-      durationMs: 300
-    )
-#elseif os(tvOS)
-    return .unsupported(
-      message: "rotate-gesture is not supported on tvOS",
-      hint: "tvOS has no touch input; rotation gestures require a touchscreen (run on iOS)."
-    )
-#else
-    return .unsupported(
-      message: "rotate-gesture is not supported on macOS",
-      hint: "macOS automation has no multi-touch input; rotation gestures require a touchscreen (run on iOS)."
-    )
-#endif
+  func plannedGestureExecution(for plan: RunnerGesturePlan) -> PlannedGestureExecution {
+    plan.topology == "single" && plan.intent == "fling" ? .fastSwipe : .sampled
   }
 
-  func transformGesture(
+  func sampledPlannedGesture(
     app: XCUIApplication,
-    x: Double,
-    y: Double,
-    dx: Double,
-    dy: Double,
-    scale: Double,
-    degrees: Double,
-    durationMs: Double
+    plan: RunnerGesturePlan
   ) -> RunnerInteractionOutcome {
 #if os(iOS)
-    let target = interactionRoot(app: app)
     let orientation = Int(RunnerSynthesizedGesture.interfaceOrientation(forApplication: app))
-    let point = nativeSynthesizedPoint(orientedX: x, orientedY: y, in: app.frame, interfaceOrientation: orientation)
-    let vector = nativeSynthesizedVector(orientedDx: dx, orientedDy: dy, interfaceOrientation: orientation)
-    if let message = RunnerSynthesizedGesture.synthesizeTransform(
+    // The portable planner and validation use this exact viewport. Using app.frame here can
+    // diverge when XCTest unions transformed/off-screen descendants into the application frame.
+    let frame = CGRect(
+      x: plan.viewport.x,
+      y: plan.viewport.y,
+      width: plan.viewport.width,
+      height: plan.viewport.height
+    )
+    let pointerSamples: [[[String: NSNumber]]] = plan.pointers.map { pointer in
+      pointer.samples.map { sample in
+        let point = nativeSynthesizedPoint(
+          orientedX: sample.point.x,
+          orientedY: sample.point.y,
+          in: frame,
+          interfaceOrientation: orientation
+        )
+        return [
+          "x": NSNumber(value: Double(point.x)),
+          "y": NSNumber(value: Double(point.y)),
+          "offsetMs": NSNumber(value: sample.offsetMs),
+        ]
+      }
+    }
+    if let message = RunnerSynthesizedGesture.synthesizeGesture(
       withApplication: app,
-      x: Double(point.x),
-      y: Double(point.y),
-      dx: Double(vector.dx),
-      dy: Double(vector.dy),
-      scale: scale,
-      degrees: degrees,
-      radius: transformGestureRadius(frame: target.frame, scale: scale),
-      durationMs: durationMs
+      pointerSamples: pointerSamples
     ) {
       return .unsupported(
         message: message,
-        hint: "This gesture uses private XCTest event-synthesis APIs; rebuild the runner with a supported Xcode (these APIs can change across Xcode versions)."
+        hint: "This gesture uses private XCTest event-synthesis APIs; rebuild the runner with a supported Xcode if this persists."
       )
     }
     return .performed
 #elseif os(tvOS)
     return .unsupported(
-      message: "transformGesture is not supported on tvOS",
-      hint: "tvOS has no touch input; transform gestures require a touchscreen (run on iOS)."
+      message: "two-finger gestures are not supported on tvOS",
+      hint: "tvOS has no touch input; use remote-driven navigation."
+    )
+#elseif os(visionOS)
+    return .unsupported(
+      message: "two-finger touch gestures are not supported on visionOS",
+      hint: "The current XCTest synthesizer supports iOS and iPadOS touch simulators only."
     )
 #else
     return .unsupported(
-      message: "transformGesture is not supported on macOS",
-      hint: "macOS automation has no multi-touch input; transform gestures require a touchscreen (run on iOS)."
+      message: "two-finger gestures are not supported on macOS",
+      hint: "macOS automation has no multi-touch input; run on an iOS simulator."
     )
 #endif
   }
 
-  private func transformGestureRadius(frame: CGRect, scale: Double) -> Double {
-    let shorterSide = Double(min(frame.width, frame.height))
-    let frameRadius = shorterSide * 0.20
-    let minimumEndRadius = shorterSide * 0.08
-    let scaleAdjustedRadius = scale < 1.0 ? max(frameRadius, minimumEndRadius / scale) : frameRadius
-    return min(max(scaleAdjustedRadius, 48.0), shorterSide * 0.35)
-  }
-
   private func interactionRoot(app: XCUIApplication) -> XCUIElement {
     let windows = app.windows.allElementsBoundByIndex
     if let window = windows.first(where: { $0.exists && !$0.frame.isEmpty }) {
@@ -1430,6 +1450,53 @@ extension RunnerTests {
     )
   }
 
+  func testPlannedMultiTouchGestureAcceptsMatchingInBoundsTrajectories() throws {
+    let plan = try JSONDecoder().decode(
+      RunnerGesturePlan.self,
+      from: Data(
+        #"{"topology":"two","intent":"pan","durationMs":32,"viewport":{"x":0,"y":0,"width":200,"height":300},"pointers":[{"pointerId":0,"samples":[{"offsetMs":0,"point":{"x":80,"y":80}},{"offsetMs":16,"point":{"x":90,"y":85}},{"offsetMs":32,"point":{"x":100,"y":90}}]},{"pointerId":1,"samples":[{"offsetMs":0,"point":{"x":80,"y":120}},{"offsetMs":16,"point":{"x":90,"y":125}},{"offsetMs":32,"point":{"x":100,"y":130}}]}]}"#.utf8
+      )
+    )
+
+    XCTAssertNil(plannedGestureValidationError(plan))
+  }
+
+  func testPlannedMultiTouchGestureRejectsMismatchedOffsets() throws {
+    let plan = try JSONDecoder().decode(
+      RunnerGesturePlan.self,
+      from: Data(
+        #"{"topology":"two","intent":"transform","durationMs":32,"viewport":{"x":0,"y":0,"width":200,"height":300},"pointers":[{"pointerId":0,"samples":[{"offsetMs":0,"point":{"x":80,"y":80}},{"offsetMs":32,"point":{"x":100,"y":90}}]},{"pointerId":1,"samples":[{"offsetMs":0,"point":{"x":80,"y":120}},{"offsetMs":31,"point":{"x":100,"y":130}}]}]}"#.utf8
+      )
+    )
+
+    XCTAssertEqual(
+      plannedGestureValidationError(plan),
+      "planned pointer sample offsets must match and strictly increase"
+    )
+  }
+
+  func testSinglePointerFlingUsesFastSwipeExecution() throws {
+    let plan = try JSONDecoder().decode(
+      RunnerGesturePlan.self,
+      from: Data(
+        #"{"topology":"single","intent":"fling","durationMs":100,"viewport":{"x":0,"y":0,"width":200,"height":300},"pointers":[{"pointerId":0,"samples":[{"offsetMs":0,"point":{"x":160,"y":150}},{"offsetMs":100,"point":{"x":40,"y":150}}]}]}"#.utf8
+      )
+    )
+
+    XCTAssertEqual(plannedGestureExecution(for: plan), .fastSwipe)
+  }
+
+  func testSinglePointerTimedPanUsesSampledExecution() throws {
+    let plan = try JSONDecoder().decode(
+      RunnerGesturePlan.self,
+      from: Data(
+        #"{"topology":"single","intent":"pan","durationMs":500,"viewport":{"x":0,"y":0,"width":200,"height":300},"pointers":[{"pointerId":0,"samples":[{"offsetMs":0,"point":{"x":160,"y":150}},{"offsetMs":250,"point":{"x":100,"y":150}},{"offsetMs":500,"point":{"x":40,"y":150}}]}]}"#.utf8
+      )
+    )
+
+    XCTAssertEqual(plannedGestureExecution(for: plan), .sampled)
+  }
+
   func testDesktopScrollWheelDeltasMapDirections() throws {
     XCTAssertEqual(try XCTUnwrap(desktopScrollWheelDeltas(direction: "up", pixels: 120)).vertical, 120)
     XCTAssertEqual(try XCTUnwrap(desktopScrollWheelDeltas(direction: "down", pixels: 120)).vertical, -120)
diff --git a/apple-runner/AgentDeviceRunner/AgentDeviceRunnerUITests/RunnerTests+Lifecycle.swift b/apple-runner/AgentDeviceRunner/AgentDeviceRunnerUITests/RunnerTests+Lifecycle.swift
index 8c73d1c11..09721e8f9 100644
--- a/apple-runner/AgentDeviceRunner/AgentDeviceRunnerUITests/RunnerTests+Lifecycle.swift
+++ b/apple-runner/AgentDeviceRunner/AgentDeviceRunnerUITests/RunnerTests+Lifecycle.swift
@@ -85,6 +85,8 @@ extension RunnerTests {
     }
     currentApp = app
     currentBundleId = nil
+    currentAppProcessIdentifier = nil
+    snapshotXCTestPenaltyWarmupExemptionPending = false
   }
 
   func invalidateCachedTarget(reason: String) {
@@ -93,6 +95,42 @@ extension RunnerTests {
     }
     currentApp = nil
     currentBundleId = nil
+    currentAppProcessIdentifier = nil
+    snapshotXCTestPenaltyWarmupExemptionPending = false
+  }
+
+  func refreshCachedTargetIfProcessChanged(bundleId: String) {
+    guard currentBundleId == bundleId, currentApp != nil else { return }
+    let candidate = XCUIApplication(bundleIdentifier: bundleId)
+    let observedProcessIdentifier = Self.processIdentifier(of: candidate)
+    guard Self.shouldRefreshCachedTarget(
+      cachedProcessIdentifier: currentAppProcessIdentifier,
+      observedProcessIdentifier: observedProcessIdentifier
+    ) else { return }
+    NSLog(
+      "AGENT_DEVICE_RUNNER_TARGET_CACHE_REFRESH bundle=%@ previousPid=%d currentPid=%d",
+      bundleId,
+      currentAppProcessIdentifier ?? 0,
+      observedProcessIdentifier ?? 0
+    )
+    currentApp = candidate
+    currentAppProcessIdentifier = observedProcessIdentifier
+    clearSnapshotXCTestChannelPenalty(reason: "target_process_changed")
+    snapshotXCTestPenaltyWarmupExemptionPending = true
+    needsFirstInteractionDelay = true
+  }
+
+  static func processIdentifier(of target: XCUIApplication) -> Int? {
+    let value = RunnerAXSnapshotBridge.processIdentifier(for: target)
+    return value > 0 ? value : nil
+  }
+
+  static func shouldRefreshCachedTarget(
+    cachedProcessIdentifier: Int?,
+    observedProcessIdentifier: Int?
+  ) -> Bool {
+    guard let cachedProcessIdentifier, let observedProcessIdentifier else { return false }
+    return cachedProcessIdentifier != observedProcessIdentifier
   }
 
   func targetNeedsActivation(_ target: XCUIApplication) -> Bool {
@@ -141,6 +179,8 @@ extension RunnerTests {
     target.activate()
     currentApp = target
     currentBundleId = bundleId
+    currentAppProcessIdentifier = Self.processIdentifier(of: target)
+    snapshotXCTestPenaltyWarmupExemptionPending = false
     needsFirstInteractionDelay = true
     return target
   }
diff --git a/apple-runner/AgentDeviceRunner/AgentDeviceRunnerUITests/RunnerTests+LifecycleCacheTests.swift b/apple-runner/AgentDeviceRunner/AgentDeviceRunnerUITests/RunnerTests+LifecycleCacheTests.swift
new file mode 100644
index 000000000..34898554f
--- /dev/null
+++ b/apple-runner/AgentDeviceRunner/AgentDeviceRunnerUITests/RunnerTests+LifecycleCacheTests.swift
@@ -0,0 +1,54 @@
+import XCTest
+
+extension RunnerTests {
+  func testCachedTargetRefreshRequiresChangedPositiveProcessIdentity() {
+    XCTAssertFalse(
+      Self.shouldRefreshCachedTarget(
+        cachedProcessIdentifier: nil,
+        observedProcessIdentifier: 42
+      )
+    )
+    XCTAssertFalse(
+      Self.shouldRefreshCachedTarget(
+        cachedProcessIdentifier: 42,
+        observedProcessIdentifier: 42
+      )
+    )
+    XCTAssertTrue(
+      Self.shouldRefreshCachedTarget(
+        cachedProcessIdentifier: 41,
+        observedProcessIdentifier: 42
+      )
+    )
+  }
+
+  func testSnapshotPenaltyWarmupExemptionIsConsumedOnce() {
+    snapshotXCTestPenaltyWarmupExemptionPending = true
+
+    XCTAssertTrue(consumeSnapshotXCTestPenaltyWarmupExemption())
+    XCTAssertFalse(consumeSnapshotXCTestPenaltyWarmupExemption())
+  }
+
+  func testSnapshotPenaltyCanBeClearedAcrossTargetProcessReplacement() {
+    penalizeSnapshotXCTestChannel(bundleId: "com.example.app", reason: "test")
+    XCTAssertTrue(isSnapshotXCTestChannelPenalized(bundleId: "com.example.app"))
+
+    clearSnapshotXCTestChannelPenalty(reason: "target_process_changed")
+
+    XCTAssertFalse(isSnapshotXCTestChannelPenalized(bundleId: "com.example.app"))
+  }
+
+  func testCachedTargetInvalidationClearsProcessBoundState() {
+    currentApp = app
+    currentBundleId = "com.example.app"
+    currentAppProcessIdentifier = 42
+    snapshotXCTestPenaltyWarmupExemptionPending = true
+
+    invalidateCachedTarget(reason: "unit_test")
+
+    XCTAssertNil(currentApp)
+    XCTAssertNil(currentBundleId)
+    XCTAssertNil(currentAppProcessIdentifier)
+    XCTAssertFalse(snapshotXCTestPenaltyWarmupExemptionPending)
+  }
+}
diff --git a/apple-runner/AgentDeviceRunner/AgentDeviceRunnerUITests/RunnerTests+Models.swift b/apple-runner/AgentDeviceRunner/AgentDeviceRunnerUITests/RunnerTests+Models.swift
index 1a3839042..912118085 100644
--- a/apple-runner/AgentDeviceRunner/AgentDeviceRunnerUITests/RunnerTests+Models.swift
+++ b/apple-runner/AgentDeviceRunner/AgentDeviceRunnerUITests/RunnerTests+Models.swift
@@ -24,10 +24,9 @@ enum CommandType: String, Codable {
   case keyboardDismiss
   case keyboardReturn
   case alert
-  case pinch
   case sequence
-  case rotateGesture
-  case transformGesture
+  case gesture
+  case gestureViewport
   case recordStart
   case recordStop
   case status
@@ -35,12 +34,6 @@ enum CommandType: String, Codable {
   case shutdown
 }
 
-enum SynthesizedDragSemantics: String, Codable {
-  case swipe
-  case pan
-  case fling
-}
-
 /// Runner command traits — see CONTEXT.md ("Runner command traits").
 ///
 /// Single source of truth for how the runner classifies a command across three
@@ -80,11 +73,11 @@ extension CommandType {
     // .sequence is the fused multi-step gesture batch.
     case .tap, .longPress, .drag, .remotePress, .type, .swipe, .scroll, .desktopScroll,
          .back, .backInApp, .backSystem, .rotate, .appSwitcher,
-         .keyboardDismiss, .keyboardReturn, .pinch, .sequence, .rotateGesture, .transformGesture:
+         .keyboardDismiss, .keyboardReturn, .sequence, .gesture:
       return CommandTraits(isInteraction: true, readOnly: .never, isLifecycle: false)
 
     // Read-only reads: eligible for the session-invalidating retry.
-    case .findText, .readText, .snapshot:
+    case .findText, .readText, .snapshot, .gestureViewport:
       return CommandTraits(isInteraction: false, readOnly: .always, isLifecycle: false)
 
     // Screenshot is both a read and a runner-lifecycle command (skips app-activation preflight).
@@ -132,16 +125,12 @@ struct Command: Codable {
   let remoteButton: String?
   let x2: Double?
   let y2: Double?
-  let dx: Double?
-  let dy: Double?
   let durationMs: Double?
   let direction: String?
   let amount: Double?
   let pixels: Double?
   let orientation: String?
-  let scale: Double?
-  let degrees: Double?
-  let velocity: Double?
+  let gesturePlan: RunnerGesturePlan?
   let outPath: String?
   let fps: Int?
   let maxSize: Int?
@@ -151,11 +140,40 @@ struct Command: Codable {
   let raw: Bool?
   let fullscreen: Bool?
   let synthesized: Bool?
-  /// Preserves the public gesture's timing semantics after it is lowered to runner `drag`.
-  let dragSemantics: SynthesizedDragSemantics?
   let steps: [SequenceStep]?
 }
 
+/// Canonical one- or two-pointer plan produced by the portable TypeScript planner.
+struct RunnerGesturePlan: Codable {
+  let topology: String
+  let intent: String
+  let durationMs: Double
+  let viewport: RunnerGestureViewport
+  let pointers: [RunnerGesturePointer]
+}
+
+struct RunnerGestureViewport: Codable {
+  let x: Double
+  let y: Double
+  let width: Double
+  let height: Double
+}
+
+struct RunnerGesturePointer: Codable {
+  let pointerId: Int
+  let samples: [RunnerGestureSample]
+}
+
+struct RunnerGestureSample: Codable {
+  let offsetMs: Double
+  let point: RunnerGesturePoint
+}
+
+struct RunnerGesturePoint: Codable {
+  let x: Double
+  let y: Double
+}
+
 /// One allowlisted coordinate gesture step inside a fused `sequence` command.
 /// `kind` is decoded as a raw String (not an enum) so the runner can return a clear
 /// INVALID_ARGS for an unknown kind instead of a generic decode failure.
@@ -163,15 +181,11 @@ struct SequenceStep: Codable {
   let kind: String
   let x: Double?
   let y: Double?
-  let x2: Double?
-  let y2: Double?
   let durationMs: Double?
   let pauseMs: Double?
-  /// For `tap`/`drag` steps on iOS non-tv: use the synthesized HID fast path instead of the
+  /// For `tap` steps on iOS non-tv: use the synthesized HID fast path instead of the
   /// drag-based XCUICoordinate path, matching the individual command behavior.
   let synthesized: Bool?
-  /// Preserves one-shot swipe timing when repeated swipes are fused into a sequence.
-  let dragSemantics: SynthesizedDragSemantics?
 }
 
 /// Per-step result for a `sequence` response. `ok:false` carries the failing step's
diff --git a/apple-runner/AgentDeviceRunner/AgentDeviceRunnerUITests/RunnerTests+SequenceExecution.swift b/apple-runner/AgentDeviceRunner/AgentDeviceRunnerUITests/RunnerTests+SequenceExecution.swift
index 53c64480d..fc20b2ad7 100644
--- a/apple-runner/AgentDeviceRunner/AgentDeviceRunnerUITests/RunnerTests+SequenceExecution.swift
+++ b/apple-runner/AgentDeviceRunner/AgentDeviceRunnerUITests/RunnerTests+SequenceExecution.swift
@@ -9,7 +9,7 @@ extension RunnerTests {
 
   /// Allowlisted step kinds. Validated on both sides so an unsupported kind is rejected with a
   /// clear INVALID_ARGS naming the step index, executing nothing.
-  private var sequenceableStepKinds: Set<String> { ["tap", "doubleTap", "longPress", "drag"] }
+  private var sequenceableStepKinds: Set<String> { ["tap", "doubleTap", "longPress"] }
 
   /// Per-step outcome carried by `assembleSequenceExecution`. The timing is captured by the
   /// executor closure (via performGesture) so ordering/stop-on-failure stay device-free testable.
@@ -127,17 +127,12 @@ extension RunnerTests {
   private func validateSequenceStep(_ step: SequenceStep, index: Int) -> Response? {
     guard sequenceableStepKinds.contains(step.kind) else {
       return sequenceInvalidArgs(
-        "sequence step \(index) has unsupported kind \"\(step.kind)\"; allowed: tap, doubleTap, longPress, drag"
+        "sequence step \(index) has unsupported kind \"\(step.kind)\"; allowed: tap, doubleTap, longPress"
       )
     }
     guard let x = step.x, let y = step.y, x.isFinite, y.isFinite else {
       return sequenceInvalidArgs("sequence step \(index) (\(step.kind)) requires finite x and y")
     }
-    if step.kind == "drag" {
-      guard let x2 = step.x2, let y2 = step.y2, x2.isFinite, y2.isFinite else {
-        return sequenceInvalidArgs("sequence step \(index) (drag) requires finite x2 and y2")
-      }
-    }
     return nil
   }
 
@@ -194,92 +189,6 @@ extension RunnerTests {
 #endif
       // Synthesis unsupported (e.g. macOS) — fall through to the drag-based tapAt below.
     }
-    if step.kind == "drag", step.synthesized == true {
-      let policyKind = SynthesizedGesturePolicyKind.synthesizedDrag
-      let dragPoints: DragPoints
-      let dragContext: SynthesizedCoordinateContext?
-#if os(iOS)
-      guard let dragPlan = axFreeSynthesizedDragPlan(
-        app: activeApp,
-        x: x,
-        y: y,
-        x2: step.x2 ?? x,
-        y2: step.y2 ?? y,
-        context: synthesizedContext
-      ) else {
-        let nowMs = ProcessInfo.processInfo.systemUptime * 1000
-        logSynthesizedGesturePolicyDecision(kind: policyKind, context: synthesizedContext, fallbackAttempted: false)
-        return SequenceStepOutcome(
-          outcome: .unsupported(
-            message: "synthesized coordinate drag could not resolve a finite coordinate frame",
-            hint: "Retry after the app is foregrounded, or use a plain screenshot to choose coordinates."
-          ),
-          gestureStartUptimeMs: nowMs,
-          gestureEndUptimeMs: nowMs
-        )
-      }
-      dragPoints = dragPlan.points
-      dragContext = dragPlan.context
-#else
-      dragPoints = keyboardAvoidingDragPoints(
-        app: activeApp, x: x, y: y, x2: step.x2 ?? x, y2: step.y2 ?? y)
-      dragContext = nil
-#endif
-      let durationMs = min(max(step.durationMs ?? 250, 16), 10000)
-      let (timing, outcome) = performGesture(activeApp, idleTimeout: false) {
-        synthesizedDragAt(
-          app: activeApp,
-          x: dragPoints.x,
-          y: dragPoints.y,
-          x2: dragPoints.x2,
-          y2: dragPoints.y2,
-          durationMs: durationMs,
-          semantics: step.dragSemantics,
-          context: dragContext
-        )
-      }
-      if case .performed = outcome {
-        logSynthesizedGesturePolicyDecision(kind: policyKind, context: dragContext, fallbackAttempted: false)
-        if let pauseMs = step.pauseMs, pauseMs > 0 {
-          sleepFor(min(max(pauseMs, 0), 10000) / 1000.0)
-        }
-        return SequenceStepOutcome(
-          outcome: outcome,
-          gestureStartUptimeMs: timing.gestureStartUptimeMs,
-          gestureEndUptimeMs: timing.gestureEndUptimeMs
-        )
-      }
-#if os(iOS)
-      guard dragContext?.allowsXCTestCoordinateFallback == true else {
-        logSynthesizedGesturePolicyDecision(kind: policyKind, context: dragContext, fallbackAttempted: false)
-        return SequenceStepOutcome(
-          outcome: outcome,
-          gestureStartUptimeMs: timing.gestureStartUptimeMs,
-          gestureEndUptimeMs: timing.gestureEndUptimeMs
-        )
-      }
-#endif
-      logSynthesizedGesturePolicyDecision(kind: policyKind, context: dragContext, fallbackAttempted: true)
-      let fallbackHoldDuration = synthesizedSwipeFallbackHoldDuration(durationMs: step.durationMs ?? 250)
-      let (fallbackTiming, fallbackOutcome) = performGesture(activeApp) {
-        dragAt(
-          app: activeApp,
-          x: dragPoints.x,
-          y: dragPoints.y,
-          x2: dragPoints.x2,
-          y2: dragPoints.y2,
-          holdDuration: fallbackHoldDuration
-        )
-      }
-      if case .performed = fallbackOutcome, let pauseMs = step.pauseMs, pauseMs > 0 {
-        sleepFor(min(max(pauseMs, 0), 10000) / 1000.0)
-      }
-      return SequenceStepOutcome(
-        outcome: fallbackOutcome,
-        gestureStartUptimeMs: fallbackTiming.gestureStartUptimeMs,
-        gestureEndUptimeMs: fallbackTiming.gestureEndUptimeMs
-      )
-    }
     let (timing, outcome) = performGesture(activeApp) {
       switch step.kind {
       case "doubleTap":
@@ -288,20 +197,6 @@ extension RunnerTests {
       case "longPress":
         let duration = min(max(step.durationMs ?? 800, 16), 10000) / 1000.0
         return longPressAt(app: activeApp, x: x, y: y, duration: duration)
-      case "drag":
-        // Route through keyboardAvoidingDragPoints for parity with the individual `.drag` command.
-        // The non-synthesized coordinate-drag path ignores durationMs, matching that command's
-        // non-synthesized branch.
-        let dragPoints = keyboardAvoidingDragPoints(
-          app: activeApp, x: x, y: y, x2: step.x2 ?? x, y2: step.y2 ?? y)
-        return dragAt(
-          app: activeApp,
-          x: dragPoints.x,
-          y: dragPoints.y,
-          x2: dragPoints.x2,
-          y2: dragPoints.y2,
-          holdDuration: coordinateDragHoldDuration()
-        )
       default:
         return tapAt(app: activeApp, x: x, y: y)
       }
@@ -354,17 +249,15 @@ extension RunnerTests {
     {"command":"sequence","commandId":"seq-1","steps":[
       {"kind":"tap","x":100,"y":200},
       {"kind":"doubleTap","x":101,"y":200},
-      {"kind":"longPress","x":102,"y":200,"durationMs":300},
-      {"kind":"drag","x":10,"y":600,"x2":10,"y2":200,"durationMs":250,"pauseMs":50}
+      {"kind":"longPress","x":102,"y":200,"durationMs":300,"pauseMs":50}
     ]}
     """
     let command = try JSONDecoder().decode(Command.self, from: Data(json.utf8))
     XCTAssertEqual(command.command, .sequence)
-    XCTAssertEqual(command.steps?.count, 4)
+    XCTAssertEqual(command.steps?.count, 3)
     XCTAssertEqual(command.steps?[0].kind, "tap")
     XCTAssertEqual(command.steps?[1].kind, "doubleTap")
-    XCTAssertEqual(command.steps?[3].x2, 10)
-    XCTAssertEqual(command.steps?[3].pauseMs, 50)
+    XCTAssertEqual(command.steps?[2].pauseMs, 50)
   }
 
   func testSequenceAcceptsDoubleTapKind() {
@@ -404,21 +297,10 @@ extension RunnerTests {
     XCTAssertTrue(response.error?.message.contains("at most 20") ?? false)
   }
 
-  func testSequenceRejectsDragMissingSecondPoint() {
-    let response = executeSequenceForTest(steps: [
-      sequenceStep(kind: "tap", x: 1, y: 2),
-      sequenceStep(kind: "drag", x: 3, y: 4),
-    ])
-    XCTAssertEqual(response.ok, false)
-    XCTAssertEqual(response.error?.code, "INVALID_ARGS")
-    XCTAssertTrue(response.error?.message.contains("step 1") ?? false)
-  }
-
   func testSequenceHasSynthesizedCoordinateStep() {
     XCTAssertTrue(
       sequenceHasSynthesizedCoordinateStep([
         sequenceStep(kind: "tap", x: 1, y: 2, synthesized: true),
-        sequenceStep(kind: "drag", x: 1, y: 2, x2: 3, y2: 4, synthesized: true),
       ])
     )
     XCTAssertFalse(
@@ -455,7 +337,7 @@ extension RunnerTests {
   func testAssembleSequenceStopsAtFirstFailure() {
     let steps = [
       sequenceStep(kind: "tap", x: 1, y: 1),
-      sequenceStep(kind: "drag", x: 2, y: 2),
+      sequenceStep(kind: "longPress", x: 2, y: 2),
       sequenceStep(kind: "tap", x: 3, y: 3),
     ]
     var calls: [Int] = []
@@ -463,7 +345,7 @@ extension RunnerTests {
       calls.append(index)
       if index == 1 {
         return SequenceStepOutcome(
-          outcome: .unsupported(message: "drag unsupported", hint: nil),
+          outcome: .unsupported(message: "long press unsupported", hint: nil),
           gestureStartUptimeMs: 10,
           gestureEndUptimeMs: 15
         )
@@ -478,7 +360,7 @@ extension RunnerTests {
     XCTAssertEqual(execution.results.count, 2)
     XCTAssertEqual(execution.results[1].ok, false)
     XCTAssertEqual(execution.results[1].errorCode, "UNSUPPORTED_OPERATION")
-    XCTAssertEqual(execution.results[1].errorMessage, "drag unsupported")
+    XCTAssertEqual(execution.results[1].errorMessage, "long press unsupported")
   }
 
   func testSequenceWorstCaseResponseStaysUnderJournalCap() throws {
@@ -486,7 +368,7 @@ extension RunnerTests {
     let results = (0..<20).map { index in
       SequenceStepResult(
         ok: index < 19,
-        kind: "drag",
+        kind: "longPress",
         errorCode: index < 19 ? nil : "UNSUPPORTED_OPERATION",
         errorMessage: index < 19 ? nil : longMessage,
         gestureStartUptimeMs: 123456.789,
@@ -510,21 +392,15 @@ extension RunnerTests {
     kind: String,
     x: Double?,
     y: Double? = nil,
-    x2: Double? = nil,
-    y2: Double? = nil,
-    synthesized: Bool? = nil,
-    dragSemantics: SynthesizedDragSemantics? = nil
+    synthesized: Bool? = nil
   ) -> SequenceStep {
     SequenceStep(
       kind: kind,
       x: x,
       y: y,
-      x2: x2,
-      y2: y2,
       durationMs: nil,
       pauseMs: nil,
-      synthesized: synthesized,
-      dragSemantics: dragSemantics
+      synthesized: synthesized
     )
   }
 
diff --git a/apple-runner/AgentDeviceRunner/AgentDeviceRunnerUITests/RunnerTests+SnapshotCapturePlan.swift b/apple-runner/AgentDeviceRunner/AgentDeviceRunnerUITests/RunnerTests+SnapshotCapturePlan.swift
index a217496e8..d0d168441 100644
--- a/apple-runner/AgentDeviceRunner/AgentDeviceRunnerUITests/RunnerTests+SnapshotCapturePlan.swift
+++ b/apple-runner/AgentDeviceRunner/AgentDeviceRunnerUITests/RunnerTests+SnapshotCapturePlan.swift
@@ -118,6 +118,17 @@ extension RunnerTests {
     )
   }
 
+  func clearSnapshotXCTestChannelPenalty(reason: String) {
+    snapshotXCTestChannelPenaltyLock.lock()
+    let hadActivePenalty = Date() < snapshotXCTestChannelPenaltyUntil
+    snapshotXCTestChannelPenaltyBundleId = nil
+    snapshotXCTestChannelPenaltyUntil = Date.distantPast
+    snapshotXCTestChannelPenaltyLock.unlock()
+    if hadActivePenalty {
+      NSLog("AGENT_DEVICE_RUNNER_SNAPSHOT_XCTEST_CHANNEL_PENALTY_CLEARED reason=%@", reason)
+    }
+  }
+
   func isSnapshotXCTestChannelPenalized(bundleId: String?) -> Bool {
     snapshotXCTestChannelPenaltyLock.lock()
     defer { snapshotXCTestChannelPenaltyLock.unlock() }
@@ -127,6 +138,12 @@ extension RunnerTests {
     return penalized == bundleId
   }
 
+  func consumeSnapshotXCTestPenaltyWarmupExemption() -> Bool {
+    let pending = snapshotXCTestPenaltyWarmupExemptionPending
+    snapshotXCTestPenaltyWarmupExemptionPending = false
+    return pending
+  }
+
   /// Pure plan-reorder rule: a penalized XCTest accessibility channel uses independent backends
   /// when the platform has one, otherwise it keeps XCTest work on a short probe. The raw
   /// diagnostic plan keeps tree-first errors, and unknown plans are left untouched.
@@ -174,6 +191,7 @@ extension RunnerTests {
     var firstFailure: (reason: String, code: String)?
     var axFailure: SnapshotCaptureFailure?
     let deadline = Date().addingTimeInterval(Self.snapshotPlanBudget)
+    let suppressXCTestPenalty = consumeSnapshotXCTestPenaltyWarmupExemption()
 
     // Reorder is iOS-only because hostile screens can make XCTest tree/query work grind while
     // the app remains visually responsive. Simulators can avoid that channel through private AX;
@@ -237,14 +255,30 @@ extension RunnerTests {
             treeCaptureSliceBudgetOverride: effective.treeCaptureSliceBudgetOverride
           )
         else {
-          recordSlowXCTestSnapshotBackendIfNeeded(kind, startedAt: backendStartedAt)
+          recordSlowXCTestSnapshotBackendIfNeeded(
+            kind,
+            startedAt: backendStartedAt,
+            penaltySuppressed: suppressXCTestPenalty
+          )
           continue
         }
         capture = result
-        recordSlowXCTestSnapshotBackendIfNeeded(kind, startedAt: backendStartedAt)
+        recordSlowXCTestSnapshotBackendIfNeeded(
+          kind,
+          startedAt: backendStartedAt,
+          penaltySuppressed: suppressXCTestPenalty
+        )
       } catch let failure as SnapshotCaptureFailure {
-        recordXCTestSnapshotBackendFailureIfNeeded(kind, failure: failure)
-        recordSlowXCTestSnapshotBackendIfNeeded(kind, startedAt: backendStartedAt)
+        recordXCTestSnapshotBackendFailureIfNeeded(
+          kind,
+          failure: failure,
+          penaltySuppressed: suppressXCTestPenalty
+        )
+        recordSlowXCTestSnapshotBackendIfNeeded(
+          kind,
+          startedAt: backendStartedAt,
+          penaltySuppressed: suppressXCTestPenalty
+        )
         if Self.isAxSnapshotFailure(failure) { axFailure = failure }
         if firstFailure == nil {
           firstFailure = (failure.message, Self.isAxSnapshotFailure(failure) ? "ax-rejected" : "capture-failed")
@@ -313,7 +347,12 @@ extension RunnerTests {
 
   /// Marks XCTest-backed snapshot tiers as penalized when one attempt ground past the slow-capture
   /// threshold — even a successful one: the next capture of this screen must not re-grind.
-  private func recordSlowXCTestSnapshotBackendIfNeeded(_ kind: SnapshotBackendKind, startedAt: Date) {
+  private func recordSlowXCTestSnapshotBackendIfNeeded(
+    _ kind: SnapshotBackendKind,
+    startedAt: Date,
+    penaltySuppressed: Bool
+  ) {
+    guard !penaltySuppressed else { return }
     guard kind.usesXCTestAccessibilityChannel else { return }
     let elapsed = Date().timeIntervalSince(startedAt)
     guard elapsed > snapshotXCTestSlowCaptureThreshold else { return }
@@ -325,8 +364,10 @@ extension RunnerTests {
 
   private func recordXCTestSnapshotBackendFailureIfNeeded(
     _ kind: SnapshotBackendKind,
-    failure: SnapshotCaptureFailure
+    failure: SnapshotCaptureFailure,
+    penaltySuppressed: Bool
   ) {
+    guard !penaltySuppressed else { return }
     guard kind.usesXCTestAccessibilityChannel, failure.code == Self.xCTestSnapshotTimeoutCode else { return }
     penalizeSnapshotXCTestChannel(
       bundleId: currentBundleId,
diff --git a/apple-runner/AgentDeviceRunner/AgentDeviceRunnerUITests/RunnerTests+SynthesizedGesturePolicy.swift b/apple-runner/AgentDeviceRunner/AgentDeviceRunnerUITests/RunnerTests+SynthesizedGesturePolicy.swift
index 878e693cc..0978b7252 100644
--- a/apple-runner/AgentDeviceRunner/AgentDeviceRunnerUITests/RunnerTests+SynthesizedGesturePolicy.swift
+++ b/apple-runner/AgentDeviceRunner/AgentDeviceRunnerUITests/RunnerTests+SynthesizedGesturePolicy.swift
@@ -103,7 +103,7 @@ func synthesizedGesturePolicy(_ kind: SynthesizedGesturePolicyKind) -> Synthesiz
 
 func sequenceHasSynthesizedCoordinateStep(_ steps: [SequenceStep]) -> Bool {
   steps.contains { step in
-    step.synthesized == true && (step.kind == "tap" || step.kind == "drag")
+    step.synthesized == true && step.kind == "tap"
   }
 }
 
diff --git a/apple-runner/AgentDeviceRunner/AgentDeviceRunnerUITests/RunnerTests.swift b/apple-runner/AgentDeviceRunner/AgentDeviceRunnerUITests/RunnerTests.swift
index 768683eb2..d1f6752ac 100644
--- a/apple-runner/AgentDeviceRunner/AgentDeviceRunnerUITests/RunnerTests.swift
+++ b/apple-runner/AgentDeviceRunner/AgentDeviceRunnerUITests/RunnerTests.swift
@@ -38,6 +38,7 @@ final class RunnerTests: XCTestCase {
   lazy var springboard = XCUIApplication(bundleIdentifier: Self.springboardBundleId)
   var currentApp: XCUIApplication?
   var currentBundleId: String?
+  var currentAppProcessIdentifier: Int?
   let maxRequestBytes = 2 * 1024 * 1024
   let mainThreadExecutionTimeout: TimeInterval = 30
   let appExistenceTimeout: TimeInterval = 30
@@ -76,6 +77,7 @@ final class RunnerTests: XCTestCase {
   var snapshotXCTestChannelPenaltyBundleId: String?
   var snapshotXCTestChannelPenaltyUntil = Date.distantPast
   let snapshotXCTestChannelPenaltyDuration: TimeInterval = 120
+  var snapshotXCTestPenaltyWarmupExemptionPending = false
   // Bluesky-class screens can grind ~4-8s before an XCTest-backed snapshot tier fails; anything
   // past this threshold marks the screen hostile so the next capture uses non-XCTest recovery.
   let snapshotXCTestSlowCaptureThreshold: TimeInterval = 3
diff --git a/docs/adr/0008-command-descriptor-registry.md b/docs/adr/0008-command-descriptor-registry.md
index 793150ae9..4564f4b97 100644
--- a/docs/adr/0008-command-descriptor-registry.md
+++ b/docs/adr/0008-command-descriptor-registry.md
@@ -77,7 +77,7 @@ As of 2026-07, the descriptor registry is live for command identity (`PUBLIC_COM
 `INTERNAL_COMMANDS`, and local CLI names), daemon registry traits, capability matrix,
 structured-batch allowlist, daemon-client timeout policy, MCP exposure list,
 capability-checked CLI command list, post-action observation traits, and the platform dispatch
-command set (including dispatch-only aliases such as `read` and `swipe-preset`). Command-family
+command set (including the remaining dispatch-only alias `read`). Command-family
 surface metadata still lives under `src/commands/**`, where the CLI grammar and client-backed
 executors already live, but it is coherence-guarded against the descriptor CLI catalog so new
 surface names cannot drift from the descriptor root.
diff --git a/docs/adr/0011-interaction-guarantee-contract.md b/docs/adr/0011-interaction-guarantee-contract.md
index 1e649795d..80c3fbed8 100644
--- a/docs/adr/0011-interaction-guarantee-contract.md
+++ b/docs/adr/0011-interaction-guarantee-contract.md
@@ -266,6 +266,11 @@ dimensions as their only frame source; cheaper frame sources such as
 intentionally excluded because they can diverge from full-screen screenshot
 coordinates on affected simulators.
 
+Two-contact pan/pinch/rotate/transform planning is now owned by the typed
+gesture-plan contract in [ADR 0013](0013-unified-gesture-plans.md). It remains a
+sibling of this element-targeting matrix: coordinate gestures do not acquire
+selector/ref guarantees merely because their native executor uses XCTest.
+
 ## Migration plan
 
 Each step lands green and independently useful:
diff --git a/docs/adr/0013-unified-gesture-plans.md b/docs/adr/0013-unified-gesture-plans.md
new file mode 100644
index 000000000..ee35b36fa
--- /dev/null
+++ b/docs/adr/0013-unified-gesture-plans.md
@@ -0,0 +1,109 @@
+# ADR 0013: Unified Gesture Plans
+
+## Status
+
+Accepted
+
+## Context
+
+Gesture intent was previously interpreted at several private boundaries: command aliases produced
+positional strings, daemon dispatch reparsed them, the `Interactor` exposed parallel semantic
+methods, and each platform derived its own two-contact geometry. That duplicated validation,
+responses, and behavior behind the three public surfaces: CLI, Node.js, and MCP.
+
+Two-contact geometry also differed by platform. Android used a fixed radius while Apple derived a
+radius from the app frame. Neither path validated every planned point against the active
+interaction viewport before injection.
+
+`scroll` remains separate because it owns viewport/edge traversal, content-state verification, and
+runner fallback policy rather than a single physical gesture.
+
+## Decision
+
+Public gesture inputs normalize once in `src/contracts/gesture-normalization.ts`. This is the
+explicit compatibility boundary: convenience APIs and deprecated arguments become canonical
+semantic intent before entering the runtime. The private daemon wire is free to evolve with that
+model; compatibility is owed at CLI, Node.js, and MCP.
+
+The runtime plans canonical intent in `src/contracts/gesture-plan.ts`. Contact topology is separate
+from motion:
+
+- one contact: pan or fling with a complete pointer trajectory;
+- two contacts: pan, pinch, rotate, or transform with two complete, synchronized trajectories.
+
+`swipe` is public sugar for a fixed-duration fling. Its historical optional duration remains a
+thin compatibility alias to pan and reports a deprecation. The same rule applies to the historical
+fling duration. Pinch fixes translation and rotation at zero; rotate fixes translation at zero and
+scale at one; two-finger pan fixes scale at one and rotation at zero; transform can apply all three
+components atomically. Intent remains on the plan even when aliases share an executor.
+
+The planner owns deterministic multi-touch geometry. Contacts start at -90 degrees, except Android
+pinch starts horizontally because a vertical pinch is captured by common vertical app scroll
+containers before the pinch recognizer activates. The same explicit planning profile preserves the
+proven frame-count convention: Android rounds while Apple truncates the duration/16 ms frame count.
+These are planner inputs, not adapter-generated trajectories. The larger of pinch's initial and final spans is 40% of the
+viewport's shorter side, preserving the proven Apple pinch geometry; other two-contact intents use
+25% to keep translation and rotation trajectories compact. The other span follows from the requested scale, and both must
+satisfy a 48-point reliability floor. Combined transforms progress translation, scale, and rotation
+together inside one uninterrupted two-contact sequence so recognizers observe every intent without an
+adapter regenerating geometry. The planner does not clamp points, cache the viewport, or distort
+the requested components. Every injected sample must fit the freshly resolved active-app
+interaction viewport; otherwise the request fails before injection with
+`GESTURE_TRAJECTORY_OUT_OF_BOUNDS` and actionable details. Span and angle remain internal because
+no established automation use case justifies a public tuning surface.
+
+Platform adapters consume the canonical plan:
+
+- Android sends the plan to provider-native touch injection when available, otherwise to the
+  bundled instrumentation helper. The helper injects the exact planned pointer samples. A
+  two-contact plan never falls back to `adb input swipe`; issue #690 separately owns removal of the
+  existing one-contact fallback. The snapshot helper is stopped before local gesture
+  instrumentation because Android permits only one instrumentation owner of `UiAutomation`.
+- iOS converts every planned point to native orientation and feeds the exact arrays to the existing
+  private XCTest event bridge. macOS lowers a one-contact plan to its drag executor and tvOS lowers
+  it to remote direction. Core admission and the Apple adapter both consume the same shared
+  multi-touch support policy; multi-touch remains capability-gated to iOS simulators.
+- WebDriver lowers a supported plan to synchronized W3C pointer action sources. Multi-touch remains
+  capability-gated until a provider proves it.
+
+The `Interactor` and backend expose one compositional `performGesture(plan)` primitive instead of a
+method per semantic alias. The old scalar Apple and Android multi-touch executors and the
+public-command alias-to-positionals-to-reparse route are deleted. `.ad` keeps its established
+positional syntax through one named replay compatibility codec; CLI, Node.js, and MCP send
+structured input. Providers should compose transport/device bindings with the shared platform
+adapter rather than reimplement the interaction runtime.
+
+Repeated coordinate swipes are bounded at the public command contract and daemon trust boundary.
+Individual count and pause limits prevent pathological fields, while the combined planned gesture
+and pause schedule must fit within 60 seconds so valid fields cannot compose into an unbounded
+session lock.
+
+Public two-finger pan is additive: `pointerCount?: 1 | 2` on pan and CLI
+`--pointer-count 2`; omission remains one contact. Responses share the canonical
+`kind`, `durationMs`, `pointerCount`, `from`, and `to` fields, followed by backend evidence.
+Recording/replay keeps its existing public command identity and session semantics.
+
+ADR 0011's element dispatch-path matrix remains unchanged: coordinate gestures do not resolve
+selectors or refs and therefore cannot claim element-targeting guarantees.
+
+## Consequences
+
+- CLI, Node.js, MCP, runtime, and platform adapters share one normalization and planning model.
+- Adding an ergonomic gesture alias does not add a platform implementation.
+- One-finger pan remains the default and explicit two-finger pan retains pan intent.
+- The active viewport is resolved for each gesture, so rotation, keyboard, and window changes do
+  not use stale geometry.
+- Pointer plans are larger than scalar requests but bounded by duration and the 16 ms sample
+  cadence; deleting duplicate scalar executors offsets the package cost.
+
+## Alternatives Considered
+
+- Keep positional aliases and share only geometry math: rejected because validation, response, and
+  routing would still have two implementations.
+- Make platform gesture APIs the source of truth: rejected because their timing, geometry, and
+  recognizer behavior differ and cannot provide cross-platform semantics.
+- Make swipe a public synonym for pan: rejected because battle-tested gesture vocabulary treats a
+  fling/swipe as a quick directional throw and pan as deliberate timed translation.
+- Add `two-finger-pan`: rejected because pointer count is topology, not a new motion intent.
+- Expose span/angle controls: rejected until a concrete automation use case needs them.
+- Consolidate scroll: rejected because edge/content verification and fallback policy are distinct.
diff --git a/docs/adr/README.md b/docs/adr/README.md
index a15149ffd..79caf7955 100644
--- a/docs/adr/README.md
+++ b/docs/adr/README.md
@@ -14,6 +14,7 @@
 | [0010 Error system conventions](0010-error-system.md) | error codes, hints, normalizeError, typed error signals |
 | [0011 Interaction Guarantee Contract](0011-interaction-guarantee-contract.md) | interaction dispatch paths, fast paths, guards, the guarantee matrix, parity tables |
 | [0012 Interactive Replay](0012-interactive-replay.md) | replay healing/`--update`, diagnostic resolution disclosure, bounded `.ad` target-binding evidence, bounded divergence wire/error handling, plan-bound replay-only `--from` semantics, and agent-supervised re-record repair ("heal-by-doing") |
+| [0013 Unified Gesture Plans](0013-unified-gesture-plans.md) | gesture API/routing, contact topology, multi-touch geometry, native pointer injection, two-finger pan |
 
 ADRs record *why*; the registries and gates they describe are the living source of truth — when
 prose and a registry disagree, the registry wins and the ADR needs a follow-up.
diff --git a/examples/test-app/README.md b/examples/test-app/README.md
index 583f879e6..57e787619 100644
--- a/examples/test-app/README.md
+++ b/examples/test-app/README.md
@@ -178,11 +178,16 @@ pnpm test-app:replay:android
 
 These run the `.ad` replay suite in `examples/test-app/replays`.
 
-`gesture-lab.ad` verifies `gesture pan`, `gesture fling`, `gesture pinch`, and
-`gesture rotate` against the gesture metrics rendered by the Home screen on iOS
-and Android. Android and iOS simulator sessions also support `gesture transform`
-for a combined pan/zoom/rotate gesture. On Android, treat combined transform
-assertions as qualitative because recognizers can report non-exact centroid,
+The iOS `gesture-lab.ad` and Android `gesture-lab-android.ad` replays verify
+`gesture pan`, `gesture fling`, `gesture pinch`, and `gesture rotate` against the
+gesture metrics rendered by the Home screen. They also prove that the default pan
+does not activate an exactly-two-pointer recognizer, while
+`gesture pan ... --pointer-count 2` does without changing pinch or rotation state.
+
+Each gesture replay relaunches the app before its combined `gesture transform`
+canary, verifies the clean pan/pinch/rotate state, then checks that one atomic
+two-pointer gesture changes all three semantic states. On Android, these checks
+are intentionally qualitative because recognizers can report non-exact centroid,
 scale, and rotation values for one simultaneous two-finger gesture.
 
 To target a specific iOS simulator or an installed Expo development build, run the
diff --git a/examples/test-app/app.config.js b/examples/test-app/app.config.js
index 1113b78e7..b6c2e4111 100644
--- a/examples/test-app/app.config.js
+++ b/examples/test-app/app.config.js
@@ -5,6 +5,7 @@ module.exports = {
   expo: {
     name: 'Agent Device Tester',
     slug: 'agent-device-test-app',
+    scheme: 'agent-device-test-app',
     version: '1.0.0',
     orientation: 'default',
     userInterfaceStyle: 'automatic',
diff --git a/examples/test-app/package.json b/examples/test-app/package.json
index f430675d0..74db8a433 100644
--- a/examples/test-app/package.json
+++ b/examples/test-app/package.json
@@ -17,6 +17,7 @@
     "expo-constants": "56.0.18",
     "expo-dev-client": "~56.0.20",
     "expo-linking": "56.0.14",
+    "expo-modules-core": "56.0.17",
     "expo-router": "~56.2.11",
     "expo-status-bar": "~56.0.4",
     "react": "19.2.3",
diff --git a/examples/test-app/pnpm-lock.yaml b/examples/test-app/pnpm-lock.yaml
index 62c7e868f..77b0b2d11 100644
--- a/examples/test-app/pnpm-lock.yaml
+++ b/examples/test-app/pnpm-lock.yaml
@@ -37,6 +37,9 @@ importers:
       expo-linking:
         specifier: 56.0.14
         version: 56.0.14(expo@56.0.12)(react-native@0.85.3(@babel/core@7.29.0)(@react-native/metro-config@0.86.0(@babel/core@7.29.0))(@types/react@19.2.14)(react@19.2.3))(react@19.2.3)
+      expo-modules-core:
+        specifier: 56.0.17
+        version: 56.0.17(react-native-worklets@0.10.0(@babel/core@7.29.0)(@react-native/metro-config@0.86.0(@babel/core@7.29.0))(react-native@0.85.3(@babel/core@7.29.0)(@react-native/metro-config@0.86.0(@babel/core@7.29.0))(@types/react@19.2.14)(react@19.2.3))(react@19.2.3))(react-native@0.85.3(@babel/core@7.29.0)(@react-native/metro-config@0.86.0(@babel/core@7.29.0))(@types/react@19.2.14)(react@19.2.3))(react@19.2.3)
       expo-router:
         specifier: ~56.2.11
         version: 56.2.11(4e54386c19a86f18d3fced032d4d30ae)
diff --git a/examples/test-app/replays/gesture-lab-android.ad b/examples/test-app/replays/gesture-lab-android.ad
new file mode 100644
index 000000000..c3000c853
--- /dev/null
+++ b/examples/test-app/replays/gesture-lab-android.ad
@@ -0,0 +1,48 @@
+context platform=android kind=emulator timeout=60000
+
+env APP_TARGET="com.callstack.agentdevicelab"
+env APP_URL=""
+
+open "${APP_TARGET}" --relaunch --launch-url "${APP_URL}"
+react-native dismiss-overlay
+wait "Gesture lab" 30000
+wait "gesture canary ready" 5000
+wait "two-pointer pan activations 0" 5000
+
+gesture pan 350 1100 180 0 500
+wait "two-pointer pan activations 0" 5000
+
+gesture pan 350 1100 180 0 500 --pointer-count 2
+wait "two-pointer pan activations 1" 5000
+
+gesture fling left 850 1100 300
+wait "fling 1" 5000
+
+gesture fling right 750 1100 300
+wait "fling 2" 5000
+
+open "${APP_TARGET}" --relaunch --launch-url "${APP_URL}"
+react-native dismiss-overlay
+wait "gesture canary ready" 5000
+wait "pan changed no, pinch changed no, rotate changed no" 30000
+
+gesture pinch 1.5 750 1100
+wait "pan changed no, pinch changed yes, rotate changed no" 5000
+
+open "${APP_TARGET}" --relaunch --launch-url "${APP_URL}"
+react-native dismiss-overlay
+wait "gesture canary ready" 5000
+wait "pan changed no, pinch changed no, rotate changed no" 30000
+
+gesture rotate 35 750 1100
+wait "pan changed no, pinch changed no, rotate changed yes" 5000
+
+open "${APP_TARGET}" --relaunch --launch-url "${APP_URL}"
+react-native dismiss-overlay
+wait "gesture canary ready" 5000
+wait "pan changed no, pinch changed no, rotate changed no" 30000
+
+gesture transform 750 1100 60 0 1.75 30 600
+wait "pan changed yes, pinch changed yes, rotate changed yes" 5000
+
+close
diff --git a/examples/test-app/replays/gesture-lab.ad b/examples/test-app/replays/gesture-lab.ad
index 2d6b3aee5..ac3946e33 100644
--- a/examples/test-app/replays/gesture-lab.ad
+++ b/examples/test-app/replays/gesture-lab.ad
@@ -1,40 +1,47 @@
-context platform=ios timeout=60000
+context platform=ios kind=simulator timeout=180000
 
 env APP_TARGET="Agent Device Tester"
 env APP_URL=""
 
 open "${APP_TARGET}" --relaunch --launch-url "${APP_URL}"
-react-native dismiss-overlay
 wait "Gesture lab" 30000
+wait "gesture canary ready" 5000
+wait "two-pointer pan activations 0" 5000
 
-gesture fling left 195 443 180
-wait "fling 1" 5000
+gesture pan 110 443 48 0 500
+wait "two-pointer pan activations 0" 5000
 
-gesture fling right 195 443 180
-wait "fling 2" 5000
+gesture pan 110 443 48 0 500 --pointer-count 2
+wait "two-pointer pan activations 1" 5000
 
-gesture fling up 195 443 80 80
-wait "fling 3" 5000
+gesture fling left 280 443 120
+wait "fling 1" 5000
 
-gesture fling down 195 443 80 80
-wait "fling 4" 5000
+gesture fling right 280 443 120
+wait "fling 2" 5000
 
-gesture pan 195 443 -80 0
-wait "x -" 5000
+open "${APP_TARGET}" --relaunch --launch-url "${APP_URL}"
+wait "Gesture lab" 30000
+wait "gesture canary ready" 5000
+wait "pan changed no, pinch changed no, rotate changed no" 30000
 
-gesture pan 195 443 160 0
-wait "x 72" 5000
+gesture pinch 1.5 280 443
+wait "pan changed no, pinch changed yes, rotate changed no" 5000
 
-gesture pan 195 443 0 -80
-wait "y -" 5000
+open "${APP_TARGET}" --relaunch --launch-url "${APP_URL}"
+wait "Gesture lab" 30000
+wait "gesture canary ready" 5000
+wait "pan changed no, pinch changed no, rotate changed no" 30000
 
-gesture pan 195 443 0 160
-wait "y 56" 5000
+gesture rotate 35 280 443
+wait "pan changed no, pinch changed no, rotate changed yes" 5000
 
-gesture pinch 1.25 195 443
-wait "pinch changed yes" 5000
+open "${APP_TARGET}" --relaunch --launch-url "${APP_URL}"
+wait "Gesture lab" 30000
+wait "gesture canary ready" 5000
+wait "pan changed no, pinch changed no, rotate changed no" 30000
 
-gesture rotate 35 195 443
-wait "rotate changed yes" 5000
+gesture transform 280 443 24 -24 1.35 30 300
+wait "pan changed yes, pinch changed yes, rotate changed yes" 5000
 
 close
diff --git a/examples/test-app/src/screens/GestureLab.tsx b/examples/test-app/src/screens/GestureLab.tsx
index 64ba952a3..7554616fe 100644
--- a/examples/test-app/src/screens/GestureLab.tsx
+++ b/examples/test-app/src/screens/GestureLab.tsx
@@ -1,8 +1,10 @@
-import { useRef, useState } from 'react';
-import { Image, StyleSheet, Text, View } from 'react-native';
+import { useEffect, useRef, useState } from 'react';
+import { Image, Platform, Text, View, type GestureResponderEvent } from 'react-native';
 import {
   Directions,
   FlingGestureHandler,
+  Gesture,
+  GestureDetector,
   PanGestureHandler,
   PinchGestureHandler,
   RotationGestureHandler,
@@ -17,7 +19,9 @@ import {
 } from 'react-native-gesture-handler';
 
 import { SectionCard } from '../components';
-import { useAppColors, type AppColors } from '../theme';
+import { useAppColors } from '../theme';
+import { createGestureLabStyles } from './gesture-lab-styles';
+import { disableDevelopmentGestureInterceptors } from './gesture-lab-dev-menu';
 
 const gestureImageUri = 'https://reactnative.dev/img/logo-share.png';
 
@@ -30,6 +34,14 @@ type TransformState = {
 
 type GestureCounts = {
   fling: number;
+  twoPointerPan: number;
+};
+
+type AndroidTouchStart = TransformState & {
+  angle: number;
+  centroidX: number;
+  centroidY: number;
+  span: number;
 };
 
 const initialTransform: TransformState = {
@@ -41,27 +53,35 @@ const initialTransform: TransformState = {
 
 const initialCounts: GestureCounts = {
   fling: 0,
+  twoPointerPan: 0,
 };
 const minScale = 0.5;
 const maxScale = 2;
 
 export function GestureLab() {
   const colors = useAppColors();
-  const styles = createStyles(colors);
+  const styles = createGestureLabStyles(colors);
+  const [canaryReady, setCanaryReady] = useState(false);
   const [transform, setTransform] = useState<TransformState>(initialTransform);
   const [counts, setCounts] = useState<GestureCounts>(initialCounts);
   const transformRef = useRef<TransformState>(initialTransform);
   const gestureStartRef = useRef<TransformState>(initialTransform);
-  const flingDownRef = useRef(null);
-  const flingLeftRef = useRef(null);
-  const flingRightRef = useRef(null);
-  const flingUpRef = useRef(null);
-  const panRef = useRef(null);
-  const pinchRef = useRef(null);
-  const rotationRef = useRef(null);
-  const flingRefs = [flingLeftRef, flingRightRef, flingUpRef, flingDownRef];
+  const androidTouchStartRef = useRef<AndroidTouchStart | undefined>(undefined);
+  const legacyFlingDownRef = useRef(null);
+  const legacyFlingLeftRef = useRef(null);
+  const legacyFlingRightRef = useRef(null);
+  const legacyFlingUpRef = useRef(null);
+  const legacyPanRef = useRef(null);
+  const legacyPinchRef = useRef(null);
+  const legacyRotationRef = useRef(null);
   const activeTransformHandlerTagsRef = useRef(new Set<number>());
 
+  useEffect(() => {
+    void disableDevelopmentGestureInterceptors()
+      .catch(() => undefined)
+      .finally(() => setCanaryReady(true));
+  }, []);
+
   function updateTransform(nextTransform: TransformState) {
     transformRef.current = nextTransform;
     setTransform(nextTransform);
@@ -79,32 +99,43 @@ export function GestureLab() {
     activeTransformHandlerTagsRef.current.delete(handlerTag);
   }
 
-  function handlePan(event: PanGestureHandlerGestureEvent) {
+  function handlePan(translationX: number, translationY: number) {
     const start = gestureStartRef.current;
     updateTransform({
       ...transformRef.current,
-      offsetX: clamp(start.offsetX + event.nativeEvent.translationX, -72, 72),
-      offsetY: clamp(start.offsetY + event.nativeEvent.translationY, -56, 56),
+      offsetX: clamp(start.offsetX + translationX, -72, 72),
+      offsetY: clamp(start.offsetY + translationY, -56, 56),
     });
   }
 
-  function handlePinch(event: PinchGestureHandlerGestureEvent) {
+  function handlePinch(scale: number) {
     const start = gestureStartRef.current;
     updateTransform({
       ...transformRef.current,
-      scale: clamp(start.scale * event.nativeEvent.scale, minScale, maxScale),
+      scale: clamp(start.scale * scale, minScale, maxScale),
     });
   }
 
-  function handleRotation(event: RotationGestureHandlerGestureEvent) {
+  function handleRotation(rotation: number) {
     const start = gestureStartRef.current;
     updateTransform({
       ...transformRef.current,
-      rotation: start.rotation + event.nativeEvent.rotation,
+      rotation: start.rotation + rotation,
     });
   }
 
-  function handleTransformStateChange(
+  function handleFling() {
+    setCounts((current) => ({ ...current, fling: current.fling + 1 }));
+  }
+
+  function handleTwoPointerPan() {
+    setCounts((current) => ({
+      ...current,
+      twoPointerPan: current.twoPointerPan + 1,
+    }));
+  }
+
+  function handleLegacyTransformStateChange(
     event:
       | PanGestureHandlerStateChangeEvent
       | PinchGestureHandlerStateChangeEvent
@@ -112,10 +143,7 @@ export function GestureLab() {
   ) {
     if (event.nativeEvent.state === State.BEGAN) {
       beginTransformGesture(event.nativeEvent.handlerTag);
-      return;
-    }
-
-    if (
+    } else if (
       event.nativeEvent.state === State.END ||
       event.nativeEvent.state === State.FAILED ||
       event.nativeEvent.state === State.CANCELLED
@@ -124,17 +152,124 @@ export function GestureLab() {
     }
   }
 
-  function handleFling(event: FlingGestureHandlerStateChangeEvent) {
-    if (event.nativeEvent.state === State.ACTIVE) {
-      setCounts((current) => ({ ...current, fling: current.fling + 1 }));
-    }
+  function handleLegacyFling(event: FlingGestureHandlerStateChangeEvent) {
+    if (event.nativeEvent.state === State.ACTIVE) handleFling();
+  }
+
+  function handleAndroidTouchStart(event: GestureResponderEvent) {
+    const [first, second] = event.nativeEvent.touches;
+    if (!first || !second) return;
+    androidTouchStartRef.current = {
+      ...transformRef.current,
+      angle: Math.atan2(second.pageY - first.pageY, second.pageX - first.pageX),
+      centroidX: (first.pageX + second.pageX) / 2,
+      centroidY: (first.pageY + second.pageY) / 2,
+      span: Math.hypot(second.pageX - first.pageX, second.pageY - first.pageY),
+    };
+  }
+
+  function handleAndroidTouchMove(event: GestureResponderEvent) {
+    const start = androidTouchStartRef.current;
+    const [first, second] = event.nativeEvent.touches;
+    if (!start || !first || !second) return;
+    const centroidX = (first.pageX + second.pageX) / 2;
+    const centroidY = (first.pageY + second.pageY) / 2;
+    const span = Math.hypot(second.pageX - first.pageX, second.pageY - first.pageY);
+    const angle = Math.atan2(second.pageY - first.pageY, second.pageX - first.pageX);
+    updateTransform({
+      offsetX: clamp(start.offsetX + centroidX - start.centroidX, -72, 72),
+      offsetY: clamp(start.offsetY + centroidY - start.centroidY, -56, 56),
+      rotation: start.rotation + normalizedRadians(angle - start.angle),
+      scale: clamp(start.scale * (span / start.span), minScale, maxScale),
+    });
   }
 
+  const twoPointerPanGesture = Gesture.Pan()
+    .averageTouches(true)
+    .minPointers(2)
+    .maxPointers(2)
+    .minDistance(4)
+    .runOnJS(true)
+    .onStart(handleTwoPointerPan);
+  const legacyFlingRefs = [
+    legacyFlingLeftRef,
+    legacyFlingRightRef,
+    legacyFlingUpRef,
+    legacyFlingDownRef,
+  ];
+
+  const androidTransformTarget = (
+    <FlingGestureHandler
+      direction={Directions.LEFT}
+      onHandlerStateChange={handleLegacyFling}
+      ref={legacyFlingLeftRef}
+      simultaneousHandlers={[legacyPanRef, legacyPinchRef, legacyRotationRef]}
+    >
+      <FlingGestureHandler
+        direction={Directions.RIGHT}
+        onHandlerStateChange={handleLegacyFling}
+        ref={legacyFlingRightRef}
+        simultaneousHandlers={[legacyPanRef, legacyPinchRef, legacyRotationRef]}
+      >
+        <FlingGestureHandler
+          direction={Directions.UP}
+          onHandlerStateChange={handleLegacyFling}
+          ref={legacyFlingUpRef}
+          simultaneousHandlers={[legacyPanRef, legacyPinchRef, legacyRotationRef]}
+        >
+          <FlingGestureHandler
+            direction={Directions.DOWN}
+            onHandlerStateChange={handleLegacyFling}
+            ref={legacyFlingDownRef}
+            simultaneousHandlers={[legacyPanRef, legacyPinchRef, legacyRotationRef]}
+          >
+            <RotationGestureHandler
+              onGestureEvent={(event: RotationGestureHandlerGestureEvent) =>
+                handleRotation(event.nativeEvent.rotation)
+              }
+              onHandlerStateChange={handleLegacyTransformStateChange}
+              ref={legacyRotationRef}
+              simultaneousHandlers={[legacyPanRef, legacyPinchRef, ...legacyFlingRefs]}
+            >
+              <PinchGestureHandler
+                onGestureEvent={(event: PinchGestureHandlerGestureEvent) =>
+                  handlePinch(event.nativeEvent.scale)
+                }
+                onHandlerStateChange={handleLegacyTransformStateChange}
+                ref={legacyPinchRef}
+                simultaneousHandlers={[legacyPanRef, legacyRotationRef, ...legacyFlingRefs]}
+              >
+                <PanGestureHandler
+                  avgTouches
+                  maxPointers={2}
+                  minDist={4}
+                  minPointers={2}
+                  onGestureEvent={(event: PanGestureHandlerGestureEvent) =>
+                    handlePan(event.nativeEvent.translationX, event.nativeEvent.translationY)
+                  }
+                  onHandlerStateChange={handleLegacyTransformStateChange}
+                  ref={legacyPanRef}
+                  simultaneousHandlers={[legacyPinchRef, legacyRotationRef, ...legacyFlingRefs]}
+                >
+                  <View
+                    accessibilityLabel="Transform gesture target"
+                    style={styles.androidTransformTarget}
+                    testID="transform-gesture-target"
+                  />
+                </PanGestureHandler>
+              </PinchGestureHandler>
+            </RotationGestureHandler>
+          </FlingGestureHandler>
+        </FlingGestureHandler>
+      </FlingGestureHandler>
+    </FlingGestureHandler>
+  );
+
   const rotationDegrees = Math.round((transform.rotation * 180) / Math.PI);
   const statusLabel = `x ${Math.round(transform.offsetX)}, y ${Math.round(
     transform.offsetY,
   )}, scale ${transform.scale.toFixed(2)}, rotate ${rotationDegrees}`;
-  const panChanged = Math.abs(transform.offsetX) > 0 || Math.abs(transform.offsetY) > 0;
+  const panChanged = Math.abs(transform.offsetX) > 1 || Math.abs(transform.offsetY) > 1;
   const pinchChanged = Math.abs(transform.scale - 1) > 0.01;
   const rotateChanged = rotationDegrees !== 0;
   const changeStatusLabel = `pan changed ${panChanged ? 'yes' : 'no'}, pinch changed ${
@@ -147,89 +282,57 @@ export function GestureLab() {
       title="Gesture lab"
       testID="gesture-lab-card"
     >
-      <FlingGestureHandler
-        direction={Directions.LEFT}
-        onHandlerStateChange={handleFling}
-        ref={flingLeftRef}
-        simultaneousHandlers={[panRef, pinchRef, rotationRef]}
+      <View
+        accessibilityLabel="Gesture test image"
+        onTouchEnd={
+          Platform.OS === 'android' ? () => (androidTouchStartRef.current = undefined) : undefined
+        }
+        onTouchMove={Platform.OS === 'android' ? handleAndroidTouchMove : undefined}
+        onTouchStart={Platform.OS === 'android' ? handleAndroidTouchStart : undefined}
+        style={styles.target}
+        testID="gesture-target"
       >
-        <FlingGestureHandler
-          direction={Directions.RIGHT}
-          onHandlerStateChange={handleFling}
-          ref={flingRightRef}
-          simultaneousHandlers={[panRef, pinchRef, rotationRef]}
-        >
-          <FlingGestureHandler
-            direction={Directions.UP}
-            onHandlerStateChange={handleFling}
-            ref={flingUpRef}
-            simultaneousHandlers={[panRef, pinchRef, rotationRef]}
-          >
-            <FlingGestureHandler
-              direction={Directions.DOWN}
-              onHandlerStateChange={handleFling}
-              ref={flingDownRef}
-              simultaneousHandlers={[panRef, pinchRef, rotationRef]}
-            >
-              <RotationGestureHandler
-                onGestureEvent={handleRotation}
-                onHandlerStateChange={handleTransformStateChange}
-                ref={rotationRef}
-                simultaneousHandlers={[panRef, pinchRef, ...flingRefs]}
-              >
-                <PinchGestureHandler
-                  onGestureEvent={handlePinch}
-                  onHandlerStateChange={handleTransformStateChange}
-                  ref={pinchRef}
-                  simultaneousHandlers={[panRef, rotationRef, ...flingRefs]}
-                >
-                  <PanGestureHandler
-                    avgTouches
-                    minDist={4}
-                    onGestureEvent={handlePan}
-                    onHandlerStateChange={handleTransformStateChange}
-                    ref={panRef}
-                    simultaneousHandlers={[pinchRef, rotationRef, ...flingRefs]}
-                  >
-                    <View
-                      accessibilityLabel="Gesture test image"
-                      style={styles.target}
-                      testID="gesture-target"
-                    >
-                      <Image
-                        accessibilityIgnoresInvertColors
-                        accessibilityLabel="Gesture test image"
-                        resizeMode="cover"
-                        source={{ uri: gestureImageUri }}
-                        style={[
-                          styles.image,
-                          {
-                            transform: [
-                              { translateX: transform.offsetX },
-                              { translateY: transform.offsetY },
-                              { scale: transform.scale },
-                              { rotate: `${rotationDegrees}deg` },
-                            ],
-                          },
-                        ]}
-                        testID="gesture-target-image"
-                      />
-                    </View>
-                  </PanGestureHandler>
-                </PinchGestureHandler>
-              </RotationGestureHandler>
-            </FlingGestureHandler>
-          </FlingGestureHandler>
-        </FlingGestureHandler>
-      </FlingGestureHandler>
+        <Image
+          accessibilityIgnoresInvertColors
+          accessibilityLabel="Gesture test image"
+          resizeMode="cover"
+          source={{ uri: gestureImageUri }}
+          style={[
+            styles.image,
+            {
+              transform: [
+                { translateX: transform.offsetX },
+                { translateY: transform.offsetY },
+                { scale: transform.scale },
+                { rotate: `${rotationDegrees}deg` },
+              ],
+            },
+          ]}
+          testID="gesture-target-image"
+        />
+        {androidTransformTarget}
+        <GestureDetector gesture={twoPointerPanGesture}>
+          <View
+            accessibilityLabel="Exact two-pointer pan target"
+            style={styles.twoPointerTarget}
+            testID="two-pointer-pan-target"
+          />
+        </GestureDetector>
+      </View>
 
       <View style={styles.metrics} testID="gesture-metrics">
+        <Text style={styles.metric} testID="gesture-canary-ready">
+          gesture canary {canaryReady ? 'ready' : 'preparing'}
+        </Text>
         <Text style={styles.metric} testID="gesture-transform-status">
           {statusLabel}
         </Text>
         <Text style={styles.metric} testID="gesture-fling-status">
           fling {counts.fling}
         </Text>
+        <Text style={styles.metric} testID="gesture-two-pointer-pan-status">
+          two-pointer pan activations {counts.twoPointerPan}
+        </Text>
         <Text style={styles.metric} testID="gesture-change-status">
           {changeStatusLabel}
         </Text>
@@ -242,31 +345,8 @@ function clamp(value: number, min: number, max: number): number {
   return Math.min(Math.max(value, min), max);
 }
 
-function createStyles(colors: AppColors) {
-  return StyleSheet.create({
-    target: {
-      alignItems: 'center',
-      backgroundColor: colors.cardStrong,
-      borderColor: colors.line,
-      borderRadius: 4,
-      borderWidth: StyleSheet.hairlineWidth,
-      height: 220,
-      justifyContent: 'center',
-      overflow: 'hidden',
-    },
-    image: {
-      borderRadius: 4,
-      height: 160,
-      width: 240,
-    },
-    metrics: {
-      gap: 6,
-    },
-    metric: {
-      color: colors.textSoft,
-      fontSize: 13,
-      fontWeight: '600',
-      lineHeight: 18,
-    },
-  });
+function normalizedRadians(value: number): number {
+  if (value > Math.PI) return value - Math.PI * 2;
+  if (value < -Math.PI) return value + Math.PI * 2;
+  return value;
 }
diff --git a/examples/test-app/src/screens/gesture-lab-dev-menu.ts b/examples/test-app/src/screens/gesture-lab-dev-menu.ts
new file mode 100644
index 000000000..4c50d6184
--- /dev/null
+++ b/examples/test-app/src/screens/gesture-lab-dev-menu.ts
@@ -0,0 +1,21 @@
+import { requireNativeModule } from 'expo-modules-core';
+
+type DevMenuPreferencesModule = {
+  setPreferencesAsync(settings: {
+    motionGestureEnabled: boolean;
+    touchGestureEnabled: boolean;
+  }): Promise<void>;
+};
+
+/** Keep development-shell shortcuts from intercepting the gesture canary's pointer streams. */
+export async function disableDevelopmentGestureInterceptors(): Promise<void> {
+  if (!__DEV__) {
+    return;
+  }
+
+  const preferences = requireNativeModule<DevMenuPreferencesModule>('DevMenuPreferences');
+  await preferences.setPreferencesAsync({
+    motionGestureEnabled: false,
+    touchGestureEnabled: false,
+  });
+}
diff --git a/examples/test-app/src/screens/gesture-lab-styles.ts b/examples/test-app/src/screens/gesture-lab-styles.ts
new file mode 100644
index 000000000..121a2649c
--- /dev/null
+++ b/examples/test-app/src/screens/gesture-lab-styles.ts
@@ -0,0 +1,48 @@
+import { StyleSheet } from 'react-native';
+
+import type { AppColors } from '../theme';
+
+export function createGestureLabStyles(colors: AppColors) {
+  return StyleSheet.create({
+    target: {
+      alignItems: 'center',
+      backgroundColor: colors.cardStrong,
+      borderColor: colors.line,
+      borderRadius: 4,
+      borderWidth: StyleSheet.hairlineWidth,
+      height: 220,
+      justifyContent: 'center',
+      overflow: 'hidden',
+    },
+    image: {
+      borderRadius: 4,
+      height: 160,
+      width: 240,
+    },
+    androidTransformTarget: {
+      bottom: 0,
+      left: 0,
+      position: 'absolute',
+      right: 0,
+      top: 0,
+      zIndex: 1,
+    },
+    twoPointerTarget: {
+      bottom: 0,
+      left: 0,
+      position: 'absolute',
+      top: 0,
+      width: '50%',
+      zIndex: 1,
+    },
+    metrics: {
+      gap: 6,
+    },
+    metric: {
+      color: colors.textSoft,
+      fontSize: 13,
+      fontWeight: '600',
+      lineHeight: 18,
+    },
+  });
+}
diff --git a/scripts/build-android-multitouch-helper.sh b/scripts/build-android-multitouch-helper.sh
index eafb24ae8..ca494ed9d 100644
--- a/scripts/build-android-multitouch-helper.sh
+++ b/scripts/build-android-multitouch-helper.sh
@@ -47,6 +47,7 @@ VERSION_CODE="$(
 
 BUILD_DIR="$HELPER_DIR/build"
 CLASSES_DIR="$BUILD_DIR/classes"
+TEST_CLASSES_DIR="$BUILD_DIR/test-classes"
 DEX_DIR="$BUILD_DIR/dex"
 KEYSTORE="$PROJECT_DIR/android-snapshot-helper/debug.keystore"
 UNSIGNED_APK="$BUILD_DIR/helper-unsigned.apk"
@@ -54,7 +55,7 @@ ALIGNED_APK="$BUILD_DIR/helper-aligned.apk"
 APK_PATH="$OUTPUT_DIR/$APK_BASENAME"
 
 rm -rf "$BUILD_DIR"
-mkdir -p "$CLASSES_DIR" "$DEX_DIR" "$OUTPUT_DIR"
+mkdir -p "$CLASSES_DIR" "$TEST_CLASSES_DIR" "$DEX_DIR" "$OUTPUT_DIR"
 
 javac \
   --release 11 \
@@ -62,6 +63,16 @@ javac \
   -d "$CLASSES_DIR" \
   $(find "$HELPER_DIR/src/main/java" -name '*.java' | sort)
 
+javac \
+  --release 11 \
+  -classpath "$ANDROID_JAR:$CLASSES_DIR" \
+  -d "$TEST_CLASSES_DIR" \
+  $(find "$HELPER_DIR/src/test/java" -name '*.java' | sort)
+
+java \
+  -classpath "$ANDROID_JAR:$CLASSES_DIR:$TEST_CLASSES_DIR" \
+  com.callstack.agentdevice.multitouchhelper.PointerEventScheduleTest
+
 "$BUILD_TOOLS_DIR/d8" \
   --min-api "$MIN_SDK" \
   --classpath "$ANDROID_JAR" \
diff --git a/scripts/integration-progress-model.ts b/scripts/integration-progress-model.ts
index 49d79cfd1..49a63731a 100644
--- a/scripts/integration-progress-model.ts
+++ b/scripts/integration-progress-model.ts
@@ -147,6 +147,7 @@ function summarizeProviderScenarioFlagCoverage(files) {
     ['retainPaths', 'retained install-source materialization'],
     ['retentionMs', 'install-source materialization TTL'],
     ['count', 'repeated press/click/swipe input'],
+    ['pointerCount', 'one- vs two-pointer pan gesture topology'],
     ['fps', 'recording frame-rate request'],
     ['quality', 'recording quality scaling'],
     ['hideTouches', 'recording without touch overlays'],
diff --git a/src/__tests__/client.test.ts b/src/__tests__/client.test.ts
index c65cb6062..4cea2261b 100644
--- a/src/__tests__/client.test.ts
+++ b/src/__tests__/client.test.ts
@@ -614,6 +614,47 @@ test('interactions.rotateGesture rejects partial centers on the client side', as
   assert.equal(setup.calls.length, 0);
 });
 
+test('interactions.pan projects one- and two-finger requests through typed gesture input', async () => {
+  const setup = createTransport(async () => ({ ok: true, data: { message: 'Panned' } }));
+  const client = createAgentDeviceClient(setup.config, { transport: setup.transport });
+
+  await client.interactions.pan({ x: 100, y: 200, dx: 40, dy: -20 });
+  await client.interactions.pan({
+    x: 100,
+    y: 200,
+    dx: 40,
+    dy: -20,
+    pointerCount: 2,
+    durationMs: 600,
+  });
+
+  assert.deepEqual(
+    setup.calls.map(({ command, positionals, input }) => ({ command, positionals, input })),
+    [
+      {
+        command: 'gesture',
+        positionals: [],
+        input: {
+          kind: 'pan',
+          origin: { x: 100, y: 200 },
+          delta: { x: 40, y: -20 },
+        },
+      },
+      {
+        command: 'gesture',
+        positionals: [],
+        input: {
+          kind: 'pan',
+          origin: { x: 100, y: 200 },
+          delta: { x: 40, y: -20 },
+          pointerCount: 2,
+          durationMs: 600,
+        },
+      },
+    ],
+  );
+});
+
 // fallow-ignore-next-line complexity
 test('replay.run serializes client-collected AD_VAR shell env into daemon request', async () => {
   const previousAppId = process.env.AD_VAR_APP_ID;
diff --git a/src/__tests__/runtime-public.test.ts b/src/__tests__/runtime-public.test.ts
index 6aace159d..34a2b7a22 100644
--- a/src/__tests__/runtime-public.test.ts
+++ b/src/__tests__/runtime-public.test.ts
@@ -254,9 +254,8 @@ test('internal backend, commands, and io modules are usable', () => {
   assert.equal(typeof commands.interactions.typeText, 'function');
   assert.equal(typeof commands.interactions.focus, 'function');
   assert.equal(typeof commands.interactions.longPress, 'function');
-  assert.equal(typeof commands.interactions.swipe, 'function');
   assert.equal(typeof commands.interactions.scroll, 'function');
-  assert.equal(typeof commands.interactions.pinch, 'function');
+  assert.equal(typeof commands.interactions.gesture, 'function');
   assert.equal(typeof commands.system.back, 'function');
   assert.equal(typeof commands.system.home, 'function');
   assert.equal(typeof commands.system.rotate, 'function');
diff --git a/src/agent-device-client.ts b/src/agent-device-client.ts
index c5ed72a75..e7243209d 100644
--- a/src/agent-device-client.ts
+++ b/src/agent-device-client.ts
@@ -53,6 +53,12 @@ import type {
   MaterializationReleaseOptions,
   MetroPrepareOptions,
   MetroPrepareResult,
+  PanOptions,
+  FlingOptions,
+  SwipeGestureOptions,
+  PinchOptions,
+  RotateGestureOptions,
+  TransformGestureOptions,
 } from './client/client-types.ts';
 import type { CommandResult } from './core/command-descriptor/command-result.ts';
 import {
@@ -65,6 +71,7 @@ import { readSnapshotDiagnosticsSummary } from './snapshot-diagnostics.ts';
 import type { CommandFlags } from './core/dispatch-context.ts';
 import type { AgentArtifactsResult } from './cloud-artifacts.ts';
 import type { ProjectedNavigationCommandClient } from './commands/system/navigation-projection.ts';
+import { AppError } from './kernel/errors.ts';
 
 type ProjectedSystemCommandClient = ProjectedNavigationCommandClient<InternalRequestOptions> &
   Pick<AgentDeviceCommandClient, 'appState' | 'keyboard' | 'clipboard'>;
@@ -86,12 +93,14 @@ export function createAgentDeviceClient(
     positionals: string[] = [],
     options: InternalRequestOptions = {},
     metadataFlags?: Partial<CommandFlags>,
+    input?: Record<string, unknown>,
   ): Promise<Record<string, unknown>> => {
     const merged = mergeClientOptions(config, options);
     const response = await transport({
       session: resolveSessionName(merged.session),
       command,
       positionals,
+      ...(input ? { input } : {}),
       flags: buildRequestFlags(merged, metadataFlags),
       runtime: merged.runtime,
       meta: buildMeta(merged),
@@ -118,6 +127,7 @@ export function createAgentDeviceClient(
       request.positionals,
       request.options,
       request.metadataFlags,
+      request.input,
     )) as T;
   };
 
@@ -352,16 +362,19 @@ export function createAgentDeviceClient(
       press: async (options) => await executeCommand('press', options),
       longPress: async (options) => await executeCommand('longpress', options),
       swipe: async (options) => await executeCommand('swipe', options),
-      pan: async (options) => await executeCommand('gesture-pan', options),
-      fling: async (options) => await executeCommand('gesture-fling', options),
-      swipeGesture: async (options) => await executeCommand('gesture-swipe', options),
+      pan: async (options) => await executeCommand('gesture', panGestureInput(options)),
+      fling: async (options) => await executeCommand('gesture', flingGestureInput(options)),
+      swipeGesture: async (options) =>
+        await executeCommand('gesture', swipePresetGestureInput(options)),
       focus: async (options) => await executeCommand('focus', options),
       type: async (options) => await executeCommand('type', options),
       fill: async (options) => await executeCommand('fill', options),
       scroll: async (options) => await executeCommand('scroll', options),
-      pinch: async (options) => await executeCommand('gesture-pinch', options),
-      rotateGesture: async (options) => await executeCommand('gesture-rotate', options),
-      transformGesture: async (options) => await executeCommand('gesture-transform', options),
+      pinch: async (options) => await executeCommand('gesture', pinchGestureInput(options)),
+      rotateGesture: async (options) =>
+        await executeCommand('gesture', rotateGestureInput(options)),
+      transformGesture: async (options) =>
+        await executeCommand('gesture', transformGestureInput(options)),
       get: async (options) => await executeCommand('get', options),
       is: async (options) => await executeCommand('is', options),
       find: async (options) => await executeCommand('find', options),
@@ -397,6 +410,65 @@ export function createAgentDeviceClient(
   };
 }
 
+function panGestureInput(options: PanOptions): InternalRequestOptions & Record<string, unknown> {
+  const { x, y, dx, dy, ...common } = options;
+  return { ...common, kind: 'pan', origin: { x, y }, delta: { x: dx, y: dy } };
+}
+
+function flingGestureInput(
+  options: FlingOptions,
+): InternalRequestOptions & Record<string, unknown> {
+  const { x, y, ...common } = options;
+  return { ...common, kind: 'fling', origin: { x, y } };
+}
+
+function swipePresetGestureInput(
+  options: SwipeGestureOptions,
+): InternalRequestOptions & Record<string, unknown> {
+  return { ...options, kind: 'swipe' };
+}
+
+function pinchGestureInput(
+  options: PinchOptions,
+): InternalRequestOptions & Record<string, unknown> {
+  const { x, y, ...common } = options;
+  assertCompleteGestureCenter(x, y, 'pinch');
+  return {
+    ...common,
+    kind: 'pinch',
+    ...(x === undefined && y === undefined ? {} : { origin: { x, y } }),
+  };
+}
+
+function rotateGestureInput(
+  options: RotateGestureOptions,
+): InternalRequestOptions & Record<string, unknown> {
+  const { x, y, ...common } = options;
+  assertCompleteGestureCenter(x, y, 'rotate');
+  return {
+    ...common,
+    kind: 'rotate',
+    ...(x === undefined && y === undefined ? {} : { origin: { x, y } }),
+  };
+}
+
+function transformGestureInput(
+  options: TransformGestureOptions,
+): InternalRequestOptions & Record<string, unknown> {
+  const { x, y, dx, dy, ...common } = options;
+  return { ...common, kind: 'transform', origin: { x, y }, delta: { x: dx, y: dy } };
+}
+
+function assertCompleteGestureCenter(
+  x: number | undefined,
+  y: number | undefined,
+  gesture: 'pinch' | 'rotate',
+): void {
+  if ((x === undefined) !== (y === undefined)) {
+    throw new AppError('INVALID_ARGS', `gesture ${gesture} center requires both x and y`);
+  }
+}
+
 function normalizeSnapshotResult(
   data: Record<string, unknown>,
   session: string | undefined,
diff --git a/src/backend.ts b/src/backend.ts
index 6d9314fe3..e6f5e7743 100644
--- a/src/backend.ts
+++ b/src/backend.ts
@@ -1,7 +1,13 @@
 import type { AlertAction, AlertInfo } from './alert-contract.ts';
 import type { AppsFilter } from './contracts/app-inventory.ts';
 import type { JsonObject } from './contracts/json.ts';
-import type { Point, SnapshotNode, SnapshotOptions, SnapshotState } from './kernel/snapshot.ts';
+import type {
+  Point,
+  Rect,
+  SnapshotNode,
+  SnapshotOptions,
+  SnapshotState,
+} from './kernel/snapshot.ts';
 import type { NetworkIncludeMode } from './kernel/contracts.ts';
 import type { DeviceTarget, Platform, PlatformSelector, PublicPlatform } from './kernel/device.ts';
 import type { BackMode } from './contracts/back-mode.ts';
@@ -11,6 +17,7 @@ import type { DeviceRotation } from './contracts/device-rotation.ts';
 import type { ScrollDirection } from './contracts/scroll-gesture.ts';
 import type { SessionSurface } from './contracts/session-surface.ts';
 import type { TvRemoteButton } from './contracts/tv-remote.ts';
+import type { GesturePlan } from './contracts/gesture-plan-types.ts';
 import type { RecordingExportQuality } from './core/recording-export-quality.ts';
 import type { SnapshotDiagnosticsSummary } from './snapshot-diagnostics.ts';
 import type {
@@ -155,10 +162,6 @@ export type BackendLongPressOptions = {
   durationMs?: number;
 };
 
-export type BackendSwipeOptions = {
-  durationMs?: number;
-};
-
 export type BackendScrollTarget =
   | {
       kind: 'viewport';
@@ -175,11 +178,6 @@ export type BackendScrollOptions = {
   durationMs?: number;
 };
 
-export type BackendPinchOptions = {
-  scale: number;
-  center?: Point;
-};
-
 export type BackendOpenTarget = {
   /**
    * Generic app identifier accepted by the backend. Hosted adapters should
@@ -434,6 +432,7 @@ export type AgentDeviceBackend = {
     context: BackendCommandContext,
     options?: BackendSnapshotOptions,
   ): Promise<BackendSnapshotResult>;
+  resolveGestureViewport?(context: BackendCommandContext): Promise<Rect | undefined>;
   captureScreenshot?(
     context: BackendCommandContext,
     outPath: string,
@@ -474,21 +473,12 @@ export type AgentDeviceBackend = {
     point: Point,
     options?: BackendLongPressOptions,
   ): Promise<BackendActionResult>;
-  swipe?(
-    context: BackendCommandContext,
-    from: Point,
-    to: Point,
-    options?: BackendSwipeOptions,
-  ): Promise<BackendActionResult>;
   scroll?(
     context: BackendCommandContext,
     target: BackendScrollTarget,
     options: BackendScrollOptions,
   ): Promise<BackendActionResult>;
-  pinch?(
-    context: BackendCommandContext,
-    options: BackendPinchOptions,
-  ): Promise<BackendActionResult>;
+  performGesture?(context: BackendCommandContext, plan: GesturePlan): Promise<BackendActionResult>;
   pressKey?(
     context: BackendCommandContext,
     key: string,
diff --git a/src/batch-policy.ts b/src/batch-policy.ts
index e9398f9c6..60a056b93 100644
--- a/src/batch-policy.ts
+++ b/src/batch-policy.ts
@@ -32,7 +32,13 @@ export const STRUCTURED_BATCH_COMMAND_NAMES: readonly StructuredBatchCommandName
 
 const BATCH_BLOCKED_COMMANDS: ReadonlySet<string> = new Set(['batch', 'replay']);
 
-export const BATCH_DAEMON_STEP_KEYS = ['command', 'positionals', 'flags', 'runtime'] as const;
+export const BATCH_DAEMON_STEP_KEYS = [
+  'command',
+  'positionals',
+  'input',
+  'flags',
+  'runtime',
+] as const;
 
 export const INHERITED_PARENT_FLAG_KEYS = [
   'platform',
diff --git a/src/cli-schema/command-schema-guards.test.ts b/src/cli-schema/command-schema-guards.test.ts
index 6ba092fbf..6df5e368d 100644
--- a/src/cli-schema/command-schema-guards.test.ts
+++ b/src/cli-schema/command-schema-guards.test.ts
@@ -17,7 +17,6 @@ import { getCliCommandSchema } from './command-schema.ts';
 test('every public capability command has a parser schema entry', () => {
   const schemaCommands = new Set<string>(listCliCommandNames());
   for (const command of listCapabilityCommands()) {
-    if (INTERNAL_GESTURE_CAPABILITY_COMMANDS.has(command)) continue;
     assert.equal(schemaCommands.has(command), true, `Missing schema for command: ${command}`);
   }
 });
@@ -58,22 +57,9 @@ test('cli.ts command dispatch checks are recognized by parser-level unknown-comm
 });
 
 test('schema capability mappings match capability source-of-truth', () => {
-  assert.deepEqual(
-    listCapabilityCheckedCommandNames(),
-    listCapabilityCommands().filter(
-      (command) => !INTERNAL_GESTURE_CAPABILITY_COMMANDS.has(command),
-    ),
-  );
+  assert.deepEqual(listCapabilityCheckedCommandNames(), listCapabilityCommands());
 });
 
-const INTERNAL_GESTURE_CAPABILITY_COMMANDS = new Set([
-  'pan',
-  'fling',
-  'pinch',
-  'rotate-gesture',
-  'transform-gesture',
-]);
-
 function collectCliDispatchCommandLiterals(): Set<string> {
   const cliPath = fileURLToPath(new URL('../cli.ts', import.meta.url));
   const sourceText = fs.readFileSync(cliPath, 'utf8');
diff --git a/src/cli/parser/__tests__/args-parse-interaction.test.ts b/src/cli/parser/__tests__/args-parse-interaction.test.ts
index c691ba8d1..483bb5e17 100644
--- a/src/cli/parser/__tests__/args-parse-interaction.test.ts
+++ b/src/cli/parser/__tests__/args-parse-interaction.test.ts
@@ -145,11 +145,15 @@ test('parseArgs recognizes swipe positional + pattern flags', () => {
 });
 
 test('parseArgs recognizes gesture subcommand positionals', () => {
-  const pan = parseArgs(['gesture', 'pan', '200', '420', '0', '-80', '500'], {
-    strictFlags: true,
-  });
+  const pan = parseArgs(
+    ['gesture', 'pan', '200', '420', '0', '-80', '500', '--pointer-count', '2'],
+    {
+      strictFlags: true,
+    },
+  );
   assert.equal(pan.command, 'gesture');
   assert.deepEqual(pan.positionals, ['pan', '200', '420', '0', '-80', '500']);
+  assert.equal(pan.flags.pointerCount, 2);
 
   const fling = parseArgs(['gesture', 'fling', 'right', '200', '420', '180'], {
     strictFlags: true,
diff --git a/src/cli/parser/__tests__/cli-help-command-usage.test.ts b/src/cli/parser/__tests__/cli-help-command-usage.test.ts
index b490e1d1a..d0bb47504 100644
--- a/src/cli/parser/__tests__/cli-help-command-usage.test.ts
+++ b/src/cli/parser/__tests__/cli-help-command-usage.test.ts
@@ -261,7 +261,8 @@ test('network command usage documents include flag', async () => {
 test('command usage shows command flags without global flags', async () => {
   const help = await usageForCommand('swipe');
   if (help === null) throw new Error('Expected command help text');
-  assert.match(help, /Swipe coordinates with optional repeat pattern/);
+  assert.match(help, /Quick coordinate fling with optional repeat pattern/);
+  assert.match(help, /duration positional is accepted as a deprecated alias to pan/);
   assert.match(help, /Command flags:/);
   assert.match(help, /--pattern one-way\|ping-pong/);
   assert.doesNotMatch(help, /Global flags:/);
diff --git a/src/cli/parser/__tests__/cli-help-topics.test.ts b/src/cli/parser/__tests__/cli-help-topics.test.ts
index 9f3a3c687..23194d1b0 100644
--- a/src/cli/parser/__tests__/cli-help-topics.test.ts
+++ b/src/cli/parser/__tests__/cli-help-topics.test.ts
@@ -225,7 +225,11 @@ test('usageForCommand resolves workflow help topic', async () => {
   assert.match(help, /Android transform injects a geometric two-finger path/);
   assert.match(help, /verify semantic app state or coarse per-component effects/);
   assert.match(help, /instead of exact numeric deltas/);
-  assert.match(help, /prefer isolated gesture pan, gesture pinch, or gesture rotate/);
+  assert.match(help, /prefer isolated gesture pan --pointer-count 2, gesture pinch/);
+  assert.match(help, /gesture pan is one finger by default/);
+  assert.match(help, /--pointer-count 2 for a parallel two-finger pan/);
+  assert.match(help, /falls back to the visible snapshot union/);
+  assert.match(help, /tvOS coordinate pan and fling preserve only the dominant direction/);
   assert.match(help, /longpress accepts coordinates, @refs, or selectors/);
   assert.match(help, /use help react-native for Metro\/Re\.Pack Fast Refresh/);
   assert.match(help, /iOS Allow Paste prompt cannot be exercised under XCUITest/);
diff --git a/src/cli/parser/cli-help.ts b/src/cli/parser/cli-help.ts
index 424cf8e0c..d3cf56058 100644
--- a/src/cli/parser/cli-help.ts
+++ b/src/cli/parser/cli-help.ts
@@ -193,7 +193,7 @@ Command shape:
   Snapshot refs look like @e12. After snapshot -i, use the exact @eN ref from that output.
   If the exact ref is not known yet, first output snapshot -i, then use a concrete example shape like press @e12 in the next command; do not write @<ref>, @ref, @Label_Name, or @eN placeholders.
   Close means agent-device close. App-owned back means back; system back means back --system.
-  Taps are press or click; tap is an alias for press. On Android TV and tvOS, read help tv and use tv-remote press up|down|left|right|select to move D-pad/remote focus before activating controls; use tv-remote longpress <button> for a held remote button. Gestures use swipe, longpress, or gesture <pan|fling|swipe|pinch|rotate|transform>. Use gesture swipe left|right for reliable in-page horizontal swipes, and gesture swipe right-edge for left-edge navigation/back gestures. Android swipe, pinch, rotate, and transform use provider-native touch injection when available, then the bundled touch helper. iOS simulator transform uses private XCTest synthesis for a continuous two-finger pan/scale/rotation path; otherwise it reports UNSUPPORTED_OPERATION.
+  Taps are press or click; tap is an alias for press. On Android TV and tvOS, read help tv and use tv-remote press up|down|left|right|select to move D-pad/remote focus before activating controls; use tv-remote longpress <button> for a held remote button. Gestures use swipe, longpress, or gesture <pan|fling|swipe|pinch|rotate|transform>. Use gesture swipe left|right for reliable in-page horizontal swipes, and gesture swipe right-edge for left-edge navigation/back gestures. gesture pan is one finger by default; add --pointer-count 2 for a parallel two-finger pan. Android swipe and multi-touch gestures use provider-native touch injection when available, then the bundled touch helper. iOS simulator multi-touch uses private XCTest synthesis for a continuous two-pointer path; otherwise it reports UNSUPPORTED_OPERATION.
 
 Bootstrap:
   agent-device devices --platform ios
@@ -280,20 +280,21 @@ Read-only and waits:
   Ambiguous find: add --first or --last. If info is not visible/exposed, report that gap instead of typing/searching/navigating to reveal it.
 
 Navigation and gestures:
-  Use scroll for lists; swipe for coordinate gestures/carousels; gesture pan for deliberate drags; gesture fling for fast directional throws.
+  Use scroll for lists; swipe for quick coordinate gestures/carousels; gesture pan for deliberate timed drags; gesture fling for fast directional throws. Historical swipe/fling duration arguments remain compatibility aliases to pan and are deprecated.
   For fast macOS desktop list traversal, prefer fixed pixel wheel steps and batch them when no snapshot is needed between passes:
     agent-device scroll down --pixels 200 --duration-ms 50 --platform macos
     agent-device batch --steps '[{"command":"scroll","input":{"direction":"down","pixels":200,"durationMs":50}},{"command":"scroll","input":{"direction":"down","pixels":200,"durationMs":50}}]' --platform macos
   For raw coordinate gestures, run snapshot -i first and choose a point near the center of the intended app-owned target. Avoid screen edges, tab bars, navigation bars, and home indicators because those areas can trigger system or app navigation instead of the gesture under test.
   If app-owned back is ambiguous or has just misrouted, prefer a visible nav/back button ref, tab-bar ref, or deep link over repeated back/system back.
   App-owned action sheets, menus, and camera/scan screens are normal UI. After opening one, run snapshot -i or wait for the option, press by label/ref, handle visible permission sheets through UI or platform-supported native alerts, then wait for a concrete result before returning to chat/form state.
-  Keep count/pause/pattern on one swipe; flags are --count, --pause-ms, --pattern ping-pong.
+  Keep count/pause/pattern on one swipe; flags are --count, --pause-ms, --pattern ping-pong. Count is capped at 200, pause at 10000ms, and the combined swipe/pause schedule at 60000ms.
   For repeated iOS gesture smoke checks, use press <x> <y> --count <n> --jitter-px <n> for tap series and swipe <x1> <y1> <x2> <y2> --count <n> for drag series.
   longpress accepts coordinates, @refs, or selectors. Prefer @ref/selector from snapshot -i; use coordinates only as a fallback when accessibility refs miss the exact target. Duration and gesture scale/center are positional:
     agent-device longpress 300 500 800
     agent-device longpress @e12 800
     agent-device swipe 320 500 40 500 --count 8 --pause-ms 30 --pattern ping-pong
     agent-device gesture pan 200 420 0 -80 500
+    agent-device gesture pan 200 420 80 -40 700 --pointer-count 2
     agent-device gesture fling right 200 420 180
     agent-device gesture pinch 0.5 200 400
     agent-device gesture rotate 35 200 420
@@ -304,7 +305,9 @@ Navigation and gestures:
     agent-device wait text "pan changed yes" 3000 --platform android
     agent-device wait text "pinch changed yes" 3000 --platform android
     agent-device wait text "rotate changed yes" 3000 --platform android
-  If Android needs exact app-state values, prefer isolated gesture pan, gesture pinch, or gesture rotate commands over one combined transform.
+  If Android needs exact app-state values, prefer isolated gesture pan --pointer-count 2, gesture pinch, or gesture rotate commands over one combined transform.
+  Gesture planning prefers the active-app frame. A backend without a gesture viewport resolver falls back to the visible snapshot union, which can be less accurate near edges.
+  tvOS coordinate pan and fling preserve only the dominant direction as a remote swipe; authored endpoints and duration are not preserved.
   macOS context menus are secondary clicks, not long presses:
     agent-device click @e66 --button secondary --platform macos
     agent-device snapshot -i --platform macos
diff --git a/src/client/client-types.ts b/src/client/client-types.ts
index a587e2e4a..803b88162 100644
--- a/src/client/client-types.ts
+++ b/src/client/client-types.ts
@@ -34,6 +34,7 @@ import type {
   NavigationCommandOptions,
   ProjectedNavigationCommandClient,
 } from '../commands/system/navigation-projection.ts';
+import type { GesturePointerCount } from '../contracts/gesture-plan.ts';
 import type { LogAction } from '../contracts/logs.ts';
 import type { SessionSurface } from '../contracts/session-surface.ts';
 import type { FindLocator } from '../selectors/find.ts';
@@ -704,6 +705,7 @@ export type LongPressOptions = DeviceCommandBaseOptions &
 export type SwipeOptions = DeviceCommandBaseOptions & {
   from: { x: number; y: number };
   to: { x: number; y: number };
+  /** @deprecated Timed movement is a pan. Omit this field for swipe/fling semantics. */
   durationMs?: number;
   count?: number;
   pauseMs?: number;
@@ -715,6 +717,7 @@ export type PanOptions = DeviceCommandBaseOptions & {
   y: number;
   dx: number;
   dy: number;
+  pointerCount?: GesturePointerCount;
   durationMs?: number;
 };
 
@@ -723,11 +726,13 @@ export type FlingOptions = DeviceCommandBaseOptions & {
   x: number;
   y: number;
   distance?: number;
+  /** @deprecated Timed movement is a pan. Omit this field for fling semantics. */
   durationMs?: number;
 };
 
 export type SwipeGestureOptions = DeviceCommandBaseOptions & {
   preset: SwipePreset;
+  /** @deprecated Timed movement is a pan. Omit this field for swipe/fling semantics. */
   durationMs?: number;
 };
 
@@ -767,6 +772,7 @@ export type RotateGestureOptions = DeviceCommandBaseOptions & {
   degrees: number;
   x?: number;
   y?: number;
+  /** @deprecated Rotation pacing is derived from degrees. */
   velocity?: number;
 };
 
diff --git a/src/cloud-webdriver/webdriver-interactor.ts b/src/cloud-webdriver/webdriver-interactor.ts
index b1d9506d1..a7b4242f4 100644
--- a/src/cloud-webdriver/webdriver-interactor.ts
+++ b/src/cloud-webdriver/webdriver-interactor.ts
@@ -6,7 +6,8 @@ import type {
 } from '../core/interactor-types.ts';
 import type { BackMode } from '../contracts/back-mode.ts';
 import type { DeviceRotation } from '../contracts/device-rotation.ts';
-import type { ScrollDirection, TransformGestureParams } from '../contracts/scroll-gesture.ts';
+import type { ScrollDirection } from '../contracts/scroll-gesture.ts';
+import type { GesturePlan } from '../contracts/gesture-plan.ts';
 import type { TvRemoteButton } from '../contracts/tv-remote.ts';
 import type { SettingOptions } from '../platforms/permission-utils.ts';
 import { AppError } from '../kernel/errors.ts';
@@ -118,26 +119,6 @@ class WebDriverInteractor implements Interactor {
     return { backend: 'webdriver', x1, y1, x2, y2, durationMs };
   }
 
-  async pan(
-    x1: number,
-    y1: number,
-    x2: number,
-    y2: number,
-    durationMs?: number,
-  ): Promise<Record<string, unknown>> {
-    return await this.swipe(x1, y1, x2, y2, durationMs);
-  }
-
-  async fling(
-    x1: number,
-    y1: number,
-    x2: number,
-    y2: number,
-    durationMs = 150,
-  ): Promise<Record<string, unknown>> {
-    return await this.swipe(x1, y1, x2, y2, durationMs);
-  }
-
   async longPress(x: number, y: number, durationMs = 600): Promise<Record<string, unknown>> {
     this.requireSupport('longPress');
     await this.pointerGesture('longPress', [
@@ -202,8 +183,19 @@ class WebDriverInteractor implements Interactor {
     return { backend: 'webdriver', ...absolutePlan, distance: plan.pixels, durationMs };
   }
 
-  async pinch(_scale: number, _x?: number, _y?: number): Promise<Record<string, unknown> | void> {
-    this.unsupported('pinch');
+  async gestureViewport(): Promise<WebDriverWindowRect> {
+    return await this.scrollGestureFrame();
+  }
+
+  async performGesture(plan: GesturePlan): Promise<Record<string, unknown>> {
+    this.requireSupport(webDriverOperationForGesture(plan));
+    await this.client.performActions(
+      plan.pointers.map((pointer) =>
+        touchPointer(`gesture-pointer-${pointer.pointerId}`, pointerActions(pointer.samples)),
+      ),
+    );
+    await this.client.releaseActions().catch(() => undefined);
+    return { backend: 'webdriver-w3c-actions' };
   }
 
   async screenshot(outPath: string, _options?: ScreenshotOptions): Promise<void> {
@@ -234,21 +226,6 @@ class WebDriverInteractor implements Interactor {
     await this.client.executeScript('mobile: rotate', [{ orientation }]);
   }
 
-  async rotateGesture(
-    _degrees: number,
-    _x?: number,
-    _y?: number,
-    _velocity?: number,
-  ): Promise<Record<string, unknown> | void> {
-    this.unsupported('rotateGesture');
-  }
-
-  async transformGesture(
-    _options: TransformGestureParams,
-  ): Promise<Record<string, unknown> | void> {
-    this.unsupported('transformGesture');
-  }
-
   async appSwitcher(): Promise<void> {
     this.requireSupport('appSwitcher');
     await this.client.executeScript('mobile: pressButton', [{ name: 'appSwitch' }]);
@@ -311,3 +288,37 @@ class WebDriverInteractor implements Interactor {
     );
   }
 }
+
+function pointerActions(samples: GesturePlan['pointers'][number]['samples']): W3CPointerAction[] {
+  const first = samples[0];
+  if (!first) throw new AppError('INVALID_ARGS', 'WebDriver gesture pointer requires samples');
+  const actions: W3CPointerAction[] = [
+    { type: 'pointerMove', duration: 0, x: first.point.x, y: first.point.y },
+    { type: 'pointerDown', button: 0 },
+  ];
+  for (let index = 1; index < samples.length; index += 1) {
+    const previous = samples[index - 1]!;
+    const sample = samples[index]!;
+    actions.push({
+      type: 'pointerMove',
+      duration: sample.offsetMs - previous.offsetMs,
+      x: sample.point.x,
+      y: sample.point.y,
+    });
+  }
+  actions.push({ type: 'pointerUp', button: 0 });
+  return actions;
+}
+
+function webDriverOperationForGesture(plan: GesturePlan): CloudWebDriverOperation {
+  if (plan.topology === 'single') return 'swipe';
+  switch (plan.intent) {
+    case 'pan':
+    case 'transform':
+      return 'transformGesture';
+    case 'pinch':
+      return 'pinch';
+    case 'rotate':
+      return 'rotateGesture';
+  }
+}
diff --git a/src/command-catalog.ts b/src/command-catalog.ts
index 7cdd4b0a1..5ed25283a 100644
--- a/src/command-catalog.ts
+++ b/src/command-catalog.ts
@@ -14,10 +14,6 @@ export const SPECIAL_CLI_COMMANDS = {
   help: 'help',
 } as const;
 
-export const GESTURE_KINDS = ['pan', 'fling', 'swipe', 'pinch', 'rotate', 'transform'] as const;
-export type GestureKind = (typeof GESTURE_KINDS)[number];
-export const GESTURE_SUBCOMMAND_ERROR = `gesture requires one of: ${GESTURE_KINDS.join(', ')}`;
-
 export type PublicCommandName = DescriptorCommandNameForCatalogGroup<'public'>;
 export type InternalCommandName = DescriptorCommandNameForCatalogGroup<'internal'>;
 export type LocalCliCommandName = DescriptorCommandNameForCatalogGroup<'local-cli'>;
diff --git a/src/commands/__tests__/command-surface-metadata.test.ts b/src/commands/__tests__/command-surface-metadata.test.ts
index eff48d206..3d15443ce 100644
--- a/src/commands/__tests__/command-surface-metadata.test.ts
+++ b/src/commands/__tests__/command-surface-metadata.test.ts
@@ -137,21 +137,9 @@ test('command family facets keep daemon writers as an explicit projection subset
   const metadataNames = new Set<string>(
     listCommandFamilyMetadata().map((metadata) => metadata.name),
   );
-  const projectionAliases = new Set([
-    'gesture-fling',
-    'gesture-pan',
-    'gesture-pinch',
-    'gesture-rotate',
-    'gesture-swipe',
-    'gesture-transform',
-  ]);
-
   assert.ok(writerNames.length > 0);
   for (const name of writerNames) {
-    assert.ok(
-      metadataNames.has(name) || projectionAliases.has(name),
-      `${name} daemon writer must belong to command metadata or projection aliases`,
-    );
+    assert.ok(metadataNames.has(name), `${name} daemon writer must belong to command metadata`);
   }
 });
 
diff --git a/src/commands/batch/projection.ts b/src/commands/batch/projection.ts
index 052d20391..623b2f7a6 100644
--- a/src/commands/batch/projection.ts
+++ b/src/commands/batch/projection.ts
@@ -62,6 +62,7 @@ function readBatchDaemonStep(
   return {
     command: prepared.command,
     positionals: prepared.positionals,
+    ...(prepared.input ? { input: prepared.input } : {}),
     flags: buildRequestFlags(prepared.options, prepared.metadataFlags),
     runtime: runtime ?? prepared.options.runtime,
   };
diff --git a/src/commands/cli-grammar/common.ts b/src/commands/cli-grammar/common.ts
index 056e60cfa..a5577a3e0 100644
--- a/src/commands/cli-grammar/common.ts
+++ b/src/commands/cli-grammar/common.ts
@@ -25,8 +25,14 @@ export function request(
   command: string,
   positionals: string[],
   options: CommandInput,
+  input?: Record<string, unknown>,
 ): DaemonCommandRequest {
-  return { command, positionals, options: normalizeCommonRequestOptions(options) };
+  return {
+    command,
+    positionals,
+    ...(input ? { input } : {}),
+    options: normalizeCommonRequestOptions(options),
+  };
 }
 
 function normalizeCommonRequestOptions(options: CommandInput): InternalRequestOptions {
diff --git a/src/commands/cli-grammar/flag-definitions-action.ts b/src/commands/cli-grammar/flag-definitions-action.ts
index f3b9c0f52..709fb670d 100644
--- a/src/commands/cli-grammar/flag-definitions-action.ts
+++ b/src/commands/cli-grammar/flag-definitions-action.ts
@@ -12,6 +12,15 @@ export const ACTION_FLAG_DEFINITIONS: readonly FlagDefinition[] = [
     usageLabel: '--count <n>',
     usageDescription: 'Repeat count for press/swipe series',
   },
+  {
+    key: 'pointerCount',
+    names: ['--pointer-count'],
+    type: 'int',
+    min: 1,
+    max: 2,
+    usageLabel: '--pointer-count <1|2>',
+    usageDescription: 'Gesture pan: number of touch pointers (default 1)',
+  },
   {
     key: 'fps',
     names: ['--fps'],
diff --git a/src/commands/cli-grammar/types.ts b/src/commands/cli-grammar/types.ts
index f17944729..124785fd4 100644
--- a/src/commands/cli-grammar/types.ts
+++ b/src/commands/cli-grammar/types.ts
@@ -8,6 +8,7 @@ import type { WaitParsed } from '../../core/wait-positionals.ts';
 export type DaemonCommandRequest = {
   command: string;
   positionals: string[];
+  input?: Record<string, unknown>;
   options: InternalRequestOptions;
   metadataFlags?: Partial<CommandFlags>;
 };
diff --git a/src/commands/command-input.ts b/src/commands/command-input.ts
index 5ce3fe042..28ac86fc8 100644
--- a/src/commands/command-input.ts
+++ b/src/commands/command-input.ts
@@ -12,6 +12,7 @@ import {
 } from '../kernel/device.ts';
 import type { JsonSchema } from './command-contract.ts';
 import { AppError } from '../kernel/errors.ts';
+import { readOptionalInteger as optionalInteger } from '../kernel/input-validation.ts';
 
 const INTERACTION_TARGET_KINDS = ['ref', 'selector', 'point'] as const;
 
@@ -354,7 +355,7 @@ function readElementTarget(record: Record<string, unknown>, key: string): Elemen
   return { kind, selector: requiredString(target, 'selector') };
 }
 
-export function readPoint(record: Record<string, unknown>, key: string): PointInput {
+function readPoint(record: Record<string, unknown>, key: string): PointInput {
   const point = readRecordField(record, key);
   return { x: requiredNumber(point, 'x'), y: requiredNumber(point, 'y') };
 }
@@ -376,7 +377,7 @@ function optionalString(record: Record<string, unknown>, key: string): string |
   return value;
 }
 
-export function requiredNumber(record: Record<string, unknown>, key: string): number {
+function requiredNumber(record: Record<string, unknown>, key: string): number {
   const value = record[key];
   if (typeof value !== 'number' || !Number.isFinite(value)) {
     throw new AppError('INVALID_ARGS', `Expected ${key} to be a finite number.`);
@@ -393,26 +394,6 @@ function optionalNumberValue(record: Record<string, unknown>, key: string): numb
   return value;
 }
 
-export function optionalInteger(
-  record: Record<string, unknown>,
-  key: string,
-  options: { min?: number; max?: number } = {},
-): number | undefined {
-  const value = record[key];
-  if (value === undefined) return undefined;
-  if (!Number.isInteger(value)) {
-    throw new AppError('INVALID_ARGS', `Expected ${key} to be an integer.`);
-  }
-  const numberValue = value as number;
-  if (options.min !== undefined && numberValue < options.min) {
-    throw new AppError('INVALID_ARGS', `Expected ${key} to be at least ${options.min}.`);
-  }
-  if (options.max !== undefined && numberValue > options.max) {
-    throw new AppError('INVALID_ARGS', `Expected ${key} to be at most ${options.max}.`);
-  }
-  return numberValue;
-}
-
 function optionalBoolean(record: Record<string, unknown>, key: string): boolean | undefined {
   const value = record[key];
   if (value === undefined) return undefined;
@@ -422,7 +403,7 @@ function optionalBoolean(record: Record<string, unknown>, key: string): boolean
   return value;
 }
 
-export function requiredEnum<const T extends readonly string[]>(
+function requiredEnum<const T extends readonly string[]>(
   record: Record<string, unknown>,
   key: string,
   values: T,
diff --git a/src/commands/interaction/gesture.test.ts b/src/commands/interaction/gesture.test.ts
index b25fba50c..c8ac7c4f1 100644
--- a/src/commands/interaction/gesture.test.ts
+++ b/src/commands/interaction/gesture.test.ts
@@ -1,266 +1,52 @@
 import { describe, expect, test } from 'vitest';
 import type { CliFlags } from '../cli-grammar/flag-types.ts';
-import type { CommandInput } from '../cli-grammar/types.ts';
 import { gestureCliReaders, gestureDaemonWriters } from './gesture.ts';
 
 const NO_FLAGS = {} as CliFlags;
 
-function readCli(positionals: string[]) {
-  return gestureCliReaders.gesture(positionals, NO_FLAGS);
-}
-
-function writePositionals(writerKey: keyof typeof gestureDaemonWriters, input: CommandInput) {
-  const request = gestureDaemonWriters[writerKey](input);
-  expect(request.command).toBe('gesture');
-  return request.positionals;
-}
-
-function expectInvalidArgs(fn: () => unknown, messageFragment?: string) {
-  expect(fn).toThrow(
-    expect.objectContaining({
-      code: 'INVALID_ARGS',
-      ...(messageFragment ? { message: expect.stringContaining(messageFragment) } : {}),
-    }),
-  );
-}
-
-describe('gestureInputFromCli reader', () => {
-  test('parses a pan gesture with origin, delta and duration', () => {
-    expect(readCli(['pan', '10', '20', '5', '6', '300'])).toMatchObject({
+describe('gesture command projection', () => {
+  test('parses one-finger pan by default and explicit two-finger pan', () => {
+    expect(gestureCliReaders.gesture(['pan', '10', '20', '5', '6', '300'], NO_FLAGS)).toMatchObject(
+      {
+        kind: 'pan',
+        origin: { x: 10, y: 20 },
+        delta: { x: 5, y: 6 },
+        durationMs: 300,
+      },
+    );
+    expect(
+      gestureCliReaders.gesture(['pan', '10', '20', '5', '6'], {
+        ...NO_FLAGS,
+        pointerCount: 2,
+      }),
+    ).toMatchObject({
       kind: 'pan',
-      origin: { x: 10, y: 20 },
-      delta: { x: 5, y: 6 },
-      durationMs: 300,
-    });
-  });
-
-  test('leaves an omitted pan duration undefined', () => {
-    expect(readCli(['pan', '10', '20', '5', '6']).durationMs).toBeUndefined();
-  });
-
-  test('parses a fling gesture with direction, origin, distance and duration', () => {
-    expect(readCli(['fling', 'up', '10', '20', '100', '250'])).toMatchObject({
-      kind: 'fling',
-      direction: 'up',
-      origin: { x: 10, y: 20 },
-      distance: 100,
-      durationMs: 250,
+      pointerCount: 2,
     });
   });
 
-  test('parses a swipe preset gesture', () => {
-    expect(readCli(['swipe', 'left', '400'])).toMatchObject({
-      kind: 'swipe',
-      preset: 'left',
-      durationMs: 400,
-    });
-  });
-
-  test('parses a pinch gesture with an explicit origin', () => {
-    expect(readCli(['pinch', '2', '10', '20'])).toMatchObject({
-      kind: 'pinch',
-      scale: 2,
-      origin: { x: 10, y: 20 },
-    });
-  });
-
-  test('leaves the pinch origin undefined when coordinates are missing', () => {
-    expect(readCli(['pinch', '0.5']).origin).toBeUndefined();
-  });
-
-  test('parses a rotate gesture with origin and velocity', () => {
-    expect(readCli(['rotate', '90', '10', '20', '5'])).toMatchObject({
-      kind: 'rotate',
-      degrees: 90,
+  test('writes only typed daemon input', () => {
+    const request = gestureDaemonWriters.gesture({
+      kind: 'pan',
       origin: { x: 10, y: 20 },
-      velocity: 5,
-    });
-  });
-
-  test('leaves the rotate origin undefined when coordinates are missing', () => {
-    expect(readCli(['rotate', '45']).origin).toBeUndefined();
-  });
-
-  test('parses a transform gesture with all parameters', () => {
-    expect(readCli(['transform', '1', '2', '3', '4', '1.5', '30', '200'])).toMatchObject({
-      kind: 'transform',
-      origin: { x: 1, y: 2 },
-      delta: { x: 3, y: 4 },
-      scale: 1.5,
-      degrees: 30,
-      durationMs: 200,
+      delta: { x: 5, y: 6 },
+      pointerCount: 2,
+      durationMs: 300,
     });
-  });
-
-  test('rejects an unknown gesture subcommand', () => {
-    expectInvalidArgs(() => readCli(['twist']), 'gesture requires pan, fling, swipe');
-  });
-});
-
-describe('gesture daemon writers', () => {
-  test('the default gesture writer serializes a pan kind from origin/delta', () => {
-    const positionals = writePositionals('gesture', {
+    expect(request.command).toBe('gesture');
+    expect(request.positionals).toEqual([]);
+    expect(request.input).toEqual({
       kind: 'pan',
       origin: { x: 10, y: 20 },
       delta: { x: 5, y: 6 },
+      pointerCount: 2,
       durationMs: 300,
-    } as CommandInput);
-    expect(positionals).toEqual(['pan', '10', '20', '5', '6', '300']);
-  });
-
-  test('the default gesture writer omits an absent duration', () => {
-    const positionals = writePositionals('gesture', {
-      kind: 'pan',
-      origin: { x: 1, y: 2 },
-      delta: { x: 3, y: 4 },
-    } as CommandInput);
-    expect(positionals).toEqual(['pan', '1', '2', '3', '4']);
-  });
-
-  test('the default gesture writer serializes swipe presets', () => {
-    expect(
-      writePositionals('gesture', { kind: 'swipe', preset: 'up', durationMs: 400 } as CommandInput),
-    ).toEqual(['swipe', 'up', '400']);
-  });
-
-  test('the default gesture writer requires a swipe preset', () => {
-    expectInvalidArgs(
-      () => writePositionals('gesture', { kind: 'swipe' } as CommandInput),
-      'gesture swipe requires preset',
-    );
-  });
-
-  test('the default gesture writer requires a fling direction', () => {
-    expectInvalidArgs(
-      () =>
-        writePositionals('gesture', {
-          kind: 'fling',
-          origin: { x: 1, y: 2 },
-        } as CommandInput),
-      'gesture fling requires direction',
-    );
-  });
-
-  test('the default gesture writer rejects unknown kinds', () => {
-    expectInvalidArgs(
-      () => writePositionals('gesture', { kind: 'mystery' } as CommandInput),
-      'gesture requires pan, fling, swipe',
-    );
-  });
-
-  test('the default gesture writer serializes a pinch kind from scale and origin', () => {
-    expect(
-      writePositionals('gesture', {
-        kind: 'pinch',
-        scale: 2,
-        origin: { x: 10, y: 20 },
-      } as CommandInput),
-    ).toEqual(['pinch', '2', '10', '20']);
-  });
-
-  test('the default gesture writer serializes a rotate kind from degrees and origin', () => {
-    expect(
-      writePositionals('gesture', {
-        kind: 'rotate',
-        degrees: 90,
-        origin: { x: 10, y: 20 },
-        velocity: 5,
-      } as CommandInput),
-    ).toEqual(['rotate', '90', '10', '20', '5']);
-  });
-
-  test('the default gesture writer serializes a transform kind from origin/delta/scale/degrees', () => {
-    expect(
-      writePositionals('gesture', {
-        kind: 'transform',
-        origin: { x: 1, y: 2 },
-        delta: { x: 3, y: 4 },
-        scale: 1.5,
-        degrees: 30,
-        durationMs: 200,
-      } as CommandInput),
-    ).toEqual(['transform', '1', '2', '3', '4', '1.5', '30', '200']);
-  });
-
-  test('the gesture-pan writer serializes flat x/y/dx/dy coordinates', () => {
-    expect(
-      writePositionals('gesture-pan', {
-        x: 10,
-        y: 20,
-        dx: 5,
-        dy: 6,
-        durationMs: 300,
-      } as CommandInput),
-    ).toEqual(['pan', '10', '20', '5', '6', '300']);
-  });
-
-  test('the gesture-fling writer defaults distance to 180 when only a duration is given', () => {
-    expect(
-      writePositionals('gesture-fling', {
-        direction: 'down',
-        x: 10,
-        y: 20,
-        durationMs: 250,
-      } as CommandInput),
-    ).toEqual(['fling', 'down', '10', '20', '180', '250']);
-  });
-
-  test('the gesture-fling writer keeps an explicit distance and omits an absent duration', () => {
-    expect(
-      writePositionals('gesture-fling', {
-        direction: 'up',
-        x: 10,
-        y: 20,
-        distance: 120,
-      } as CommandInput),
-    ).toEqual(['fling', 'up', '10', '20', '120']);
-  });
-
-  test('the gesture-pinch writer serializes scale and optional origin', () => {
-    expect(writePositionals('gesture-pinch', { scale: 2, x: 10, y: 20 } as CommandInput)).toEqual([
-      'pinch',
-      '2',
-      '10',
-      '20',
-    ]);
-  });
-
-  test('the gesture-rotate writer serializes degrees with a complete center', () => {
-    expect(
-      writePositionals('gesture-rotate', {
-        degrees: 90,
-        x: 10,
-        y: 20,
-        velocity: 5,
-      } as CommandInput),
-    ).toEqual(['rotate', '90', '10', '20', '5']);
-  });
-
-  test('the gesture-rotate writer omits the center when no coordinates are given', () => {
-    expect(writePositionals('gesture-rotate', { degrees: 45 } as CommandInput)).toEqual([
-      'rotate',
-      '45',
-    ]);
-  });
-
-  test('the gesture-rotate writer rejects a half-specified center', () => {
-    expectInvalidArgs(
-      () => writePositionals('gesture-rotate', { degrees: 45, x: 10 } as CommandInput),
-      'gesture rotate center requires both x and y',
-    );
+    });
   });
 
-  test('the gesture-transform writer serializes the full parameter list', () => {
-    expect(
-      writePositionals('gesture-transform', {
-        x: 1,
-        y: 2,
-        dx: 3,
-        dy: 4,
-        scale: 1.5,
-        degrees: 30,
-        durationMs: 200,
-      } as CommandInput),
-    ).toEqual(['transform', '1', '2', '3', '4', '1.5', '30', '200']);
+  test('rejects pointerCount on non-pan gestures', () => {
+    expect(() =>
+      gestureDaemonWriters.gesture({ kind: 'pinch', scale: 2, pointerCount: 2 }),
+    ).toThrow(expect.objectContaining({ code: 'INVALID_ARGS' }));
   });
 });
diff --git a/src/commands/interaction/gesture.ts b/src/commands/interaction/gesture.ts
index 9837a3d13..27cb99cd9 100644
--- a/src/commands/interaction/gesture.ts
+++ b/src/commands/interaction/gesture.ts
@@ -1,220 +1,25 @@
 import { PUBLIC_COMMANDS } from '../../command-catalog.ts';
-import type { FlingOptions, RotateGestureOptions } from '../../client/client-types.ts';
+import { compactRecord } from '../command-input.ts';
 import type { CliFlags } from '../cli-grammar/flag-types.ts';
-import { AppError } from '../../kernel/errors.ts';
-import {
-  commonInputFromFlags,
-  direct,
-  optionalCliNumber,
-  optionalNumber,
-  requiredDaemonString,
-} from '../cli-grammar/common.ts';
-import type { CliReader, DaemonWriter, CommandInput } from '../cli-grammar/types.ts';
+import { commonInputFromFlags, request } from '../cli-grammar/common.ts';
+import type { CliReader, DaemonWriter } from '../cli-grammar/types.ts';
+import { readGestureInput } from './metadata.ts';
+import { gesturePayloadFromPositionals } from '../../contracts/gesture-normalization.ts';
 
 export const gestureCliReaders = {
   gesture: gestureInputFromCli,
 } satisfies Record<string, CliReader>;
 
 export const gestureDaemonWriters = {
-  gesture: direct(PUBLIC_COMMANDS.gesture, gesturePositionals),
-  'gesture-pan': direct(PUBLIC_COMMANDS.gesture, panPositionals),
-  'gesture-fling': direct(PUBLIC_COMMANDS.gesture, (input) =>
-    flingPositionals(input as FlingOptions),
-  ),
-  'gesture-swipe': direct(PUBLIC_COMMANDS.gesture, swipePresetPositionals),
-  'gesture-pinch': direct(PUBLIC_COMMANDS.gesture, pinchPositionals),
-  'gesture-rotate': direct(PUBLIC_COMMANDS.gesture, (input) =>
-    rotateGesturePositionals(input as RotateGestureOptions),
-  ),
-  'gesture-transform': direct(PUBLIC_COMMANDS.gesture, transformPositionals),
+  gesture: (input) => {
+    const gesture = readGestureInput(input);
+    return request(PUBLIC_COMMANDS.gesture, [], input, compactRecord(gesture));
+  },
 } satisfies Record<string, DaemonWriter>;
 
-// fallow-ignore-next-line complexity
-function gesturePositionals(input: CommandInput): string[] {
-  switch (input.kind) {
-    case 'pan':
-      return [
-        'pan',
-        String(input.origin?.x),
-        String(input.origin?.y),
-        String(input.delta?.x),
-        String(input.delta?.y),
-        ...optionalNumber(input.durationMs),
-      ];
-    case 'fling':
-      return [
-        'fling',
-        requiredDaemonString(input.direction, 'gesture fling requires direction'),
-        String(input.origin?.x),
-        String(input.origin?.y),
-        ...optionalNumber(input.distance),
-        ...optionalNumber(input.durationMs),
-      ];
-    case 'swipe':
-      return swipePresetPositionals(input);
-    case 'pinch':
-      return [
-        'pinch',
-        String(input.scale),
-        ...optionalNumber(input.origin?.x),
-        ...optionalNumber(input.origin?.y),
-      ];
-    case 'rotate':
-      return [
-        'rotate',
-        String(input.degrees),
-        ...optionalNumber(input.origin?.x),
-        ...optionalNumber(input.origin?.y),
-        ...optionalNumber(input.velocity),
-      ];
-    case 'transform':
-      return [
-        'transform',
-        String(input.origin?.x),
-        String(input.origin?.y),
-        String(input.delta?.x),
-        String(input.delta?.y),
-        String(input.scale),
-        String(input.degrees),
-        ...optionalNumber(input.durationMs),
-      ];
-    default:
-      throw new AppError(
-        'INVALID_ARGS',
-        'gesture requires pan, fling, swipe, pinch, rotate, or transform',
-      );
-  }
-}
-
-function swipePresetPositionals(input: CommandInput): string[] {
-  return [
-    'swipe',
-    requiredDaemonString(input.preset, 'gesture swipe requires preset'),
-    ...optionalNumber(input.durationMs),
-  ];
-}
-
-function panPositionals(input: CommandInput): string[] {
-  return [
-    'pan',
-    String(input.x),
-    String(input.y),
-    String(input.dx),
-    String(input.dy),
-    ...optionalNumber(input.durationMs),
-  ];
-}
-
-function flingPositionals(input: FlingOptions): string[] {
-  const distance = input.durationMs !== undefined ? (input.distance ?? 180) : input.distance;
-  return [
-    'fling',
-    input.direction,
-    String(input.x),
-    String(input.y),
-    ...optionalNumber(distance),
-    ...optionalNumber(input.durationMs),
-  ];
-}
-
-function pinchPositionals(input: CommandInput): string[] {
-  return ['pinch', String(input.scale), ...optionalNumber(input.x), ...optionalNumber(input.y)];
-}
-
-function rotateGesturePositionals(input: RotateGestureOptions): string[] {
-  assertCompleteCenter(input);
-  const center =
-    input.x === undefined || input.y === undefined ? [] : [String(input.x), String(input.y)];
-  return ['rotate', String(input.degrees), ...center, ...optionalNumber(input.velocity)];
-}
-
-function transformPositionals(input: CommandInput): string[] {
-  return [
-    'transform',
-    String(input.x),
-    String(input.y),
-    String(input.dx),
-    String(input.dy),
-    String(input.scale),
-    String(input.degrees),
-    ...optionalNumber(input.durationMs),
-  ];
-}
-
-// fallow-ignore-next-line complexity
 function gestureInputFromCli(positionals: string[], flags: CliFlags): Record<string, unknown> {
-  const subcommand = positionals[0];
-  const args = positionals.slice(1);
-  const common = commonInputFromFlags(flags);
-  switch (subcommand) {
-    case 'pan':
-      return {
-        ...common,
-        kind: subcommand,
-        origin: { x: Number(args[0]), y: Number(args[1]) },
-        delta: { x: Number(args[2]), y: Number(args[3]) },
-        durationMs: optionalCliNumber(args[4]),
-      };
-    case 'fling':
-      return {
-        ...common,
-        kind: subcommand,
-        direction: args[0],
-        origin: { x: Number(args[1]), y: Number(args[2]) },
-        distance: optionalCliNumber(args[3]),
-        durationMs: optionalCliNumber(args[4]),
-      };
-    case 'swipe':
-      return {
-        ...common,
-        kind: subcommand,
-        preset: args[0],
-        durationMs: optionalCliNumber(args[1]),
-      };
-    case 'pinch':
-      return {
-        ...common,
-        kind: subcommand,
-        scale: Number(args[0]),
-        origin:
-          args[1] === undefined || args[2] === undefined
-            ? undefined
-            : { x: Number(args[1]), y: Number(args[2]) },
-      };
-    case 'rotate':
-      return {
-        ...common,
-        kind: subcommand,
-        degrees: Number(args[0]),
-        origin:
-          args[1] === undefined || args[2] === undefined
-            ? undefined
-            : { x: Number(args[1]), y: Number(args[2]) },
-        velocity: optionalCliNumber(args[3]),
-      };
-    case 'transform':
-      return {
-        ...common,
-        kind: subcommand,
-        origin: { x: Number(args[0]), y: Number(args[1]) },
-        delta: { x: Number(args[2]), y: Number(args[3]) },
-        scale: Number(args[4]),
-        degrees: Number(args[5]),
-        durationMs: optionalCliNumber(args[6]),
-      };
-    default:
-      throw new AppError(
-        'INVALID_ARGS',
-        'gesture requires pan, fling, swipe, pinch, rotate, or transform',
-      );
-  }
-}
-
-function assertCompleteCenter(input: RotateGestureOptions): void {
-  if (
-    (input.x === undefined && input.y !== undefined) ||
-    (input.x !== undefined && input.y === undefined)
-  ) {
-    throw new AppError('INVALID_ARGS', 'gesture rotate center requires both x and y');
-  }
+  return {
+    ...commonInputFromFlags(flags),
+    ...gesturePayloadFromPositionals(positionals, flags.pointerCount),
+  };
 }
diff --git a/src/commands/interaction/index.ts b/src/commands/interaction/index.ts
index bb40116b1..413b1d467 100644
--- a/src/commands/interaction/index.ts
+++ b/src/commands/interaction/index.ts
@@ -107,7 +107,8 @@ const interactionCliSchemas = {
     allowedFlags: [...postActionObservationCliFlags('longpress'), ...SELECTOR_SNAPSHOT_FLAGS],
   },
   swipe: {
-    helpDescription: 'Swipe coordinates with optional repeat pattern',
+    helpDescription:
+      'Quick coordinate fling with optional repeat pattern. The historical duration positional is accepted as a deprecated alias to pan.',
     positionalArgs: ['x1', 'y1', 'x2', 'y2', 'durationMs?'],
     allowedFlags: ['count', 'pauseMs', 'pattern'],
   },
@@ -115,10 +116,11 @@ const interactionCliSchemas = {
     usageOverride: 'gesture <pan|fling|swipe|pinch|rotate|transform> ...',
     listUsageOverride: 'gesture <pan|fling|swipe|pinch|rotate|transform> ...',
     helpDescription:
-      'Run touch gestures: pan <x> <y> <dx> <dy> [durationMs], fling <up|down|left|right> <x> <y> [distance] [durationMs], swipe <left|right|left-edge|right-edge> [durationMs], pinch <scale> [x] [y], rotate <degrees> [x] [y] [velocity], or transform <x> <y> <dx> <dy> <scale> <degrees> [durationMs]. For command plans, output only command lines. Android transform verification should use all app-observable effects, for example wait text "pan changed yes", wait text "pinch changed yes", and wait text "rotate changed yes", not exact transform values.',
+      'Run touch gestures: pan <x> <y> <dx> <dy> [durationMs], fling <up|down|left|right> <x> <y> [distance], swipe <left|right|left-edge|right-edge>, pinch <scale> [x] [y], rotate <degrees> [x] [y], or transform <x> <y> <dx> <dy> <scale> <degrees> [durationMs]. Historical swipe/fling duration and rotate velocity arguments remain deprecated compatibility aliases. For command plans, output only command lines. Android transform verification should use all app-observable effects, for example wait text "pan changed yes", wait text "pinch changed yes", and wait text "rotate changed yes", not exact transform values.',
     summary: 'Run pan, fling, swipe, pinch, rotate, or transform gestures',
     positionalArgs: ['pan|fling|swipe|pinch|rotate|transform', 'args?'],
     allowsExtraPositionals: true,
+    allowedFlags: ['pointerCount'],
   },
   focus: {
     positionalArgs: ['x', 'y'],
@@ -145,9 +147,6 @@ const interactionCliSchemas = {
 
 type InteractionCommandMetadata = (typeof interactionCommandMetadata)[number];
 type InteractionCommandName = InteractionCommandMetadata['name'];
-const { gesture: _gestureDaemonWriter, ...gestureProjectionAliasDaemonWriters } =
-  gestureDaemonWriters;
-
 function postActionObservationCliFlags(command: InteractionCommandName): readonly FlagKey[] {
   const flags: FlagKey[] = [];
   if (commandSupportsVerifyEvidence(command)) flags.push('verify');
@@ -332,7 +331,6 @@ const gestureCommandFacet = defineCommandFacet({
   cliSchema: interactionCliSchemas.gesture,
   cliReader: gestureCliReaders.gesture,
   daemonWriter: gestureDaemonWriters.gesture,
-  extraDaemonWriters: gestureProjectionAliasDaemonWriters,
 });
 
 export const interactionCommandFamily = defineCommandFamilyFromFacets({
@@ -435,6 +433,7 @@ function toPanOptions(input: PanInput): PanOptions {
     y: input.origin.y,
     dx: input.delta.x,
     dy: input.delta.y,
+    pointerCount: input.pointerCount,
     durationMs: input.durationMs,
   };
 }
diff --git a/src/commands/interaction/interactions.test.ts b/src/commands/interaction/interactions.test.ts
new file mode 100644
index 000000000..e8e77948d
--- /dev/null
+++ b/src/commands/interaction/interactions.test.ts
@@ -0,0 +1,23 @@
+import { expect, test } from 'vitest';
+import { interactionDaemonWriters } from './interactions.ts';
+
+test('swipe writes only typed daemon input', () => {
+  const request = interactionDaemonWriters.swipe({
+    from: { x: 10, y: 20 },
+    to: { x: 30, y: 40 },
+    durationMs: 300,
+    count: 2,
+    pauseMs: 10,
+    pattern: 'ping-pong',
+  });
+
+  expect(request.positionals).toEqual([]);
+  expect(request.input).toEqual({
+    from: { x: 10, y: 20 },
+    to: { x: 30, y: 40 },
+    durationMs: 300,
+    count: 2,
+    pauseMs: 10,
+    pattern: 'ping-pong',
+  });
+});
diff --git a/src/commands/interaction/interactions.ts b/src/commands/interaction/interactions.ts
index 26afc7b9b..5e2eb6b1d 100644
--- a/src/commands/interaction/interactions.ts
+++ b/src/commands/interaction/interactions.ts
@@ -11,6 +11,7 @@ import {
   readInteractionTargetFromPositionals,
 } from '../../core/interaction-positionals.ts';
 import { AppError } from '../../kernel/errors.ts';
+import { swipePayloadFromPositionals } from '../../contracts/gesture-normalization.ts';
 import type { ScrollInputDirection } from './runtime/gestures.ts';
 import {
   commonInputFromFlags,
@@ -29,7 +30,7 @@ import {
   settleInputFromFlags,
   targetInputFromClientTarget,
 } from '../cli-grammar/common.ts';
-import type { CliReader, DaemonWriter, CommandInput } from '../cli-grammar/types.ts';
+import type { CliReader, DaemonWriter } from '../cli-grammar/types.ts';
 
 export const interactionCliReaders = {
   click: (positionals, flags) => ({
@@ -61,12 +62,11 @@ export const interactionCliReaders = {
   },
   swipe: (positionals, flags) => ({
     ...commonInputFromFlags(flags),
-    from: { x: Number(positionals[0]), y: Number(positionals[1]) },
-    to: { x: Number(positionals[2]), y: Number(positionals[3]) },
-    durationMs: optionalCliNumber(positionals[4]),
-    count: flags.count,
-    pauseMs: flags.pauseMs,
-    pattern: flags.pattern,
+    ...swipePayloadFromPositionals(positionals, {
+      count: flags.count,
+      pauseMs: flags.pauseMs,
+      pattern: flags.pattern,
+    }),
   }),
   focus: (positionals, flags) => ({
     ...commonInputFromFlags(flags),
@@ -117,7 +117,15 @@ export const interactionDaemonWriters = {
   longpress: direct(PUBLIC_COMMANDS.longPress, (input) =>
     longPressPositionals(input as LongPressOptions),
   ),
-  swipe: direct(PUBLIC_COMMANDS.swipe, swipePositionals),
+  swipe: (input) =>
+    request(PUBLIC_COMMANDS.swipe, [], input, {
+      from: input.from,
+      to: input.to,
+      durationMs: input.durationMs,
+      count: input.count,
+      pauseMs: input.pauseMs,
+      pattern: input.pattern,
+    }),
   focus: direct(PUBLIC_COMMANDS.focus, (input) => [String(input.x), String(input.y)]),
   type: direct(PUBLIC_COMMANDS.type, (input) => typePositionals(input as TypeTextOptions)),
   fill: direct(PUBLIC_COMMANDS.fill, (input) => fillPositionals(input as FillOptions)),
@@ -153,16 +161,6 @@ function fillPositionals(input: FillOptions): string[] {
   return [...interactionTargetPositionals(input), input.text];
 }
 
-function swipePositionals(input: CommandInput): string[] {
-  return [
-    String(input.from?.x),
-    String(input.from?.y),
-    String(input.to?.x),
-    String(input.to?.y),
-    ...optionalNumber(input.durationMs),
-  ];
-}
-
 function readScrollDirection(value: string | undefined): ScrollInputDirection {
   if (
     value === 'up' ||
diff --git a/src/commands/interaction/metadata.ts b/src/commands/interaction/metadata.ts
index 0edb27afc..be7f0651d 100644
--- a/src/commands/interaction/metadata.ts
+++ b/src/commands/interaction/metadata.ts
@@ -1,5 +1,4 @@
 import { defineCommandMetadata } from '../command-contract.ts';
-import { GESTURE_KINDS } from '../../command-catalog.ts';
 import {
   booleanField,
   elementTargetField,
@@ -8,32 +7,27 @@ import {
   integerField,
   interactionTargetField,
   numberField,
-  optionalInteger,
   pointField,
   readCommonInput,
   readFieldInput,
   readInputRecord,
-  readPoint,
   repeatedFields,
-  requiredEnum,
   requiredField,
-  requiredNumber,
   selectorSnapshotFields,
   stringField,
   type CommandFieldMap,
   type CommonCommandInput,
   type InferCommandInput,
-  type PointInput,
 } from '../command-input.ts';
 import { defineFieldCommandMetadata } from '../field-command-contract.ts';
 import { CLICK_BUTTONS } from '../../core/click-button.ts';
 import { SCROLL_DURATION_MAX_MS } from '../../contracts/scroll-command.ts';
 import {
   SCROLL_DIRECTIONS,
+  SWIPE_PAUSE_MAX_MS,
   SWIPE_PATTERNS,
   SWIPE_PRESETS,
-  type ScrollDirection,
-  type SwipePreset,
+  SWIPE_REPETITION_MAX,
 } from '../../contracts/scroll-gesture.ts';
 import { SCROLL_INPUT_DIRECTIONS } from './runtime/gestures.ts';
 import { FIND_LOCATORS } from '../../selectors/find.ts';
@@ -42,6 +36,16 @@ import {
   commandSupportsVerifyEvidence,
 } from '../../core/command-descriptor/registry.ts';
 import type { PostActionObservationSupportFor } from '../../core/command-descriptor/post-action-observation.ts';
+import {
+  GESTURE_KINDS,
+  readGesturePayload,
+  type FlingGesturePayload,
+  type PanGesturePayload,
+  type PinchGesturePayload,
+  type RotateGesturePayload,
+  type SwipeGesturePayload,
+  type TransformGesturePayload,
+} from '../../contracts/gesture-input.ts';
 
 const FIND_ACTION_VALUES = [
   'click',
@@ -135,9 +139,12 @@ const longPressFields = {
 const swipeFields = {
   from: requiredField(pointField('Swipe start point.')),
   to: requiredField(pointField('Swipe end point.')),
-  durationMs: integerField('Swipe duration in milliseconds.', { min: 0 }),
-  count: integerField('Number of swipe repetitions.', { min: 1 }),
-  pauseMs: integerField('Pause between repeated swipes.', { min: 0 }),
+  durationMs: integerField('Deprecated: timed movement is a pan; omit for swipe.', {
+    min: 16,
+    max: 10_000,
+  }),
+  count: integerField('Number of swipe repetitions.', { min: 1, max: SWIPE_REPETITION_MAX }),
+  pauseMs: integerField('Pause between repeated swipes.', { min: 0, max: SWIPE_PAUSE_MAX_MS }),
   pattern: enumField(SWIPE_PATTERNS),
 };
 
@@ -197,8 +204,12 @@ const gestureFields = {
   distance: integerField('Fling distance.', { min: 0 }),
   scale: numberField('Pinch or transform scale.'),
   degrees: numberField('Rotation in degrees.'),
-  velocity: integerField('Rotate gesture velocity.', { min: 0 }),
-  durationMs: integerField('Gesture duration in milliseconds.', { min: 0 }),
+  velocity: numberField('Deprecated: rotation pacing is derived from degrees; must be non-zero.'),
+  durationMs: integerField(
+    'Pan/transform duration. Deprecated on swipe/fling; timed movement is a pan.',
+    { min: 16, max: 10_000 },
+  ),
+  pointerCount: integerField('Pan touch pointer count (1 or 2).', { min: 1, max: 2 }),
 };
 
 export type ClickInput = InferCommandInput<typeof clickFields>;
@@ -207,48 +218,12 @@ export type FillInput = InferCommandInput<typeof fillFields>;
 export type LongPressInput = InferCommandInput<typeof longPressFields>;
 export type GetInput = InferCommandInput<typeof getFields>;
 
-export type PanInput = CommonCommandInput & {
-  kind: 'pan';
-  origin: PointInput;
-  delta: PointInput;
-  durationMs?: number;
-};
-
-export type FlingInput = CommonCommandInput & {
-  kind: 'fling';
-  direction: ScrollDirection;
-  origin: PointInput;
-  distance?: number;
-  durationMs?: number;
-};
-
-export type SwipeGestureInput = CommonCommandInput & {
-  kind: 'swipe';
-  preset: SwipePreset;
-  durationMs?: number;
-};
-
-export type PinchInput = CommonCommandInput & {
-  kind: 'pinch';
-  scale: number;
-  origin?: PointInput;
-};
-
-export type RotateInput = CommonCommandInput & {
-  kind: 'rotate';
-  degrees: number;
-  origin?: PointInput;
-  velocity?: number;
-};
-
-export type TransformInput = CommonCommandInput & {
-  kind: 'transform';
-  origin: PointInput;
-  delta: PointInput;
-  scale: number;
-  degrees: number;
-  durationMs?: number;
-};
+export type PanInput = CommonCommandInput & PanGesturePayload;
+export type FlingInput = CommonCommandInput & FlingGesturePayload;
+export type SwipeGestureInput = CommonCommandInput & SwipeGesturePayload;
+export type PinchInput = CommonCommandInput & PinchGesturePayload;
+export type RotateInput = CommonCommandInput & RotateGesturePayload;
+export type TransformInput = CommonCommandInput & TransformGesturePayload;
 
 export type GestureInput =
   | PanInput
@@ -293,63 +268,9 @@ export const interactionCommandMetadata = [
   }),
 ] as const;
 
-function readGestureInput(input: unknown): GestureInput {
+export function readGestureInput(input: unknown): GestureInput {
   const record = readInputRecord(input);
-  const common = readCommonInput(record);
-  const kind = requiredEnum(record, 'kind', GESTURE_KINDS);
-  if (kind === 'pan') {
-    return {
-      ...common,
-      kind,
-      origin: readPoint(record, 'origin'),
-      delta: readPoint(record, 'delta'),
-      durationMs: optionalInteger(record, 'durationMs', { min: 0 }),
-    };
-  }
-  if (kind === 'fling') {
-    return {
-      ...common,
-      kind,
-      direction: requiredEnum(record, 'direction', SCROLL_DIRECTIONS),
-      origin: readPoint(record, 'origin'),
-      distance: optionalInteger(record, 'distance', { min: 0 }),
-      durationMs: optionalInteger(record, 'durationMs', { min: 0 }),
-    };
-  }
-  if (kind === 'swipe') {
-    return {
-      ...common,
-      kind,
-      preset: requiredEnum(record, 'preset', SWIPE_PRESETS),
-      durationMs: optionalInteger(record, 'durationMs', { min: 0 }),
-    };
-  }
-  if (kind === 'pinch') {
-    return {
-      ...common,
-      kind,
-      scale: requiredNumber(record, 'scale'),
-      origin: optionalPoint(record, 'origin'),
-    };
-  }
-  if (kind === 'rotate') {
-    return {
-      ...common,
-      kind,
-      degrees: requiredNumber(record, 'degrees'),
-      origin: optionalPoint(record, 'origin'),
-      velocity: optionalInteger(record, 'velocity', { min: 0 }),
-    };
-  }
-  return {
-    ...common,
-    kind,
-    origin: readPoint(record, 'origin'),
-    delta: readPoint(record, 'delta'),
-    scale: requiredNumber(record, 'scale'),
-    degrees: requiredNumber(record, 'degrees'),
-    durationMs: optionalInteger(record, 'durationMs', { min: 0 }),
-  };
+  return { ...readCommonInput(record), ...readGesturePayload(record) } as GestureInput;
 }
 
 function defineInteractionCommandMetadata<
@@ -358,7 +279,3 @@ function defineInteractionCommandMetadata<
 >(name: TName, fields: TFields) {
   return defineFieldCommandMetadata(name, interactionCommandDescriptions[name], fields);
 }
-
-function optionalPoint(record: Record<string, unknown>, key: string): PointInput | undefined {
-  return record[key] === undefined ? undefined : readPoint(record, key);
-}
diff --git a/src/commands/interaction/runtime/__tests__/test-utils/index.ts b/src/commands/interaction/runtime/__tests__/test-utils/index.ts
index 37487943a..aa5e9ab9d 100644
--- a/src/commands/interaction/runtime/__tests__/test-utils/index.ts
+++ b/src/commands/interaction/runtime/__tests__/test-utils/index.ts
@@ -318,6 +318,7 @@ export function createInteractionDevice(
     Pick<
       AgentDeviceBackend,
       | 'captureSnapshot'
+      | 'resolveGestureViewport'
       | 'tap'
       | 'tapTarget'
       | 'fill'
@@ -326,8 +327,7 @@ export function createInteractionDevice(
       | 'focus'
       | 'longPress'
       | 'scroll'
-      | 'swipe'
-      | 'pinch'
+      | 'performGesture'
     >
   > & {
     platform?: AgentDeviceBackend['platform'];
@@ -339,6 +339,9 @@ export function createInteractionDevice(
       platform: overrides.platform ?? 'ios',
       captureSnapshot: async (...args) =>
         overrides.captureSnapshot ? await overrides.captureSnapshot(...args) : { snapshot },
+      resolveGestureViewport: overrides.resolveGestureViewport
+        ? async (...args) => await overrides.resolveGestureViewport?.(...args)
+        : undefined,
       tap: async (...args) => await overrides.tap?.(...args),
       tapTarget: overrides.tapTarget
         ? async (...args) => await overrides.tapTarget?.(...args)
@@ -353,8 +356,7 @@ export function createInteractionDevice(
         ? async (...args) => await overrides.longPress?.(...args)
         : undefined,
       scroll: overrides.scroll ? async (...args) => await overrides.scroll?.(...args) : undefined,
-      swipe: overrides.swipe ? async (...args) => await overrides.swipe?.(...args) : undefined,
-      pinch: overrides.pinch ? async (...args) => await overrides.pinch?.(...args) : undefined,
+      performGesture: overrides.performGesture,
     } satisfies AgentDeviceBackend,
     artifacts: createLocalArtifactAdapter(),
     sessions: createMemorySessionStore([
diff --git a/src/commands/interaction/runtime/gesture-command.ts b/src/commands/interaction/runtime/gesture-command.ts
new file mode 100644
index 000000000..d0de9b702
--- /dev/null
+++ b/src/commands/interaction/runtime/gesture-command.ts
@@ -0,0 +1,101 @@
+import type { AgentDeviceRuntime, CommandContext } from '../../../runtime-contract.ts';
+import type { GestureIntent, GestureSemanticInput } from '../../../contracts/gesture-plan-types.ts';
+import { buildGesturePlan } from '../../../contracts/gesture-plan.ts';
+import type { Point, Rect } from '../../../kernel/snapshot.ts';
+import { AppError } from '../../../kernel/errors.ts';
+import { successText } from '../../../utils/success-text.ts';
+import { toBackendContext } from '../../runtime-common.ts';
+import {
+  toBackendResult,
+  type BackendResultEnvelope,
+  type RuntimeCommand,
+} from '../../runtime-types.ts';
+import { assertSupportedInteractionSurface, captureInteractionSnapshot } from './resolution.ts';
+import { resolveVisibleSnapshotViewport } from './viewport.ts';
+
+export type GestureCommandOptions = CommandContext & {
+  gesture: GestureSemanticInput;
+};
+
+export type GestureCommandResult = {
+  kind: GestureIntent;
+  durationMs: number;
+  pointerCount: 1 | 2;
+  from: Point;
+  to: Point;
+} & BackendResultEnvelope;
+
+export const gestureCommand: RuntimeCommand<GestureCommandOptions, GestureCommandResult> = async (
+  runtime,
+  options,
+) => {
+  if (!runtime.backend.performGesture) {
+    throw new AppError('UNSUPPORTED_OPERATION', 'gesture is not supported by this backend');
+  }
+  await assertSupportedInteractionSurface(runtime, options, options.gesture.intent);
+  const viewport = await captureGestureViewport(runtime, options);
+  const plan = buildGesturePlan(options.gesture, viewport, runtime.backend.platform);
+  const backendResult = await runtime.backend.performGesture(
+    toBackendContext(runtime, options),
+    plan,
+  );
+  const formattedBackendResult = toBackendResult(backendResult);
+  const from = centroidAt(plan.pointers, 0);
+  const to = centroidAt(plan.pointers, -1);
+  return {
+    kind: plan.intent,
+    durationMs: plan.durationMs,
+    pointerCount: plan.topology === 'single' ? 1 : 2,
+    from,
+    to,
+    ...(formattedBackendResult ? { backendResult: formattedBackendResult } : {}),
+    ...successText(gestureMessage(options.gesture, from, to)),
+  };
+};
+
+async function captureGestureViewport(
+  runtime: AgentDeviceRuntime,
+  options: GestureCommandOptions,
+): Promise<Rect> {
+  const backendViewport = await runtime.backend.resolveGestureViewport?.(
+    toBackendContext(runtime, options),
+  );
+  if (backendViewport) return backendViewport;
+  const capture = await captureInteractionSnapshot(runtime, options, false);
+  return resolveVisibleSnapshotViewport(capture.snapshot.nodes, 'gesture');
+}
+
+function centroidAt(
+  pointers: readonly { samples: readonly { point: Point }[] }[],
+  index: 0 | -1,
+): Point {
+  const points = pointers.map((pointer) =>
+    index === 0 ? pointer.samples[0]?.point : pointer.samples.at(-1)?.point,
+  );
+  if (points.some((point) => point === undefined)) {
+    throw new AppError('COMMAND_FAILED', 'Gesture plan did not contain endpoint samples.');
+  }
+  const defined = points as Point[];
+  return {
+    x: defined.reduce((sum, point) => sum + point.x, 0) / defined.length,
+    y: defined.reduce((sum, point) => sum + point.y, 0) / defined.length,
+  };
+}
+
+function gestureMessage(input: GestureSemanticInput, from: Point, to: Point): string {
+  switch (input.intent) {
+    case 'pan': {
+      const origin = 'preset' in input ? from : input.origin;
+      const delta = 'preset' in input ? { x: to.x - from.x, y: to.y - from.y } : input.delta;
+      return `Panned (${origin.x}, ${origin.y}) by (${delta.x}, ${delta.y})`;
+    }
+    case 'fling':
+      return 'direction' in input ? `Flung ${input.direction}` : 'Flung';
+    case 'pinch':
+      return `Pinched to scale ${input.scale}`;
+    case 'rotate':
+      return `Rotated gesture ${input.degrees} degrees`;
+    case 'transform':
+      return `Requested transform gesture by (${input.delta.x}, ${input.delta.y}), scale ${input.scale}, rotate ${input.degrees} degrees`;
+  }
+}
diff --git a/src/commands/interaction/runtime/gestures.test.ts b/src/commands/interaction/runtime/gestures.test.ts
index 4fff1584d..11a178548 100644
--- a/src/commands/interaction/runtime/gestures.test.ts
+++ b/src/commands/interaction/runtime/gestures.test.ts
@@ -6,7 +6,6 @@ import {
   createInteractionDevice,
   runtimeScrollSnapshot,
   selectorSnapshot,
-  snapshotWithOffscreenContent,
 } from './__tests__/test-utils/index.ts';
 
 test('runtime focus and longPress share selector/ref target resolution', async () => {
@@ -278,105 +277,7 @@ test('runtime scroll bottom keeps scoped snapshot failures scoped', async () =>
   assert.equal(snapshotCount, 2);
 });
 
-test('runtime swipe supports explicit and viewport-derived targets', async () => {
-  const calls: unknown[] = [];
-  const device = createInteractionDevice(selectorSnapshot(), {
-    swipe: async (_context, from, to, options) => {
-      calls.push({ from, to, durationMs: options?.durationMs });
-    },
-  });
-
-  const explicit = await device.interactions.swipe({
-    from: selector('label=Continue'),
-    to: { x: 200, y: 40 },
-    durationMs: 300,
-    session: 'default',
-  });
-  const directional = await device.interactions.swipe({
-    direction: 'left',
-    distance: 25,
-    session: 'default',
-  });
-
-  assert.deepEqual(explicit.from, { x: 60, y: 40 });
-  assert.deepEqual(directional.from, { x: 60, y: 40 });
-  assert.deepEqual(directional.to, { x: 35, y: 40 });
-  assert.deepEqual(calls, [
-    { from: { x: 60, y: 40 }, to: { x: 200, y: 40 }, durationMs: 300 },
-    { from: { x: 60, y: 40 }, to: { x: 35, y: 40 }, durationMs: undefined },
-  ]);
-});
-
-test('runtime directional swipe uses the visible viewport instead of off-screen content bounds', async () => {
-  const calls: unknown[] = [];
-  const device = createInteractionDevice(snapshotWithOffscreenContent(), {
-    swipe: async (_context, from, to) => {
-      calls.push({ from, to });
-    },
-  });
-
-  const result = await device.interactions.swipe({
-    direction: 'left',
-    distance: 25,
-    session: 'default',
-  });
-
-  assert.deepEqual(result.from, { x: 50, y: 50 });
-  assert.deepEqual(result.to, { x: 25, y: 50 });
-  assert.deepEqual(calls, [{ from: { x: 50, y: 50 }, to: { x: 25, y: 50 } }]);
-});
-
-test('runtime gesture swipe presets use stable viewport lanes', async () => {
-  const calls: unknown[] = [];
-  const device = createInteractionDevice(snapshotWithOffscreenContent(), {
-    platform: 'android',
-    swipe: async (_context, from, to, options) => {
-      calls.push({ from, to, durationMs: options?.durationMs });
-    },
-  });
-
-  const pageSwipe = await device.interactions.swipe({
-    preset: 'left',
-    durationMs: 300,
-    session: 'default',
-  });
-  const edgeSwipe = await device.interactions.swipe({
-    preset: 'right-edge',
-    durationMs: 350,
-    session: 'default',
-  });
-
-  assert.deepEqual(pageSwipe.from, { x: 85, y: 50 });
-  assert.deepEqual(pageSwipe.to, { x: 15, y: 50 });
-  assert.deepEqual(edgeSwipe.from, { x: 8, y: 50 });
-  assert.deepEqual(edgeSwipe.to, { x: 85, y: 50 });
-  assert.deepEqual(calls, [
-    { from: { x: 85, y: 50 }, to: { x: 15, y: 50 }, durationMs: 300 },
-    { from: { x: 8, y: 50 }, to: { x: 85, y: 50 }, durationMs: 350 },
-  ]);
-});
-
-test('runtime iOS in-page swipe presets avoid edge-navigation lanes', async () => {
-  const calls: unknown[] = [];
-  const device = createInteractionDevice(snapshotWithOffscreenContent(), {
-    platform: 'ios',
-    swipe: async (_context, from, to, options) => {
-      calls.push({ from, to, durationMs: options?.durationMs });
-    },
-  });
-
-  const pageSwipe = await device.interactions.swipe({
-    preset: 'right',
-    durationMs: 300,
-    session: 'default',
-  });
-
-  assert.deepEqual(pageSwipe.from, { x: 15, y: 50 });
-  assert.deepEqual(pageSwipe.to, { x: 85, y: 50 });
-  assert.deepEqual(calls, [{ from: { x: 15, y: 50 }, to: { x: 85, y: 50 }, durationMs: 300 }]);
-});
-
-test('runtime viewport gestures reject inspect-only macOS surfaces', async () => {
+test('runtime viewport scroll rejects inspect-only macOS surfaces', async () => {
   for (const surface of ['desktop', 'menubar'] as const) {
     const device = createInteractionDevice(selectorSnapshot(), {
       platform: 'macos',
@@ -384,12 +285,6 @@ test('runtime viewport gestures reject inspect-only macOS surfaces', async () =>
       scroll: async () => {
         throw new Error(`${surface} scroll should be rejected before backend call`);
       },
-      swipe: async () => {
-        throw new Error(`${surface} swipe should be rejected before backend call`);
-      },
-      pinch: async () => {
-        throw new Error(`${surface} pinch should be rejected before backend call`);
-      },
     });
 
     await assert.rejects(
@@ -401,55 +296,35 @@ test('runtime viewport gestures reject inspect-only macOS surfaces', async () =>
         }),
       new RegExp(`scroll is not supported on macOS ${surface}`),
     );
-    await assert.rejects(
-      () =>
-        device.interactions.swipe({
-          direction: 'left',
-          session: 'default',
-        }),
-      new RegExp(`swipe is not supported on macOS ${surface}`),
-    );
-    await assert.rejects(
-      () =>
-        device.interactions.swipe({
-          from: { x: 10, y: 20 },
-          to: { x: 30, y: 20 },
-          session: 'default',
-        }),
-      new RegExp(`swipe is not supported on macOS ${surface}`),
-    );
-    await assert.rejects(
-      () =>
-        device.interactions.pinch({
-          scale: 1.2,
-          session: 'default',
-        }),
-      new RegExp(`pinch is not supported on macOS ${surface}`),
-    );
   }
 });
 
-test('runtime pinch is backend-gated and resolves optional center targets', async () => {
-  const calls: unknown[] = [];
-  const unsupported = createInteractionDevice(selectorSnapshot());
-  await assert.rejects(
-    () => unsupported.interactions.pinch({ scale: 1.2 }),
-    /pinch is not supported/,
-  );
-
+test('runtime multi-touch planning prefers backend viewport geometry without a snapshot capture', async () => {
+  let capturedPlan: unknown;
   const device = createInteractionDevice(selectorSnapshot(), {
-    pinch: async (_context, options) => {
-      calls.push(options);
+    platform: 'android',
+    captureSnapshot: async () => {
+      throw new Error('gesture viewport must not capture Android accessibility state');
+    },
+    resolveGestureViewport: async () => ({ x: 0, y: 0, width: 300, height: 600 }),
+    performGesture: async (_context, plan) => {
+      capturedPlan = plan;
     },
   });
 
-  const result = await device.interactions.pinch({
-    scale: 0.8,
-    center: ref('@e1'),
-    session: 'default',
+  await device.interactions.gesture({
+    gesture: {
+      intent: 'pan',
+      origin: { x: 150, y: 300 },
+      delta: { x: 20, y: 0 },
+      pointerCount: 2,
+    },
   });
 
-  assert.equal(result.kind, 'pinch');
-  assert.deepEqual(result.center, { x: 60, y: 40 });
-  assert.deepEqual(calls, [{ scale: 0.8, center: { x: 60, y: 40 } }]);
+  assert.deepEqual(
+    capturedPlan && typeof capturedPlan === 'object' && 'viewport' in capturedPlan
+      ? capturedPlan.viewport
+      : undefined,
+    { x: 0, y: 0, width: 300, height: 600 },
+  );
 });
diff --git a/src/commands/interaction/runtime/gestures.ts b/src/commands/interaction/runtime/gestures.ts
index ba82474ea..86a229ad2 100644
--- a/src/commands/interaction/runtime/gestures.ts
+++ b/src/commands/interaction/runtime/gestures.ts
@@ -1,13 +1,6 @@
 import { AppError } from '../../../kernel/errors.ts';
-import type { Point, Rect, SnapshotNode, SnapshotState } from '../../../kernel/snapshot.ts';
-import { centerOfRect } from '../../../kernel/snapshot.ts';
-import {
-  buildSwipePresetGesturePlan,
-  parseSwipePreset,
-  type GestureReferenceFrame,
-  type ScrollDirection,
-  type SwipePreset,
-} from '../../../contracts/scroll-gesture.ts';
+import type { Point } from '../../../kernel/snapshot.ts';
+import type { ScrollDirection } from '../../../contracts/scroll-gesture.ts';
 import {
   assertExclusiveScrollDistanceInputs,
   honoredScrollDurationMs,
@@ -16,7 +9,6 @@ import {
 import type { AgentDeviceRuntime, CommandContext } from '../../../runtime-contract.ts';
 import { requireIntInRange } from '../../../utils/validation.ts';
 import { successText } from '../../../utils/success-text.ts';
-import { isNodeVisibleInEffectiveViewport } from '../../../snapshot/mobile-snapshot-semantics.ts';
 import {
   captureScrollEdgeState,
   formatScrollEdgeMessage,
@@ -35,7 +27,6 @@ import {
 import type { LongPressCommandResult } from '../../../contracts/interaction.ts';
 import {
   assertSupportedInteractionSurface,
-  captureInteractionSnapshot,
   type ExpectedResolvedTarget,
   type InteractionTarget,
   type ResolvedInteractionTarget,
@@ -103,40 +94,6 @@ export type ScrollCommandResult =
 
 type ResolvedScrollTarget = { kind: 'viewport' } | ResolvedInteractionTarget;
 
-export type SwipeOptions = {
-  from?: Point | InteractionTarget;
-  to?: Point;
-  direction?: GestureDirection;
-  preset?: SwipePreset;
-  distance?: number;
-  durationMs?: number;
-};
-
-export type SwipeCommandOptions = CommandContext & SwipeOptions;
-
-export type SwipeCommandResult = {
-  kind: 'swipe';
-  from: Point;
-  to: Point;
-  direction?: GestureDirection;
-  preset?: SwipePreset;
-  distance?: number;
-  durationMs?: number;
-  fromTarget?: ResolvedInteractionTarget | { kind: 'viewport' };
-} & BackendResultEnvelope;
-
-export type PinchCommandOptions = CommandContext & {
-  scale: number;
-  center?: InteractionTarget;
-};
-
-export type PinchCommandResult = {
-  kind: 'pinch';
-  scale: number;
-  center?: Point;
-  centerTarget?: ResolvedInteractionTarget;
-} & BackendResultEnvelope;
-
 export const focusCommand: RuntimeCommand<FocusCommandOptions, FocusCommandResult> = async (
   runtime,
   options,
@@ -259,114 +216,6 @@ export const scrollCommand: RuntimeCommand<ScrollCommandOptions, ScrollCommandRe
   };
 };
 
-export const swipeCommand: RuntimeCommand<SwipeCommandOptions, SwipeCommandResult> = async (
-  runtime,
-  options,
-): Promise<SwipeCommandResult> => {
-  if (!runtime.backend.swipe) {
-    throw new AppError('UNSUPPORTED_OPERATION', 'swipe is not supported by this backend');
-  }
-  if (options.preset) {
-    return await runSwipePreset(runtime, options, runtime.backend.swipe);
-  }
-  const resolvedFrom = await resolveSwipeFrom(runtime, options);
-  const to = resolveSwipeTo(resolvedFrom.point, options);
-  const durationMs =
-    options.durationMs === undefined
-      ? undefined
-      : requireIntInRange(options.durationMs, 'durationMs', 16, 10_000);
-  const backendResult = await runtime.backend.swipe(
-    toBackendContext(runtime, options),
-    resolvedFrom.point,
-    to.point,
-    { durationMs },
-  );
-  const formattedBackendResult = toBackendResult(backendResult);
-  return {
-    kind: 'swipe',
-    from: resolvedFrom.point,
-    to: to.point,
-    ...(to.direction ? { direction: to.direction } : {}),
-    ...(to.distance !== undefined ? { distance: to.distance } : {}),
-    ...(durationMs !== undefined ? { durationMs } : {}),
-    ...(resolvedFrom.target ? { fromTarget: resolvedFrom.target } : {}),
-    ...(formattedBackendResult ? { backendResult: formattedBackendResult } : {}),
-    ...successText('Swiped'),
-  };
-};
-
-async function runSwipePreset(
-  runtime: AgentDeviceRuntime,
-  options: SwipeCommandOptions,
-  swipeBackend: NonNullable<AgentDeviceRuntime['backend']['swipe']>,
-): Promise<SwipeCommandResult> {
-  if (options.from || options.to || options.direction || options.distance !== undefined) {
-    throw new AppError(
-      'INVALID_ARGS',
-      'gesture swipe preset cannot be combined with from, to, direction, or distance',
-    );
-  }
-  const preset = parseSwipePreset(options.preset);
-  await assertSupportedInteractionSurface(runtime, options, 'swipe');
-  const capture = await captureInteractionSnapshot(runtime, options, false);
-  const frame = resolveSnapshotReferenceFrame(capture.snapshot.nodes);
-  const plan = buildSwipePresetGesturePlan(preset, frame);
-  const durationMs =
-    options.durationMs === undefined
-      ? undefined
-      : requireIntInRange(options.durationMs, 'durationMs', 16, 10_000);
-  const from = { x: plan.x1, y: plan.y1 };
-  const to = { x: plan.x2, y: plan.y2 };
-  const backendResult = await swipeBackend(toBackendContext(runtime, options), from, to, {
-    durationMs,
-  });
-  const formattedBackendResult = toBackendResult(backendResult);
-  return {
-    kind: 'swipe',
-    from,
-    to,
-    preset,
-    ...(durationMs !== undefined ? { durationMs } : {}),
-    fromTarget: { kind: 'viewport' },
-    ...(formattedBackendResult ? { backendResult: formattedBackendResult } : {}),
-    ...successText(`Swiped ${preset}`),
-  };
-}
-
-export const pinchCommand: RuntimeCommand<PinchCommandOptions, PinchCommandResult> = async (
-  runtime,
-  options,
-): Promise<PinchCommandResult> => {
-  if (!runtime.backend.pinch) {
-    throw new AppError('UNSUPPORTED_OPERATION', 'pinch is not supported by this backend');
-  }
-  await assertSupportedInteractionSurface(runtime, options, 'pinch');
-  const scale = normalizePositiveNumber(options.scale, 'pinch scale');
-  const centerTarget = options.center
-    ? await resolveInteractionTarget(
-        runtime,
-        { ...options, target: options.center },
-        {
-          action: 'pinch',
-          requireInteractive: false,
-          promoteToHittableAncestor: false,
-        },
-      )
-    : undefined;
-  const backendResult = await runtime.backend.pinch(toBackendContext(runtime, options), {
-    scale,
-    ...(centerTarget ? { center: centerTarget.point } : {}),
-  });
-  const formattedBackendResult = toBackendResult(backendResult);
-  return {
-    kind: 'pinch',
-    scale,
-    ...(centerTarget ? { center: centerTarget.point, centerTarget } : {}),
-    ...(formattedBackendResult ? { backendResult: formattedBackendResult } : {}),
-    ...successText(`Pinched to scale ${scale}`),
-  };
-};
-
 async function resolveScrollTarget(
   runtime: AgentDeviceRuntime,
   options: ScrollCommandOptions,
@@ -387,60 +236,6 @@ async function resolveScrollTarget(
   );
 }
 
-async function resolveSwipeFrom(
-  runtime: AgentDeviceRuntime,
-  options: SwipeCommandOptions,
-): Promise<{
-  point: Point;
-  target?: ResolvedInteractionTarget | { kind: 'viewport' };
-}> {
-  if (options.from) {
-    if (isPointLike(options.from)) {
-      await assertSupportedInteractionSurface(runtime, options, 'swipe');
-      return { point: requirePoint(options.from, 'from') };
-    }
-    const target = await resolveInteractionTarget(
-      runtime,
-      { ...options, target: options.from },
-      {
-        action: 'swipe',
-        requireInteractive: false,
-        promoteToHittableAncestor: false,
-      },
-    );
-    return { point: requireResolvedPoint(target), target };
-  }
-  if (!options.direction) {
-    throw new AppError('INVALID_ARGS', 'swipe requires from+to or a direction');
-  }
-  await assertSupportedInteractionSurface(runtime, options, 'swipe');
-  const capture = await captureInteractionSnapshot(runtime, options, false);
-  const viewport = resolveSnapshotViewport(capture.snapshot.nodes);
-  return {
-    point: centerOfRect(viewport),
-    target: { kind: 'viewport' },
-  };
-}
-
-function resolveSwipeTo(
-  from: Point,
-  options: SwipeCommandOptions,
-): { point: Point; direction?: GestureDirection; distance?: number } {
-  if (options.to) return { point: requirePoint(options.to, 'to') };
-  const direction = requireDirection(options.direction, 'swipe direction');
-  const distance = normalizePositiveNumber(options.distance ?? 200, 'swipe distance');
-  switch (direction) {
-    case 'up':
-      return { point: { x: from.x, y: from.y - distance }, direction, distance };
-    case 'down':
-      return { point: { x: from.x, y: from.y + distance }, direction, distance };
-    case 'left':
-      return { point: { x: from.x - distance, y: from.y }, direction, distance };
-    case 'right':
-      return { point: { x: from.x + distance, y: from.y }, direction, distance };
-  }
-}
-
 function resolveScrollDirection(direction: ScrollInputDirection): {
   direction: GestureDirection;
   edge?: 'top' | 'bottom';
@@ -508,19 +303,6 @@ function requireDirection(
   }
 }
 
-function requirePoint(point: Point, field: string): Point {
-  const x = Number(point.x);
-  const y = Number(point.y);
-  if (!Number.isFinite(x) || !Number.isFinite(y)) {
-    throw new AppError('INVALID_ARGS', `${field} point requires finite x and y`);
-  }
-  return { x, y };
-}
-
-function isPointLike(value: Point | InteractionTarget): value is Point {
-  return 'x' in value && 'y' in value;
-}
-
 function normalizeOptionalPositiveNumber(
   value: number | undefined,
   field: string,
@@ -545,37 +327,3 @@ function normalizeOptionalPositiveInteger(
   }
   return value;
 }
-
-function resolveSnapshotViewport(nodes: SnapshotState['nodes']): Rect {
-  const visibleRects = nodes
-    .filter((node) => isNodeVisibleInEffectiveViewport(node, nodes))
-    .map((node) => node.rect)
-    .filter(isUsableRect);
-  const rects =
-    visibleRects.length > 0 ? visibleRects : nodes.map((node) => node.rect).filter(isUsableRect);
-  if (rects.length === 0) {
-    throw new AppError('COMMAND_FAILED', 'Cannot infer viewport for directional swipe');
-  }
-  const minX = Math.min(...rects.map((rect) => rect.x));
-  const minY = Math.min(...rects.map((rect) => rect.y));
-  const maxX = Math.max(...rects.map((rect) => rect.x + rect.width));
-  const maxY = Math.max(...rects.map((rect) => rect.y + rect.height));
-  return {
-    x: minX,
-    y: minY,
-    width: maxX - minX,
-    height: maxY - minY,
-  };
-}
-
-function resolveSnapshotReferenceFrame(nodes: SnapshotState['nodes']): GestureReferenceFrame {
-  const viewport = resolveSnapshotViewport(nodes);
-  return {
-    referenceWidth: viewport.width,
-    referenceHeight: viewport.height,
-  };
-}
-
-function isUsableRect(rect: SnapshotNode['rect']): rect is NonNullable<SnapshotNode['rect']> {
-  return Boolean(rect && rect.width > 0 && rect.height > 0);
-}
diff --git a/src/commands/interaction/runtime/index.ts b/src/commands/interaction/runtime/index.ts
index db5a29601..f46bbc532 100644
--- a/src/commands/interaction/runtime/index.ts
+++ b/src/commands/interaction/runtime/index.ts
@@ -5,10 +5,8 @@ import {
   fillCommand,
   focusCommand,
   longPressCommand,
-  pinchCommand,
   pressCommand,
   scrollCommand,
-  swipeCommand,
   typeTextCommand,
   type ClickCommandOptions,
   type FillCommandOptions,
@@ -18,14 +16,10 @@ import {
   type InteractionTarget,
   type LongPressCommandOptions,
   type LongPressCommandResult,
-  type PinchCommandOptions,
-  type PinchCommandResult,
   type PressCommandOptions,
   type PressCommandResult,
   type ScrollCommandOptions,
   type ScrollCommandResult,
-  type SwipeCommandOptions,
-  type SwipeCommandResult,
   type TypeTextCommandOptions,
   type TypeTextCommandResult,
 } from './interactions.ts';
@@ -54,6 +48,11 @@ import {
   type WaitCommandResult,
   type WaitForTextCommandOptions,
 } from './selector-read.ts';
+import {
+  gestureCommand,
+  type GestureCommandOptions,
+  type GestureCommandResult,
+} from './gesture-command.ts';
 
 export type SelectorCommands = {
   find: RuntimeCommand<FindReadCommandOptions, FindReadCommandResult>;
@@ -77,9 +76,8 @@ export type InteractionCommands = {
   typeText: RuntimeCommand<TypeTextCommandOptions, TypeTextCommandResult>;
   focus: RuntimeCommand<FocusCommandOptions, FocusCommandResult>;
   longPress: RuntimeCommand<LongPressCommandOptions, LongPressCommandResult>;
-  swipe: RuntimeCommand<SwipeCommandOptions, SwipeCommandResult>;
   scroll: RuntimeCommand<ScrollCommandOptions, ScrollCommandResult>;
-  pinch: RuntimeCommand<PinchCommandOptions, PinchCommandResult>;
+  gesture: RuntimeCommand<GestureCommandOptions, GestureCommandResult>;
 };
 
 export type BoundSelectorCommands = {
@@ -135,9 +133,8 @@ export type BoundInteractionCommands = {
     target: InteractionTarget,
     options?: Omit<LongPressCommandOptions, 'target'>,
   ) => Promise<LongPressCommandResult>;
-  swipe: BoundRuntimeCommand<SwipeCommandOptions, SwipeCommandResult>;
   scroll: BoundRuntimeCommand<ScrollCommandOptions, ScrollCommandResult>;
-  pinch: BoundRuntimeCommand<PinchCommandOptions, PinchCommandResult>;
+  gesture: BoundRuntimeCommand<GestureCommandOptions, GestureCommandResult>;
 };
 
 export const selectorCommands: SelectorCommands = {
@@ -159,9 +156,8 @@ export const interactionCommands: InteractionCommands = {
   typeText: typeTextCommand,
   focus: focusCommand,
   longPress: longPressCommand,
-  swipe: swipeCommand,
   scroll: scrollCommand,
-  pinch: pinchCommand,
+  gesture: gestureCommand,
 };
 
 export function bindSelectorCommands(runtime: AgentDeviceRuntime): BoundSelectorCommands {
@@ -190,8 +186,9 @@ export function bindInteractionCommands(runtime: AgentDeviceRuntime): BoundInter
     focus: (target, options = {}) => interactionCommands.focus(runtime, { ...options, target }),
     longPress: (target, options = {}) =>
       interactionCommands.longPress(runtime, { ...options, target }),
-    swipe: (options) => interactionCommands.swipe(runtime, options),
     scroll: (options) => interactionCommands.scroll(runtime, options),
-    pinch: (options) => interactionCommands.pinch(runtime, options),
+    gesture: (options) => interactionCommands.gesture(runtime, options),
   };
 }
+
+export type { GestureCommandOptions, GestureCommandResult } from './gesture-command.ts';
diff --git a/src/commands/interaction/runtime/interactions.ts b/src/commands/interaction/runtime/interactions.ts
index 61450b893..e33e2c6dc 100644
--- a/src/commands/interaction/runtime/interactions.ts
+++ b/src/commands/interaction/runtime/interactions.ts
@@ -31,27 +31,16 @@ import {
   type PostActionObservationOptions,
 } from './post-action-observation.ts';
 
-export {
-  focusCommand,
-  longPressCommand,
-  pinchCommand,
-  scrollCommand,
-  swipeCommand,
-} from './gestures.ts';
+export { focusCommand, longPressCommand, scrollCommand } from './gestures.ts';
 export type {
   FocusCommandOptions,
   FocusCommandResult,
   GestureDirection,
   LongPressCommandOptions,
   LongPressCommandResult,
-  PinchCommandOptions,
-  PinchCommandResult,
   ScrollCommandOptions,
   ScrollCommandResult,
   ScrollTarget,
-  SwipeCommandOptions,
-  SwipeCommandResult,
-  SwipeOptions,
 } from './gestures.ts';
 export type { InteractionTarget, PointTarget, ResolvedInteractionTarget } from './resolution.ts';
 
diff --git a/src/commands/interaction/runtime/resolution.ts b/src/commands/interaction/runtime/resolution.ts
index fdad3fe39..4323ff56c 100644
--- a/src/commands/interaction/runtime/resolution.ts
+++ b/src/commands/interaction/runtime/resolution.ts
@@ -105,7 +105,11 @@ export type InteractionAction =
   | 'longPress'
   | 'scroll'
   | 'swipe'
-  | 'pinch';
+  | 'pinch'
+  | 'pan'
+  | 'fling'
+  | 'rotate'
+  | 'transform';
 
 export type CapturedSnapshot = {
   snapshot: SnapshotState;
diff --git a/src/commands/interaction/runtime/viewport.ts b/src/commands/interaction/runtime/viewport.ts
new file mode 100644
index 000000000..2642dc720
--- /dev/null
+++ b/src/commands/interaction/runtime/viewport.ts
@@ -0,0 +1,27 @@
+import { AppError } from '../../../kernel/errors.ts';
+import type { Rect, SnapshotNode, SnapshotState } from '../../../kernel/snapshot.ts';
+import { isNodeVisibleInEffectiveViewport } from '../../../snapshot/mobile-snapshot-semantics.ts';
+
+export function resolveVisibleSnapshotViewport(
+  nodes: SnapshotState['nodes'],
+  action: string,
+): Rect {
+  const visibleRects = nodes
+    .filter((node) => isNodeVisibleInEffectiveViewport(node, nodes))
+    .map((node) => node.rect)
+    .filter(isUsableRect);
+  const rects =
+    visibleRects.length > 0 ? visibleRects : nodes.map((node) => node.rect).filter(isUsableRect);
+  if (rects.length === 0) {
+    throw new AppError('COMMAND_FAILED', `Cannot infer viewport for ${action}`);
+  }
+  const minX = Math.min(...rects.map((rect) => rect.x));
+  const minY = Math.min(...rects.map((rect) => rect.y));
+  const maxX = Math.max(...rects.map((rect) => rect.x + rect.width));
+  const maxY = Math.max(...rects.map((rect) => rect.y + rect.height));
+  return { x: minX, y: minY, width: maxX - minX, height: maxY - minY };
+}
+
+function isUsableRect(rect: SnapshotNode['rect']): rect is NonNullable<SnapshotNode['rect']> {
+  return Boolean(rect && rect.width > 0 && rect.height > 0);
+}
diff --git a/src/compat/maestro/__tests__/runtime-assertions.test.ts b/src/compat/maestro/__tests__/runtime-assertions.test.ts
index a18c0b0cf..2fd14409d 100644
--- a/src/compat/maestro/__tests__/runtime-assertions.test.ts
+++ b/src/compat/maestro/__tests__/runtime-assertions.test.ts
@@ -392,10 +392,10 @@ test('invokeMaestroAssertVisible does not retry stale Android taps after swipes'
 
   assert.equal(response.ok, false);
   assert.deepEqual(calls, [
-    ['gesture', ['swipe', 'left', '300']],
+    ['gesture', []],
     ['wait', ['What is Lorem Ipsum?', '2000']],
     ['snapshot', []],
-    ['gesture', ['swipe', 'left', '300']],
+    ['gesture', []],
     ['wait', ['What is Lorem Ipsum?', '2000']],
     ['snapshot', []],
   ]);
@@ -407,7 +407,7 @@ test('invokeMaestroAssertVisible does not replay a previous iOS swipe after an A
   rememberMaestroRecoverableInteraction(scope, {
     kind: 'swipe',
     command: 'gesture',
-    positionals: ['swipe', 'left', '300'],
+    input: { kind: 'swipe', preset: 'left', durationMs: 300 },
   });
 
   const response = await invokeMaestroAssertVisible({
diff --git a/src/compat/maestro/__tests__/runtime-interactions.test.ts b/src/compat/maestro/__tests__/runtime-interactions.test.ts
index 093537032..8179774b3 100644
--- a/src/compat/maestro/__tests__/runtime-interactions.test.ts
+++ b/src/compat/maestro/__tests__/runtime-interactions.test.ts
@@ -7,7 +7,10 @@ import {
   invokeMaestroTapOn,
   invokeMaestroTapPointPercent,
 } from '../runtime-interactions.ts';
-import { consumeMaestroRecoverableInteraction } from '../runtime-support.ts';
+import {
+  captureMaestroSnapshot,
+  consumeMaestroRecoverableInteraction,
+} from '../runtime-support.ts';
 
 test('invokeMaestroTapOn resolves mutating taps from the current snapshot', async () => {
   const selector =
@@ -245,7 +248,7 @@ test('invokeMaestroTapOn clicks explicit React Native overlay controls directly'
 
 test('invokeMaestroSwipeScreen delegates directional swipes to core gestures', async () => {
   const scope = { values: {} };
-  const gestures: string[][] = [];
+  const gestures: Array<DaemonRequest['input']> = [];
   const response = await invokeMaestroSwipeScreen({
     baseReq: {
       token: 'test',
@@ -256,7 +259,7 @@ test('invokeMaestroSwipeScreen delegates directional swipes to core gestures', a
     positionals: ['direction', 'left', '300'],
     invoke: async (req: DaemonRequest): Promise<DaemonResponse> => {
       if (req.command === 'gesture') {
-        gestures.push(req.positionals ?? []);
+        gestures.push(req.input);
         return { ok: true, data: {} };
       }
       return { ok: false, error: { code: 'UNEXPECTED_COMMAND', message: req.command } };
@@ -264,16 +267,16 @@ test('invokeMaestroSwipeScreen delegates directional swipes to core gestures', a
   });
 
   expect(response.ok).toBe(true);
-  expect(gestures).toEqual([['swipe', 'left', '300']]);
+  expect(gestures).toEqual([{ kind: 'swipe', preset: 'left', durationMs: 300 }]);
   expect(consumeMaestroRecoverableInteraction(scope)).toEqual({
     kind: 'swipe',
     command: 'gesture',
-    positionals: ['swipe', 'left', '300'],
+    input: { kind: 'swipe', preset: 'left', durationMs: 300 },
   });
 });
 
 test('invokeMaestroSwipeScreen delegates mirrored Android directional swipes to core gestures', async () => {
-  const gestures: string[][] = [];
+  const gestures: Array<DaemonRequest['input']> = [];
   const response = await invokeMaestroSwipeScreen({
     baseReq: {
       token: 'test',
@@ -283,7 +286,7 @@ test('invokeMaestroSwipeScreen delegates mirrored Android directional swipes to
     positionals: ['direction', 'right', '300'],
     invoke: async (req: DaemonRequest): Promise<DaemonResponse> => {
       if (req.command === 'gesture') {
-        gestures.push(req.positionals ?? []);
+        gestures.push(req.input);
         return { ok: true, data: {} };
       }
       return { ok: false, error: { code: 'UNEXPECTED_COMMAND', message: req.command } };
@@ -291,12 +294,12 @@ test('invokeMaestroSwipeScreen delegates mirrored Android directional swipes to
   });
 
   expect(response.ok).toBe(true);
-  expect(gestures).toEqual([['swipe', 'right', '300']]);
+  expect(gestures).toEqual([{ kind: 'swipe', preset: 'right', durationMs: 300 }]);
 });
 
 test('invokeMaestroSwipeScreen delegates Android vertical down swipes to core gestures', async () => {
   const scope = { values: {} };
-  const gestures: string[][] = [];
+  const gestures: Array<DaemonRequest['input']> = [];
   const response = await invokeMaestroSwipeScreen({
     baseReq: {
       token: 'test',
@@ -307,7 +310,7 @@ test('invokeMaestroSwipeScreen delegates Android vertical down swipes to core ge
     positionals: ['direction', 'down', '100'],
     invoke: async (req: DaemonRequest): Promise<DaemonResponse> => {
       if (req.command === 'gesture') {
-        gestures.push(req.positionals ?? []);
+        gestures.push(req.input);
         return { ok: true, data: {} };
       }
       return { ok: false, error: { code: 'UNEXPECTED_COMMAND', message: req.command } };
@@ -315,16 +318,16 @@ test('invokeMaestroSwipeScreen delegates Android vertical down swipes to core ge
   });
 
   expect(response.ok).toBe(true);
-  expect(gestures).toEqual([['swipe', 'down', '100']]);
+  expect(gestures).toEqual([{ kind: 'swipe', preset: 'down', durationMs: 100 }]);
   expect(consumeMaestroRecoverableInteraction(scope)).toEqual({
     kind: 'swipe',
     command: 'gesture',
-    positionals: ['swipe', 'down', '100'],
+    input: { kind: 'swipe', preset: 'down', durationMs: 100 },
   });
 });
 
 test('invokeMaestroSwipeScreen delegates Android vertical up swipes to core gestures', async () => {
-  const gestures: string[][] = [];
+  const gestures: Array<DaemonRequest['input']> = [];
   const response = await invokeMaestroSwipeScreen({
     baseReq: {
       token: 'test',
@@ -334,7 +337,7 @@ test('invokeMaestroSwipeScreen delegates Android vertical up swipes to core gest
     positionals: ['direction', 'up'],
     invoke: async (req: DaemonRequest): Promise<DaemonResponse> => {
       if (req.command === 'gesture') {
-        gestures.push(req.positionals ?? []);
+        gestures.push(req.input);
         return { ok: true, data: {} };
       }
       return { ok: false, error: { code: 'UNEXPECTED_COMMAND', message: req.command } };
@@ -342,12 +345,12 @@ test('invokeMaestroSwipeScreen delegates Android vertical up swipes to core gest
   });
 
   expect(response.ok).toBe(true);
-  expect(gestures).toEqual([['swipe', 'up']]);
+  expect(gestures).toEqual([{ kind: 'swipe', preset: 'up' }]);
 });
 
 test('invokeMaestroSwipeOn resolves visible non-interactive text from a regular snapshot', async () => {
   const snapshotFlags: Array<DaemonRequest['flags']> = [];
-  const swipes: string[][] = [];
+  const swipes: Array<DaemonRequest['input']> = [];
   const swipeFlags: Array<DaemonRequest['flags']> = [];
   const response = await invokeMaestroSwipeOn({
     baseReq: {
@@ -382,7 +385,7 @@ test('invokeMaestroSwipeOn resolves visible non-interactive text from a regular
         };
       }
       if (req.command === 'swipe') {
-        swipes.push(req.positionals ?? []);
+        swipes.push(req.input);
         swipeFlags.push(req.flags);
         return { ok: true, data: {} };
       }
@@ -394,12 +397,12 @@ test('invokeMaestroSwipeOn resolves visible non-interactive text from a regular
   expect(snapshotFlags).toHaveLength(1);
   expect(snapshotFlags[0]?.snapshotInteractiveOnly).toBeUndefined();
   expect(snapshotFlags[0]?.snapshotRaw).toBe(true);
-  expect(swipes).toEqual([['200', '250', '8', '250', '300']]);
+  expect(swipes).toEqual([{ from: { x: 200, y: 250 }, to: { x: 8, y: 250 }, durationMs: 300 }]);
   expect(swipeFlags[0]?.postGestureStabilization).toBe(true);
 });
 
 test('invokeMaestroSwipeScreen preserves vertical percentage endpoints', async () => {
-  const swipes: string[][] = [];
+  const swipes: Array<DaemonRequest['input']> = [];
   const swipeFlags: Array<DaemonRequest['flags']> = [];
   const response = await invokeMaestroSwipeScreen({
     baseReq: {
@@ -413,7 +416,7 @@ test('invokeMaestroSwipeScreen preserves vertical percentage endpoints', async (
         return { ok: true, data: fullScreenSnapshot(400, 800) };
       }
       if (req.command === 'swipe') {
-        swipes.push(req.positionals ?? []);
+        swipes.push(req.input);
         swipeFlags.push(req.flags);
         return { ok: true, data: {} };
       }
@@ -422,12 +425,12 @@ test('invokeMaestroSwipeScreen preserves vertical percentage endpoints', async (
   });
 
   expect(response.ok).toBe(true);
-  expect(swipes).toEqual([['200', '600', '200', '280', '300']]);
+  expect(swipes).toEqual([{ from: { x: 200, y: 600 }, to: { x: 200, y: 280 }, durationMs: 300 }]);
   expect(swipeFlags[0]?.postGestureStabilization).toBeUndefined();
 });
 
 test('invokeMaestroSwipeScreen preserves iOS horizontal percentage endpoints', async () => {
-  const swipes: string[][] = [];
+  const swipes: Array<DaemonRequest['input']> = [];
   const response = await invokeMaestroSwipeScreen({
     baseReq: {
       token: 'test',
@@ -440,7 +443,7 @@ test('invokeMaestroSwipeScreen preserves iOS horizontal percentage endpoints', a
         return { ok: true, data: fullScreenSnapshot(400, 800) };
       }
       if (req.command === 'swipe') {
-        swipes.push(req.positionals ?? []);
+        swipes.push(req.input);
         return { ok: true, data: {} };
       }
       return { ok: false, error: { code: 'UNEXPECTED_COMMAND', message: req.command } };
@@ -448,11 +451,11 @@ test('invokeMaestroSwipeScreen preserves iOS horizontal percentage endpoints', a
   });
 
   expect(response.ok).toBe(true);
-  expect(swipes).toEqual([['40', '400', '360', '400', '300']]);
+  expect(swipes).toEqual([{ from: { x: 40, y: 400 }, to: { x: 360, y: 400 }, durationMs: 300 }]);
 });
 
 test('invokeMaestroSwipeScreen preserves Android midpoint percentage endpoints', async () => {
-  const swipes: string[][] = [];
+  const swipes: Array<DaemonRequest['input']> = [];
   const response = await invokeMaestroSwipeScreen({
     baseReq: {
       token: 'test',
@@ -465,7 +468,7 @@ test('invokeMaestroSwipeScreen preserves Android midpoint percentage endpoints',
         return { ok: true, data: fullScreenSnapshot(390, 600) };
       }
       if (req.command === 'swipe') {
-        swipes.push(req.positionals ?? []);
+        swipes.push(req.input);
         return { ok: true, data: {} };
       }
       return { ok: false, error: { code: 'UNEXPECTED_COMMAND', message: req.command } };
@@ -473,11 +476,48 @@ test('invokeMaestroSwipeScreen preserves Android midpoint percentage endpoints',
   });
 
   expect(response.ok).toBe(true);
-  expect(swipes).toEqual([['351', '300', '39', '300', '300']]);
+  expect(swipes).toEqual([{ from: { x: 351, y: 300 }, to: { x: 39, y: 300 }, durationMs: 300 }]);
+});
+
+test('invokeMaestroSwipeScreen refreshes a cached frame before resolving percentages', async () => {
+  const scope = { values: {} };
+  const swipes: Array<DaemonRequest['input']> = [];
+  let snapshots = 0;
+  const baseReq = {
+    token: 'test',
+    session: 'rotated-pager',
+    flags: { platform: 'android' as const },
+  };
+  const invoke = async (req: DaemonRequest): Promise<DaemonResponse> => {
+    if (req.command === 'snapshot') {
+      snapshots += 1;
+      return {
+        ok: true,
+        data: snapshots === 1 ? fullScreenSnapshot(400, 800) : fullScreenSnapshot(800, 400),
+      };
+    }
+    if (req.command === 'swipe') {
+      swipes.push(req.input);
+      return { ok: true, data: {} };
+    }
+    return { ok: false, error: { code: 'UNEXPECTED_COMMAND', message: req.command } };
+  };
+
+  await captureMaestroSnapshot({ baseReq, invoke, scope });
+  const response = await invokeMaestroSwipeScreen({
+    baseReq,
+    positionals: ['percent', '90', '50', '10', '50', '300'],
+    invoke,
+    scope,
+  });
+
+  expect(response.ok).toBe(true);
+  expect(snapshots).toBe(2);
+  expect(swipes).toEqual([{ from: { x: 720, y: 200 }, to: { x: 80, y: 200 }, durationMs: 300 }]);
 });
 
 test('invokeMaestroSwipeScreen preserves an explicit Android horizontal percentage lane', async () => {
-  const swipes: string[][] = [];
+  const swipes: Array<DaemonRequest['input']> = [];
   const response = await invokeMaestroSwipeScreen({
     baseReq: {
       token: 'test',
@@ -490,7 +530,7 @@ test('invokeMaestroSwipeScreen preserves an explicit Android horizontal percenta
         return { ok: true, data: fullScreenSnapshot(390, 600) };
       }
       if (req.command === 'swipe') {
-        swipes.push(req.positionals ?? []);
+        swipes.push(req.input);
         return { ok: true, data: {} };
       }
       return { ok: false, error: { code: 'UNEXPECTED_COMMAND', message: req.command } };
@@ -498,7 +538,7 @@ test('invokeMaestroSwipeScreen preserves an explicit Android horizontal percenta
   });
 
   expect(response.ok).toBe(true);
-  expect(swipes).toEqual([['351', '180', '39', '180', '300']]);
+  expect(swipes).toEqual([{ from: { x: 351, y: 180 }, to: { x: 39, y: 180 }, durationMs: 300 }]);
 });
 
 test('invokeMaestroTapPointPercent bounds percentage points to valid frame pixels', async () => {
diff --git a/src/compat/maestro/runtime-assertions.ts b/src/compat/maestro/runtime-assertions.ts
index 85999bc91..c6614509f 100644
--- a/src/compat/maestro/runtime-assertions.ts
+++ b/src/compat/maestro/runtime-assertions.ts
@@ -259,7 +259,7 @@ async function retryRecentSwipeAfterVisibleMiss(
     data: {
       selector: args.selector,
       swipeCommand: recentSwipe.command,
-      swipePositionals: recentSwipe.positionals,
+      swipeInput: recentSwipe.input,
       timeoutMs: MAESTRO_ASSERTION_POLICY.assertVisibleRetryTimeoutMs,
     },
   });
@@ -368,7 +368,8 @@ async function invokeRecentSwipeRetry(
   return await params.invoke({
     ...params.baseReq,
     command: swipe.command,
-    positionals: swipe.positionals,
+    positionals: [],
+    input: swipe.input,
   });
 }
 
diff --git a/src/compat/maestro/runtime-interactions.ts b/src/compat/maestro/runtime-interactions.ts
index 877d227aa..8d280e410 100644
--- a/src/compat/maestro/runtime-interactions.ts
+++ b/src/compat/maestro/runtime-interactions.ts
@@ -16,7 +16,6 @@ import {
   clearMaestroRecoverableInteraction,
   clearMaestroVisibleContext,
   errorResponse,
-  readCachedMaestroReferenceFrame,
   readMaestroVisibleContext,
   readSnapshotState,
   rememberMaestroRecoverableInteraction,
@@ -173,17 +172,22 @@ async function maybeInvokeMaestroDirectionalSwipePreset(params: {
       'Maestro swipe direction must be UP, DOWN, LEFT, or RIGHT.',
     );
   }
-  const positionals = ['swipe', direction, ...(durationMs ? [durationMs] : [])];
+  const input = {
+    kind: 'swipe',
+    preset: direction,
+    ...(durationMs === undefined ? {} : { durationMs: Number(durationMs) }),
+  };
   const response = await params.invoke({
     ...params.baseReq,
     command: 'gesture',
-    positionals,
+    positionals: [],
+    input,
   });
   if (response.ok) {
     rememberMaestroRecoverableInteraction(params.scope, {
       kind: 'swipe',
       command: 'gesture',
-      positionals,
+      input,
     });
   }
   return response;
@@ -238,23 +242,22 @@ async function invokeSwipeGesture(
   },
   durationMs: string | undefined,
 ): Promise<DaemonResponse> {
-  const responsePositionals = [
-    String(swipe.start.x),
-    String(swipe.start.y),
-    String(swipe.end.x),
-    String(swipe.end.y),
-    ...(durationMs ? [durationMs] : []),
-  ];
+  const input = {
+    from: swipe.start,
+    to: swipe.end,
+    ...(durationMs === undefined ? {} : { durationMs: Number(durationMs) }),
+  };
   const response = await params.invoke({
     ...params.baseReq,
     command: 'swipe',
-    positionals: responsePositionals,
+    positionals: [],
+    input,
   });
   if (response.ok) {
     rememberMaestroRecoverableInteraction(params.scope, {
       kind: 'swipe',
       command: 'swipe',
-      positionals: responsePositionals,
+      input,
     });
   }
   return response;
@@ -266,8 +269,7 @@ async function resolveMaestroScreenSwipe(params: {
   invoke: MaestroRuntimeInvoke;
   scope?: ReplayVarScope;
 }): Promise<MaestroScreenSwipeResolution> {
-  const cachedFrame = readCachedMaestroReferenceFrame(params.scope);
-  const frame = cachedFrame ?? (await captureFrameForMaestroScreenSwipe(params));
+  const frame = await captureFrameForMaestroScreenSwipe(params);
   if (!frame) {
     return {
       ok: false,
diff --git a/src/compat/maestro/runtime-support.ts b/src/compat/maestro/runtime-support.ts
index 9c3bc199a..0a13b99ba 100644
--- a/src/compat/maestro/runtime-support.ts
+++ b/src/compat/maestro/runtime-support.ts
@@ -1,7 +1,3 @@
-import {
-  getSnapshotReferenceFrame,
-  type TouchReferenceFrame,
-} from '../../daemon/touch-reference-frame.ts';
 import type {
   DaemonInvokeFn,
   DaemonRequest,
@@ -21,7 +17,6 @@ export type MaestroRuntimeInvoke = DaemonInvokeFn;
 
 export type FailedDaemonResponse = DaemonFailureResponse;
 
-const maestroReferenceFrameCache = new WeakMap<ReplayVarScope, TouchReferenceFrame>();
 const maestroVisibleContextCache = new WeakMap<ReplayVarScope, { selector: string }>();
 const maestroRecoverableInteractionCache = new WeakMap<
   ReplayVarScope,
@@ -47,7 +42,7 @@ export type MaestroRecoverableTap = {
 
 export type MaestroRecoverableSwipe = {
   command: 'gesture' | 'swipe';
-  positionals: string[];
+  input: Record<string, unknown>;
 };
 
 export function errorResponse(
@@ -79,7 +74,6 @@ export async function captureMaestroSnapshot(params: {
       ...(useRawSnapshot ? { snapshotRaw: true } : {}),
     },
   });
-  if (response.ok && params.scope) rememberMaestroReferenceFrame(params.scope, response.data);
   return response;
 }
 
@@ -87,12 +81,6 @@ export function readSnapshotState(data: DaemonResponseData | undefined): Snapsho
   return Array.isArray(data?.nodes) ? (data as SnapshotState) : undefined;
 }
 
-export function readCachedMaestroReferenceFrame(
-  scope: ReplayVarScope | undefined,
-): TouchReferenceFrame | undefined {
-  return scope ? maestroReferenceFrameCache.get(scope) : undefined;
-}
-
 export function rememberMaestroVisibleContext(
   scope: ReplayVarScope | undefined,
   selector: string,
@@ -129,12 +117,3 @@ export function consumeMaestroRecoverableInteraction(
 export function clearMaestroRecoverableInteraction(scope: ReplayVarScope | undefined): void {
   if (scope) maestroRecoverableInteractionCache.delete(scope);
 }
-
-function rememberMaestroReferenceFrame(
-  scope: ReplayVarScope,
-  data: DaemonResponseData | undefined,
-): void {
-  const snapshot = readSnapshotState(data);
-  const frame = getSnapshotReferenceFrame(snapshot);
-  if (frame) maestroReferenceFrameCache.set(scope, frame);
-}
diff --git a/src/contracts/apple-multitouch-support.ts b/src/contracts/apple-multitouch-support.ts
new file mode 100644
index 000000000..f115a57be
--- /dev/null
+++ b/src/contracts/apple-multitouch-support.ts
@@ -0,0 +1,58 @@
+import {
+  isApplePlatform,
+  resolveDeviceAppleOs,
+  type AppleOS,
+  type DeviceInfo,
+} from '../kernel/device.ts';
+import { AppError } from '../kernel/errors.ts';
+import type { GesturePlan } from './gesture-plan-types.ts';
+
+const APPLE_OS_DISPLAY_NAMES: Record<AppleOS, string> = {
+  ios: 'iOS',
+  ipados: 'iPadOS',
+  tvos: 'tvOS',
+  watchos: 'watchOS',
+  visionos: 'visionOS',
+  macos: 'macOS',
+};
+
+const APPLE_MULTI_TOUCH_UNSUPPORTED_HINTS: Partial<Record<AppleOS, string>> = {
+  visionos: 'visionOS uses spatial input and does not support two-finger touch synthesis.',
+  tvos: 'tvOS has no touch input — this gesture is supported on Android and the iOS simulator only.',
+  macos:
+    'macOS automation has no multi-touch input — this gesture is supported on Android and the iOS simulator only.',
+};
+
+/** One policy shared by command admission and the defensive Apple adapter check. */
+export function assertAppleMultiTouchSupported(
+  device: DeviceInfo,
+  intent: GesturePlan['intent'],
+): void {
+  if (!isApplePlatform(device.platform)) {
+    throw unsupported(intent, device.platform);
+  }
+  const appleOs = resolveDeviceAppleOs(device);
+  if ((appleOs === 'ios' || appleOs === 'ipados') && device.kind === 'simulator') return;
+  if (appleOs === 'ios' || appleOs === 'ipados') {
+    throw new AppError(
+      'UNSUPPORTED_OPERATION',
+      `gesture ${intent} is not supported on physical iOS devices`,
+      {
+        hint: 'Two-finger gesture synthesis is iOS-simulator only — not available on physical iOS devices.',
+      },
+    );
+  }
+  throw unsupported(
+    intent,
+    APPLE_OS_DISPLAY_NAMES[appleOs],
+    APPLE_MULTI_TOUCH_UNSUPPORTED_HINTS[appleOs],
+  );
+}
+
+function unsupported(intent: GesturePlan['intent'], platform: string, hint?: string): AppError {
+  return new AppError(
+    'UNSUPPORTED_OPERATION',
+    `gesture ${intent} is not supported on ${platform}`,
+    hint === undefined ? undefined : { hint },
+  );
+}
diff --git a/src/contracts/cli-flags.ts b/src/contracts/cli-flags.ts
index e150158f7..d628ba880 100644
--- a/src/contracts/cli-flags.ts
+++ b/src/contracts/cli-flags.ts
@@ -84,6 +84,7 @@ export type CliFlags = CloudProviderProfileFields &
     threshold?: string;
     appsFilter?: 'user-installed' | 'all';
     count?: number;
+    pointerCount?: number;
     fps?: number;
     quality?: RecordingExportQuality | string;
     hideTouches?: boolean;
diff --git a/src/contracts/gesture-input.test.ts b/src/contracts/gesture-input.test.ts
new file mode 100644
index 000000000..14481ed23
--- /dev/null
+++ b/src/contracts/gesture-input.test.ts
@@ -0,0 +1,61 @@
+import assert from 'node:assert/strict';
+import { test } from 'vitest';
+import { readGesturePayload } from './gesture-input.ts';
+
+test('structured gesture input rejects durations outside the planner range', () => {
+  const cases = [
+    {
+      kind: 'pan',
+      origin: { x: 10, y: 20 },
+      delta: { x: 30, y: 40 },
+      durationMs: 0,
+    },
+    {
+      kind: 'fling',
+      direction: 'left',
+      origin: { x: 10, y: 20 },
+      durationMs: 10_001,
+    },
+    { kind: 'swipe', preset: 'left', durationMs: 0 },
+    {
+      kind: 'transform',
+      origin: { x: 10, y: 20 },
+      delta: { x: 30, y: 40 },
+      scale: 1.2,
+      degrees: 20,
+      durationMs: 10_001,
+    },
+  ];
+
+  for (const input of cases) {
+    assert.throws(
+      () => readGesturePayload(input),
+      (error: unknown) =>
+        typeof error === 'object' &&
+        error !== null &&
+        'code' in error &&
+        error.code === 'INVALID_ARGS' &&
+        'message' in error &&
+        typeof error.message === 'string' &&
+        error.message.includes('16') &&
+        error.message.includes('10000'),
+    );
+  }
+});
+
+test('deprecated rotate velocity accepts finite non-zero compatibility values', () => {
+  for (const velocity of [-2.5, -1, 0.25, 3]) {
+    assert.deepEqual(readGesturePayload({ kind: 'rotate', degrees: 45, velocity }), {
+      kind: 'rotate',
+      degrees: 45,
+      origin: undefined,
+      velocity,
+    });
+  }
+
+  for (const velocity of [0, Number.NaN, Number.POSITIVE_INFINITY]) {
+    assert.throws(() => readGesturePayload({ kind: 'rotate', degrees: 45, velocity }), {
+      code: 'INVALID_ARGS',
+    });
+  }
+});
diff --git a/src/contracts/gesture-input.ts b/src/contracts/gesture-input.ts
new file mode 100644
index 000000000..87be1db6c
--- /dev/null
+++ b/src/contracts/gesture-input.ts
@@ -0,0 +1,183 @@
+import { AppError } from '../kernel/errors.ts';
+import type { Point } from '../kernel/snapshot.ts';
+import { readOptionalInteger } from '../kernel/input-validation.ts';
+import {
+  SCROLL_DIRECTIONS,
+  SWIPE_PRESETS,
+  type ScrollDirection,
+  type SwipePreset,
+} from './scroll-gesture.ts';
+import {
+  GESTURE_DURATION_MAX_MS,
+  GESTURE_DURATION_MIN_MS,
+  type GesturePointerCount,
+} from './gesture-plan-types.ts';
+
+export const GESTURE_KINDS = ['pan', 'fling', 'swipe', 'pinch', 'rotate', 'transform'] as const;
+
+export type PanGesturePayload = {
+  kind: 'pan';
+  origin: Point;
+  delta: Point;
+  pointerCount?: GesturePointerCount;
+  durationMs?: number;
+};
+
+export type FlingGesturePayload = {
+  kind: 'fling';
+  direction: ScrollDirection;
+  origin: Point;
+  distance?: number;
+  durationMs?: number;
+};
+
+export type SwipeGesturePayload = {
+  kind: 'swipe';
+  preset: SwipePreset;
+  durationMs?: number;
+};
+
+export type PinchGesturePayload = {
+  kind: 'pinch';
+  scale: number;
+  origin?: Point;
+};
+
+export type RotateGesturePayload = {
+  kind: 'rotate';
+  degrees: number;
+  origin?: Point;
+  velocity?: number;
+};
+
+export type TransformGesturePayload = {
+  kind: 'transform';
+  origin: Point;
+  delta: Point;
+  scale: number;
+  degrees: number;
+  durationMs?: number;
+};
+
+export type GesturePayload =
+  | PanGesturePayload
+  | FlingGesturePayload
+  | SwipeGesturePayload
+  | PinchGesturePayload
+  | RotateGesturePayload
+  | TransformGesturePayload;
+
+export function readGesturePayload(input: unknown): GesturePayload {
+  const record = readRecord(input);
+  const kind = readEnum(record, 'kind', GESTURE_KINDS);
+  if (kind === 'pan') {
+    return {
+      kind,
+      origin: readPoint(record, 'origin'),
+      delta: readPoint(record, 'delta'),
+      pointerCount: readOptionalInteger(record, 'pointerCount', { min: 1, max: 2 }) as
+        | GesturePointerCount
+        | undefined,
+      durationMs: readOptionalGestureDuration(record),
+    };
+  }
+  if (record.pointerCount !== undefined) {
+    throw new AppError('INVALID_ARGS', 'pointerCount is supported only for gesture pan');
+  }
+  if (kind === 'fling') {
+    return {
+      kind,
+      direction: readEnum(record, 'direction', SCROLL_DIRECTIONS),
+      origin: readPoint(record, 'origin'),
+      distance: readOptionalInteger(record, 'distance', { min: 0 }),
+      durationMs: readOptionalGestureDuration(record),
+    };
+  }
+  if (kind === 'swipe') {
+    return {
+      kind,
+      preset: readEnum(record, 'preset', SWIPE_PRESETS),
+      durationMs: readOptionalGestureDuration(record),
+    };
+  }
+  if (kind === 'pinch') {
+    return {
+      kind,
+      scale: readNumber(record, 'scale'),
+      origin: readOptionalPoint(record, 'origin'),
+    };
+  }
+  if (kind === 'rotate') {
+    return {
+      kind,
+      degrees: readNumber(record, 'degrees'),
+      origin: readOptionalPoint(record, 'origin'),
+      velocity: readOptionalRotateVelocity(record),
+    };
+  }
+  return {
+    kind,
+    origin: readPoint(record, 'origin'),
+    delta: readPoint(record, 'delta'),
+    scale: readNumber(record, 'scale'),
+    degrees: readNumber(record, 'degrees'),
+    durationMs: readOptionalGestureDuration(record),
+  };
+}
+
+function readOptionalRotateVelocity(record: Record<string, unknown>): number | undefined {
+  if (record.velocity === undefined) return undefined;
+  const velocity = readNumber(record, 'velocity');
+  if (velocity === 0) {
+    throw new AppError('INVALID_ARGS', 'Expected velocity to be a non-zero finite number.');
+  }
+  return velocity;
+}
+
+function readOptionalGestureDuration(record: Record<string, unknown>): number | undefined {
+  const durationMs = readOptionalInteger(record, 'durationMs');
+  if (durationMs === undefined) return undefined;
+  if (durationMs < GESTURE_DURATION_MIN_MS || durationMs > GESTURE_DURATION_MAX_MS) {
+    throw new AppError(
+      'INVALID_ARGS',
+      `Expected durationMs to be an integer between ${GESTURE_DURATION_MIN_MS} and ${GESTURE_DURATION_MAX_MS}.`,
+    );
+  }
+  return durationMs;
+}
+
+function readRecord(input: unknown): Record<string, unknown> {
+  if (!input || typeof input !== 'object' || Array.isArray(input)) {
+    throw new AppError('INVALID_ARGS', 'gesture requires structured object input');
+  }
+  return input as Record<string, unknown>;
+}
+
+function readPoint(record: Record<string, unknown>, key: string): Point {
+  const point = readRecord(record[key]);
+  return { x: readNumber(point, 'x'), y: readNumber(point, 'y') };
+}
+
+function readOptionalPoint(record: Record<string, unknown>, key: string): Point | undefined {
+  return record[key] === undefined ? undefined : readPoint(record, key);
+}
+
+function readNumber(record: Record<string, unknown>, key: string): number {
+  const value = record[key];
+  if (typeof value !== 'number' || !Number.isFinite(value)) {
+    throw new AppError('INVALID_ARGS', `Expected ${key} to be a finite number.`);
+  }
+  return value;
+}
+
+function readEnum<const Values extends readonly string[]>(
+  record: Record<string, unknown>,
+  key: string,
+  values: Values,
+): Values[number] {
+  const value = record[key];
+  if (typeof value !== 'string' || !values.includes(value)) {
+    throw new AppError('INVALID_ARGS', `Expected ${key} to be one of: ${values.join(', ')}.`);
+  }
+  return value;
+}
diff --git a/src/contracts/gesture-normalization.test.ts b/src/contracts/gesture-normalization.test.ts
new file mode 100644
index 000000000..1704d7079
--- /dev/null
+++ b/src/contracts/gesture-normalization.test.ts
@@ -0,0 +1,138 @@
+import assert from 'node:assert/strict';
+import { test } from 'vitest';
+import {
+  gesturePayloadFromPositionals,
+  gesturePayloadToPositionals,
+  normalizePublicGesture,
+  swipePayloadFromPositionals,
+} from './gesture-normalization.ts';
+
+test('CLI and .ad positionals normalize at one explicit syntax seam', () => {
+  assert.deepEqual(gesturePayloadFromPositionals(['pan', '10', '20', '30', '-40', '500'], 2), {
+    kind: 'pan',
+    origin: { x: 10, y: 20 },
+    delta: { x: 30, y: -40 },
+    durationMs: 500,
+    pointerCount: 2,
+  });
+});
+
+test('CLI and .ad coordinate swipes normalize at one explicit syntax seam', () => {
+  assert.deepEqual(
+    swipePayloadFromPositionals(['10', '20', '30', '40', '300'], {
+      count: 2,
+      pauseMs: 5,
+      pattern: 'ping-pong',
+    }),
+    {
+      from: { x: 10, y: 20 },
+      to: { x: 30, y: 40 },
+      durationMs: 300,
+      count: 2,
+      pauseMs: 5,
+      pattern: 'ping-pong',
+    },
+  );
+});
+
+test('gesture recording codec round-trips structured requests', () => {
+  const payload = {
+    kind: 'transform' as const,
+    origin: { x: 10, y: 20 },
+    delta: { x: 30, y: -40 },
+    scale: 1.5,
+    degrees: -35,
+    durationMs: 600,
+  };
+  assert.deepEqual(gesturePayloadFromPositionals(gesturePayloadToPositionals(payload)), payload);
+});
+
+test('gesture recording codec preserves timed fling duration when distance is omitted', () => {
+  const payload = {
+    kind: 'fling' as const,
+    direction: 'left' as const,
+    origin: { x: 10, y: 20 },
+    durationMs: 600,
+  };
+  const positionals = gesturePayloadToPositionals(payload);
+  assert.deepEqual(positionals, ['fling', 'left', '10', '20', '180', '600']);
+  assert.deepEqual(normalizePublicGesture(gesturePayloadFromPositionals(positionals)), {
+    gesture: {
+      intent: 'pan',
+      origin: { x: 10, y: 20 },
+      delta: { x: -180, y: 0 },
+      durationMs: 600,
+    },
+    deprecations: [{ rule: 'fling-duration', replacement: 'Use gesture pan for timed movement.' }],
+  });
+});
+
+test('pinch and rotate syntax rejects a partial origin', () => {
+  assert.throws(() => gesturePayloadFromPositionals(['pinch', '1.5', '100']), {
+    code: 'INVALID_ARGS',
+  });
+  assert.throws(() => gesturePayloadFromPositionals(['rotate', '35', '100']), {
+    code: 'INVALID_ARGS',
+  });
+});
+
+test('rotate serialization omits behaviorless velocity when no origin can delimit it', () => {
+  assert.deepEqual(gesturePayloadToPositionals({ kind: 'rotate', degrees: 35, velocity: 2 }), [
+    'rotate',
+    '35',
+  ]);
+});
+
+test('swipe is fling sugar unless legacy duration requests a pan', () => {
+  assert.deepEqual(normalizePublicGesture({ kind: 'swipe', preset: 'left' }), {
+    gesture: { intent: 'fling', preset: 'left' },
+    deprecations: [],
+  });
+  assert.deepEqual(normalizePublicGesture({ kind: 'swipe', preset: 'left', durationMs: 400 }), {
+    gesture: { intent: 'pan', preset: 'left', durationMs: 400 },
+    deprecations: [{ rule: 'swipe-duration', replacement: 'Use gesture pan for timed movement.' }],
+  });
+});
+
+test('duration-bearing fling is an explicit compatibility alias for pan', () => {
+  assert.deepEqual(
+    normalizePublicGesture({
+      kind: 'fling',
+      direction: 'left',
+      origin: { x: 200, y: 300 },
+      distance: 80,
+      durationMs: 500,
+    }),
+    {
+      gesture: {
+        intent: 'pan',
+        origin: { x: 200, y: 300 },
+        delta: { x: -80, y: 0 },
+        durationMs: 500,
+      },
+      deprecations: [
+        { rule: 'fling-duration', replacement: 'Use gesture pan for timed movement.' },
+      ],
+    },
+  );
+});
+
+test('multi-touch aliases become constraints on transform motion', () => {
+  assert.deepEqual(normalizePublicGesture({ kind: 'pinch', scale: 1.5 }).gesture, {
+    intent: 'pinch',
+    origin: undefined,
+    scale: 1.5,
+  });
+  assert.deepEqual(normalizePublicGesture({ kind: 'rotate', degrees: -45, velocity: 2 }), {
+    gesture: { intent: 'rotate', origin: undefined, degrees: -45 },
+    deprecations: [
+      { rule: 'rotate-velocity', replacement: 'Rotation pacing is derived from degrees.' },
+    ],
+  });
+  assert.deepEqual(normalizePublicGesture({ kind: 'rotate', degrees: -45, velocity: -1.5 }), {
+    gesture: { intent: 'rotate', origin: undefined, degrees: -45 },
+    deprecations: [
+      { rule: 'rotate-velocity', replacement: 'Rotation pacing is derived from degrees.' },
+    ],
+  });
+});
diff --git a/src/contracts/gesture-normalization.ts b/src/contracts/gesture-normalization.ts
new file mode 100644
index 000000000..5adcdaf06
--- /dev/null
+++ b/src/contracts/gesture-normalization.ts
@@ -0,0 +1,267 @@
+import type { Point } from '../kernel/snapshot.ts';
+import { AppError } from '../kernel/errors.ts';
+import { gestureDirectionDelta } from './scroll-gesture.ts';
+import { readGesturePayload, type GesturePayload } from './gesture-input.ts';
+import { GESTURE_FLING_DEFAULT_DISTANCE } from './gesture-plan.ts';
+import type { GestureSemanticInput } from './gesture-plan-types.ts';
+
+export type GestureCompatibilityRule = 'swipe-duration' | 'fling-duration' | 'rotate-velocity';
+
+export type GestureDeprecation = {
+  rule: GestureCompatibilityRule;
+  replacement: string;
+};
+
+export type NormalizedPublicGesture = {
+  gesture: GestureSemanticInput;
+  deprecations: GestureDeprecation[];
+};
+
+export type SwipePayload = {
+  from: Point;
+  to: Point;
+  durationMs?: number;
+  count?: number;
+  pauseMs?: number;
+  pattern?: 'one-way' | 'ping-pong';
+};
+
+/** The explicit parser for the public CLI and `.ad` gesture syntax. */
+// fallow-ignore-next-line complexity
+export function gesturePayloadFromPositionals(
+  positionals: string[],
+  pointerCount?: number,
+): GesturePayload {
+  const kind = positionals[0];
+  const args = positionals.slice(1);
+  switch (kind) {
+    case 'pan':
+      return readGesturePayload({
+        kind,
+        origin: { x: Number(args[0]), y: Number(args[1]) },
+        delta: { x: Number(args[2]), y: Number(args[3]) },
+        pointerCount,
+        durationMs: optionalPositionNumber(args[4]),
+      });
+    case 'fling':
+      return readGesturePayload({
+        kind,
+        direction: args[0],
+        origin: { x: Number(args[1]), y: Number(args[2]) },
+        distance: optionalPositionNumber(args[3]),
+        durationMs: optionalPositionNumber(args[4]),
+      });
+    case 'swipe':
+      return readGesturePayload({
+        kind,
+        preset: args[0],
+        durationMs: optionalPositionNumber(args[1]),
+      });
+    case 'pinch':
+      return readGesturePayload({
+        kind,
+        scale: Number(args[0]),
+        origin: optionalOrigin(args[1], args[2]),
+      });
+    case 'rotate':
+      return readGesturePayload({
+        kind,
+        degrees: Number(args[0]),
+        origin: optionalOrigin(args[1], args[2]),
+        velocity: optionalPositionNumber(args[3]),
+      });
+    case 'transform':
+      return readGesturePayload({
+        kind,
+        origin: { x: Number(args[0]), y: Number(args[1]) },
+        delta: { x: Number(args[2]), y: Number(args[3]) },
+        scale: Number(args[4]),
+        degrees: Number(args[5]),
+        durationMs: optionalPositionNumber(args[6]),
+      });
+    default:
+      return readGesturePayload({ kind });
+  }
+}
+
+/** Serializes structured gesture input for `.ad` recordings. */
+export function gesturePayloadToPositionals(input: GesturePayload): string[] {
+  switch (input.kind) {
+    case 'pan':
+      return compact([
+        input.kind,
+        input.origin.x,
+        input.origin.y,
+        input.delta.x,
+        input.delta.y,
+        input.durationMs,
+      ]);
+    case 'fling':
+      // `.ad` positionals cannot encode an empty distance slot. Preserve the
+      // planner default when a deprecated duration must occupy the next slot.
+      return compact([
+        input.kind,
+        input.direction,
+        input.origin.x,
+        input.origin.y,
+        input.durationMs === undefined
+          ? input.distance
+          : (input.distance ?? GESTURE_FLING_DEFAULT_DISTANCE),
+        input.durationMs,
+      ]);
+    case 'swipe':
+      return compact([input.kind, input.preset, input.durationMs]);
+    case 'pinch':
+      return compact([input.kind, input.scale, input.origin?.x, input.origin?.y]);
+    case 'rotate':
+      return input.origin
+        ? compact([input.kind, input.degrees, input.origin.x, input.origin.y, input.velocity])
+        : [input.kind, String(input.degrees)];
+    case 'transform':
+      return compact([
+        input.kind,
+        input.origin.x,
+        input.origin.y,
+        input.delta.x,
+        input.delta.y,
+        input.scale,
+        input.degrees,
+        input.durationMs,
+      ]);
+  }
+}
+
+/** Parses the public CLI and `.ad` coordinate-swipe syntax. */
+export function swipePayloadFromPositionals(
+  positionals: string[],
+  options: Omit<SwipePayload, 'from' | 'to' | 'durationMs'> = {},
+): SwipePayload {
+  return {
+    from: { x: Number(positionals[0]), y: Number(positionals[1]) },
+    to: { x: Number(positionals[2]), y: Number(positionals[3]) },
+    ...(positionals[4] === undefined ? {} : { durationMs: Number(positionals[4]) }),
+    ...(options.count === undefined ? {} : { count: options.count }),
+    ...(options.pauseMs === undefined ? {} : { pauseMs: options.pauseMs }),
+    ...(options.pattern === undefined ? {} : { pattern: options.pattern }),
+  };
+}
+
+/** The only public/deprecated gesture interpretation point. */
+export function normalizePublicGesture(input: GesturePayload): NormalizedPublicGesture {
+  switch (input.kind) {
+    case 'pan':
+      return {
+        gesture: {
+          intent: 'pan',
+          origin: input.origin,
+          delta: input.delta,
+          pointerCount: input.pointerCount,
+          durationMs: input.durationMs,
+        },
+        deprecations: [],
+      };
+    case 'fling': {
+      if (input.durationMs !== undefined) {
+        return {
+          gesture: {
+            intent: 'pan',
+            origin: input.origin,
+            delta: gestureDirectionDelta(
+              input.direction,
+              input.distance ?? GESTURE_FLING_DEFAULT_DISTANCE,
+            ),
+            durationMs: input.durationMs,
+          },
+          deprecations: [
+            { rule: 'fling-duration', replacement: 'Use gesture pan for timed movement.' },
+          ],
+        };
+      }
+      return {
+        gesture: {
+          intent: 'fling',
+          direction: input.direction,
+          origin: input.origin,
+          distance: input.distance,
+        },
+        deprecations: [],
+      };
+    }
+    case 'swipe':
+      return input.durationMs === undefined
+        ? { gesture: { intent: 'fling', preset: input.preset }, deprecations: [] }
+        : {
+            gesture: { intent: 'pan', preset: input.preset, durationMs: input.durationMs },
+            deprecations: [
+              { rule: 'swipe-duration', replacement: 'Use gesture pan for timed movement.' },
+            ],
+          };
+    case 'pinch':
+      return {
+        gesture: { intent: 'pinch', origin: input.origin, scale: input.scale },
+        deprecations: [],
+      };
+    case 'rotate':
+      return {
+        gesture: { intent: 'rotate', origin: input.origin, degrees: input.degrees },
+        deprecations:
+          input.velocity === undefined
+            ? []
+            : [
+                {
+                  rule: 'rotate-velocity',
+                  replacement: 'Rotation pacing is derived from degrees.',
+                },
+              ],
+      };
+    case 'transform':
+      return {
+        gesture: {
+          intent: 'transform',
+          origin: input.origin,
+          delta: input.delta,
+          scale: input.scale,
+          degrees: input.degrees,
+          durationMs: input.durationMs,
+        },
+        deprecations: [],
+      };
+  }
+}
+
+export function normalizePublicSwipeMotion(input: {
+  from: Point;
+  to: Point;
+  durationMs?: number;
+}): NormalizedPublicGesture {
+  if (input.durationMs === undefined) {
+    return {
+      gesture: { intent: 'fling', from: input.from, to: input.to },
+      deprecations: [],
+    };
+  }
+  return {
+    gesture: {
+      intent: 'pan',
+      origin: input.from,
+      delta: { x: input.to.x - input.from.x, y: input.to.y - input.from.y },
+      durationMs: input.durationMs,
+    },
+    deprecations: [{ rule: 'swipe-duration', replacement: 'Use gesture pan for timed movement.' }],
+  };
+}
+
+function optionalPositionNumber(value: string | undefined): number | undefined {
+  return value === undefined ? undefined : Number(value);
+}
+
+function optionalOrigin(x: string | undefined, y: string | undefined): Point | undefined {
+  if ((x === undefined) !== (y === undefined)) {
+    throw new AppError('INVALID_ARGS', 'gesture origin requires both x and y coordinates');
+  }
+  return x === undefined ? undefined : { x: Number(x), y: Number(y) };
+}
+
+function compact(values: Array<string | number | undefined>): string[] {
+  return values.filter((value): value is string | number => value !== undefined).map(String);
+}
diff --git a/src/contracts/gesture-plan-types.ts b/src/contracts/gesture-plan-types.ts
new file mode 100644
index 000000000..797628b5c
--- /dev/null
+++ b/src/contracts/gesture-plan-types.ts
@@ -0,0 +1,62 @@
+import type { Point, Rect } from '../kernel/snapshot.ts';
+import type { ScrollDirection, SwipePreset } from './scroll-gesture.ts';
+
+export type GesturePointerCount = 1 | 2;
+
+export const GESTURE_DURATION_MIN_MS = 16;
+export const GESTURE_DURATION_MAX_MS = 10_000;
+
+export type GestureIntent = 'fling' | 'pan' | 'pinch' | 'rotate' | 'transform';
+
+export type GestureSemanticInput =
+  | { intent: 'fling'; from: Point; to: Point }
+  | { intent: 'fling'; preset: SwipePreset }
+  | {
+      intent: 'fling';
+      direction: ScrollDirection;
+      origin: Point;
+      distance?: number;
+    }
+  | {
+      intent: 'pan';
+      origin: Point;
+      delta: Point;
+      pointerCount?: GesturePointerCount;
+      durationMs?: number;
+    }
+  | { intent: 'pan'; preset: SwipePreset; durationMs: number }
+  | { intent: 'pinch'; origin?: Point; scale: number }
+  | { intent: 'rotate'; origin?: Point; degrees: number }
+  | {
+      intent: 'transform';
+      origin: Point;
+      delta: Point;
+      scale: number;
+      degrees: number;
+      durationMs?: number;
+    };
+
+export type PointerTrajectorySample = { offsetMs: number; point: Point };
+
+export type PointerTrajectory = {
+  pointerId: 0 | 1;
+  samples: readonly PointerTrajectorySample[];
+};
+
+export type SinglePointerGesturePlan = {
+  topology: 'single';
+  intent: 'fling' | 'pan';
+  durationMs: number;
+  viewport: Rect;
+  pointers: readonly [PointerTrajectory];
+};
+
+export type MultiTouchGesturePlan = {
+  topology: 'two';
+  intent: 'pan' | 'pinch' | 'rotate' | 'transform';
+  durationMs: number;
+  viewport: Rect;
+  pointers: readonly [PointerTrajectory, PointerTrajectory];
+};
+
+export type GesturePlan = SinglePointerGesturePlan | MultiTouchGesturePlan;
diff --git a/src/contracts/gesture-plan.ts b/src/contracts/gesture-plan.ts
new file mode 100644
index 000000000..ac05b9c45
--- /dev/null
+++ b/src/contracts/gesture-plan.ts
@@ -0,0 +1,464 @@
+import { AppError } from '../kernel/errors.ts';
+import type { PublicPlatform } from '../kernel/device.ts';
+import type { Point, Rect } from '../kernel/snapshot.ts';
+import {
+  buildSwipePresetGesturePlan,
+  gestureDirectionDelta,
+  type SwipePreset,
+} from './scroll-gesture.ts';
+import { GESTURE_DURATION_MAX_MS, GESTURE_DURATION_MIN_MS } from './gesture-plan-types.ts';
+import type {
+  GesturePlan,
+  GestureSemanticInput,
+  MultiTouchGesturePlan,
+  PointerTrajectory,
+  SinglePointerGesturePlan,
+} from './gesture-plan-types.ts';
+
+export * from './gesture-plan-types.ts';
+
+export const GESTURE_SAMPLE_INTERVAL_MS = 16;
+export const GESTURE_INITIAL_ANGLE_DEGREES = -90;
+export const GESTURE_FLING_DEFAULT_DISTANCE = 180;
+
+const GESTURE_INITIAL_SPAN_RATIO = 0.25;
+const GESTURE_PINCH_INITIAL_SPAN_RATIO = 0.4;
+const GESTURE_HORIZONTAL_ANGLE_DEGREES = 0;
+const GESTURE_MINIMUM_RELIABLE_SPAN_PX = 48;
+const GESTURE_VIEWPORT_INSET_PX = 1;
+const DEFAULT_PAN_DURATION_MS = 500;
+export const GESTURE_FLING_DURATION_MS = 100;
+const DEFAULT_MULTI_TOUCH_DURATION_MS = 300;
+const MAX_ROTATION_DEGREES_PER_SAMPLE = 3;
+const MAX_ROTATION_DEFAULT_DURATION_MS = 2_400;
+
+type GesturePlatformProfile = {
+  pinchAxisDegrees: number;
+  frameCount: (rawFrameCount: number) => number;
+};
+
+const DEFAULT_GESTURE_PLATFORM_PROFILE: GesturePlatformProfile = {
+  pinchAxisDegrees: GESTURE_INITIAL_ANGLE_DEGREES,
+  frameCount: Math.floor,
+};
+const GESTURE_PLATFORM_PROFILES = {
+  ios: DEFAULT_GESTURE_PLATFORM_PROFILE,
+  macos: DEFAULT_GESTURE_PLATFORM_PROFILE,
+  android: {
+    pinchAxisDegrees: GESTURE_HORIZONTAL_ANGLE_DEGREES,
+    frameCount: Math.round,
+  },
+  linux: DEFAULT_GESTURE_PLATFORM_PROFILE,
+  web: DEFAULT_GESTURE_PLATFORM_PROFILE,
+} satisfies Record<PublicPlatform, GesturePlatformProfile>;
+
+/** Plans one physical gesture. Public aliases must be normalized before this boundary. */
+export function buildGesturePlan(
+  input: GestureSemanticInput,
+  viewport: Rect,
+  platform?: PublicPlatform,
+): GesturePlan {
+  const frame = normalizeViewport(viewport);
+  const profile = gesturePlatformProfile(platform);
+  switch (input.intent) {
+    case 'fling':
+      return buildFlingPlan(input, frame, profile);
+    case 'pan':
+      return buildPanPlan(input, frame, profile);
+    case 'pinch':
+      return buildTransformPlan(
+        {
+          intent: 'pinch',
+          origin: input.origin ?? centerOfViewport(frame),
+          delta: { x: 0, y: 0 },
+          scale: normalizeScale(input.scale, 'gesture pinch scale'),
+          rotationDegrees: 0,
+          durationMs: DEFAULT_MULTI_TOUCH_DURATION_MS,
+        },
+        frame,
+        profile,
+      );
+    case 'rotate': {
+      const rotationDegrees = finiteNumber(input.degrees, 'gesture rotate degrees');
+      return buildTransformPlan(
+        {
+          intent: 'rotate',
+          origin: input.origin ?? centerOfViewport(frame),
+          delta: { x: 0, y: 0 },
+          scale: 1,
+          rotationDegrees,
+          durationMs: defaultTransformDuration(rotationDegrees),
+        },
+        frame,
+        profile,
+      );
+    }
+    case 'transform': {
+      const rotationDegrees = finiteNumber(input.degrees, 'gesture transform degrees');
+      return buildTransformPlan(
+        {
+          intent: 'transform',
+          origin: input.origin,
+          delta: input.delta,
+          scale: normalizeScale(input.scale, 'gesture transform scale'),
+          rotationDegrees,
+          durationMs: normalizeDuration(
+            input.durationMs,
+            defaultTransformDuration(rotationDegrees),
+            'gesture transform durationMs',
+          ),
+        },
+        frame,
+        profile,
+      );
+    }
+  }
+}
+
+export function singlePointerPlanEndpoints(plan: SinglePointerGesturePlan): {
+  start: Point;
+  end: Point;
+} {
+  const start = plan.pointers[0].samples[0]?.point;
+  const end = plan.pointers[0].samples.at(-1)?.point;
+  if (!start || !end) {
+    throw new AppError('INVALID_ARGS', 'single-pointer gesture plan requires samples');
+  }
+  return { start, end };
+}
+
+function buildFlingPlan(
+  input: Extract<GestureSemanticInput, { intent: 'fling' }>,
+  viewport: Rect,
+  profile: GesturePlatformProfile,
+): SinglePointerGesturePlan {
+  if ('preset' in input) {
+    const { from, to } = presetGestureEndpoints(input.preset, viewport);
+    return buildSinglePointerPlan('fling', from, to, GESTURE_FLING_DURATION_MS, viewport, profile);
+  }
+  if ('from' in input) {
+    return buildSinglePointerPlan(
+      'fling',
+      input.from,
+      input.to,
+      GESTURE_FLING_DURATION_MS,
+      viewport,
+      profile,
+    );
+  }
+  const start = finitePoint(input.origin, 'gesture fling origin');
+  const distance = positiveNumber(
+    input.distance ?? GESTURE_FLING_DEFAULT_DISTANCE,
+    'gesture fling distance',
+  );
+  return buildSinglePointerPlan(
+    'fling',
+    start,
+    addPoints(start, gestureDirectionDelta(input.direction, distance)),
+    GESTURE_FLING_DURATION_MS,
+    viewport,
+    profile,
+  );
+}
+
+function buildPanPlan(
+  input: Extract<GestureSemanticInput, { intent: 'pan' }>,
+  viewport: Rect,
+  profile: GesturePlatformProfile,
+): GesturePlan {
+  const durationMs = normalizeDuration(
+    input.durationMs,
+    DEFAULT_PAN_DURATION_MS,
+    'gesture pan durationMs',
+  );
+  if ('preset' in input) {
+    const { from, to } = presetGestureEndpoints(input.preset, viewport);
+    return buildSinglePointerPlan('pan', from, to, durationMs, viewport, profile);
+  }
+  if ((input.pointerCount ?? 1) === 1) {
+    const start = finitePoint(input.origin, 'gesture pan origin');
+    const delta = finitePoint(input.delta, 'gesture pan delta');
+    return buildSinglePointerPlan(
+      'pan',
+      start,
+      addPoints(start, delta),
+      durationMs,
+      viewport,
+      profile,
+    );
+  }
+  if (input.pointerCount !== 2) {
+    throw new AppError('INVALID_ARGS', 'gesture pan pointerCount must be 1 or 2');
+  }
+  return buildTransformPlan(
+    {
+      intent: 'pan',
+      origin: input.origin,
+      delta: input.delta,
+      scale: 1,
+      rotationDegrees: 0,
+      durationMs,
+    },
+    viewport,
+    profile,
+  );
+}
+
+function buildSinglePointerPlan(
+  intent: SinglePointerGesturePlan['intent'],
+  from: Point,
+  to: Point,
+  durationMs: number,
+  viewport: Rect,
+  profile: GesturePlatformProfile,
+): SinglePointerGesturePlan {
+  const start = finitePoint(from, `gesture ${intent} start`);
+  const end = finitePoint(to, `gesture ${intent} end`);
+  const samples = sampleOffsets(durationMs, profile).map((offsetMs) => ({
+    offsetMs,
+    point: interpolatePoint(start, end, offsetMs / durationMs),
+  }));
+  assertSamplesInViewport(samples, viewport, { intent, pointerId: 0 });
+  return {
+    topology: 'single',
+    intent,
+    durationMs,
+    viewport,
+    pointers: [{ pointerId: 0, samples }],
+  };
+}
+
+function buildTransformPlan(
+  motion: {
+    intent: MultiTouchGesturePlan['intent'];
+    origin: Point;
+    delta: Point;
+    scale: number;
+    rotationDegrees: number;
+    durationMs: number;
+  },
+  viewport: Rect,
+  profile: GesturePlatformProfile,
+): MultiTouchGesturePlan {
+  const start = finitePoint(motion.origin, `gesture ${motion.intent} origin`);
+  const delta = finitePoint(motion.delta, `gesture ${motion.intent} delta`);
+  const end = addPoints(start, delta);
+  const maximumSpan =
+    Math.min(viewport.width, viewport.height) * initialSpanRatioForIntent(motion.intent);
+  const initialSpan = motion.scale > 1 ? maximumSpan / motion.scale : maximumSpan;
+  const finalSpan = initialSpan * motion.scale;
+  if (Math.min(initialSpan, finalSpan) < GESTURE_MINIMUM_RELIABLE_SPAN_PX) {
+    throw trajectoryOutOfBounds({
+      intent: motion.intent,
+      viewport,
+      initialSpan,
+      finalSpan,
+      minimumReliableSpan: GESTURE_MINIMUM_RELIABLE_SPAN_PX,
+    });
+  }
+  const initialRadius = initialSpan / 2;
+
+  const offsets = sampleOffsets(motion.durationMs, profile);
+  const trajectory = (pointerId: 0 | 1, side: 1 | -1): PointerTrajectory => {
+    const samples = offsets.map((offsetMs) => ({
+      offsetMs,
+      point: transformPointAt({
+        ...motion,
+        start,
+        end,
+        initialRadius,
+        offsetMs,
+        side,
+        profile,
+      }),
+    }));
+    assertSamplesInViewport(samples, viewport, { intent: motion.intent, pointerId });
+    return { pointerId, samples };
+  };
+
+  return {
+    topology: 'two',
+    intent: motion.intent,
+    durationMs: motion.durationMs,
+    viewport,
+    pointers: [trajectory(0, 1), trajectory(1, -1)],
+  };
+}
+
+function transformPointAt(options: {
+  intent: MultiTouchGesturePlan['intent'];
+  start: Point;
+  end: Point;
+  initialRadius: number;
+  scale: number;
+  rotationDegrees: number;
+  durationMs: number;
+  offsetMs: number;
+  side: 1 | -1;
+  profile: GesturePlatformProfile;
+}): Point {
+  const progress = options.offsetMs / options.durationMs;
+  const centroid = interpolatePoint(options.start, options.end, progress);
+  const radius = options.initialRadius * (1 + (options.scale - 1) * progress);
+  const angle = degreesToRadians(
+    initialAngleForIntent(options.intent, options.profile) + options.rotationDegrees * progress,
+  );
+  return {
+    x: centroid.x + Math.cos(angle) * radius * options.side,
+    y: centroid.y + Math.sin(angle) * radius * options.side,
+  };
+}
+
+function initialAngleForIntent(
+  intent: MultiTouchGesturePlan['intent'],
+  profile: GesturePlatformProfile,
+): number {
+  return intent === 'pinch' ? profile.pinchAxisDegrees : GESTURE_INITIAL_ANGLE_DEGREES;
+}
+
+function initialSpanRatioForIntent(intent: MultiTouchGesturePlan['intent']): number {
+  return intent === 'pinch' ? GESTURE_PINCH_INITIAL_SPAN_RATIO : GESTURE_INITIAL_SPAN_RATIO;
+}
+
+function sampleOffsets(durationMs: number, profile: GesturePlatformProfile): number[] {
+  const rawFrameCount = durationMs / GESTURE_SAMPLE_INTERVAL_MS;
+  const frameCount = Math.max(3, profile.frameCount(rawFrameCount));
+  return Array.from({ length: frameCount + 1 }, (_, index) =>
+    Math.round((durationMs * index) / frameCount),
+  );
+}
+
+function assertSamplesInViewport(
+  samples: readonly { offsetMs: number; point: Point }[],
+  viewport: Rect,
+  details: Record<string, unknown>,
+): void {
+  const maxX = viewport.x + viewport.width - GESTURE_VIEWPORT_INSET_PX;
+  const maxY = viewport.y + viewport.height - GESTURE_VIEWPORT_INSET_PX;
+  for (const sample of samples) {
+    const { x, y } = sample.point;
+    if (!Number.isFinite(x) || !Number.isFinite(y)) {
+      throw new AppError('INVALID_ARGS', 'Gesture motion produces non-finite pointer coordinates', {
+        ...details,
+        reason: 'GESTURE_TRAJECTORY_NON_FINITE',
+        hint: 'Reduce the requested rotation, translation, or scale.',
+      });
+    }
+    if (
+      x < viewport.x + GESTURE_VIEWPORT_INSET_PX ||
+      x > maxX ||
+      y < viewport.y + GESTURE_VIEWPORT_INSET_PX ||
+      y > maxY
+    ) {
+      throw trajectoryOutOfBounds({ ...details, viewport, sample });
+    }
+  }
+}
+
+function trajectoryOutOfBounds(details: Record<string, unknown>): AppError {
+  return new AppError('INVALID_ARGS', 'Gesture trajectory does not fit inside the viewport', {
+    ...details,
+    reason: 'GESTURE_TRAJECTORY_OUT_OF_BOUNDS',
+    hint: 'Move the gesture away from the edge or reduce its translation, scale, or rotation.',
+  });
+}
+
+function normalizeViewport(viewport: Rect): Rect {
+  const frame = {
+    x: finiteNumber(viewport.x, 'gesture viewport x'),
+    y: finiteNumber(viewport.y, 'gesture viewport y'),
+    width: finiteNumber(viewport.width, 'gesture viewport width'),
+    height: finiteNumber(viewport.height, 'gesture viewport height'),
+  };
+  if (frame.width <= 0 || frame.height <= 0) {
+    throw new AppError('INVALID_ARGS', 'gesture viewport width and height must be positive');
+  }
+  return frame;
+}
+
+function normalizeDuration(value: number | undefined, fallback: number, field: string): number {
+  const durationMs = value ?? fallback;
+  if (
+    !Number.isInteger(durationMs) ||
+    durationMs < GESTURE_DURATION_MIN_MS ||
+    durationMs > GESTURE_DURATION_MAX_MS
+  ) {
+    throw new AppError(
+      'INVALID_ARGS',
+      `${field} must be an integer between ${GESTURE_DURATION_MIN_MS} and ${GESTURE_DURATION_MAX_MS}`,
+    );
+  }
+  return durationMs;
+}
+
+function defaultTransformDuration(rotationDegrees: number): number {
+  const rotationDuration =
+    Math.ceil(Math.abs(rotationDegrees) / MAX_ROTATION_DEGREES_PER_SAMPLE) *
+    GESTURE_SAMPLE_INTERVAL_MS;
+  return Math.min(
+    Math.max(DEFAULT_MULTI_TOUCH_DURATION_MS, rotationDuration),
+    MAX_ROTATION_DEFAULT_DURATION_MS,
+  );
+}
+
+function finitePoint(point: Point, field: string): Point {
+  return {
+    x: finiteNumber(point.x, `${field} x`),
+    y: finiteNumber(point.y, `${field} y`),
+  };
+}
+
+function finiteNumber(value: number, field: string): number {
+  if (!Number.isFinite(value)) {
+    throw new AppError('INVALID_ARGS', `${field} must be a finite number`);
+  }
+  return value;
+}
+
+function normalizeScale(value: number, field: string): number {
+  const scale = finiteNumber(value, field);
+  if (scale <= 0) throw new AppError('INVALID_ARGS', `${field} must be greater than 0`);
+  return scale;
+}
+
+function positiveNumber(value: number, field: string): number {
+  const number = finiteNumber(value, field);
+  if (number <= 0) throw new AppError('INVALID_ARGS', `${field} must be a positive number`);
+  return number;
+}
+
+function centerOfViewport(viewport: Rect): Point {
+  return { x: viewport.x + viewport.width / 2, y: viewport.y + viewport.height / 2 };
+}
+
+function addPoints(left: Point, right: Point): Point {
+  return { x: left.x + right.x, y: left.y + right.y };
+}
+
+function interpolatePoint(start: Point, end: Point, progress: number): Point {
+  return {
+    x: start.x + (end.x - start.x) * progress,
+    y: start.y + (end.y - start.y) * progress,
+  };
+}
+
+function presetGestureEndpoints(preset: SwipePreset, viewport: Rect): { from: Point; to: Point } {
+  const relative = buildSwipePresetGesturePlan(preset, {
+    referenceWidth: viewport.width,
+    referenceHeight: viewport.height,
+  });
+  return {
+    from: { x: viewport.x + relative.x1, y: viewport.y + relative.y1 },
+    to: { x: viewport.x + relative.x2, y: viewport.y + relative.y2 },
+  };
+}
+
+function gesturePlatformProfile(platform: PublicPlatform | undefined): GesturePlatformProfile {
+  return platform === undefined
+    ? DEFAULT_GESTURE_PLATFORM_PROFILE
+    : GESTURE_PLATFORM_PROFILES[platform];
+}
+
+function degreesToRadians(degrees: number): number {
+  return (degrees * Math.PI) / 180;
+}
diff --git a/src/contracts/scroll-gesture.ts b/src/contracts/scroll-gesture.ts
index 9e17d26d1..1e7f86fff 100644
--- a/src/contracts/scroll-gesture.ts
+++ b/src/contracts/scroll-gesture.ts
@@ -8,9 +8,9 @@ export const SWIPE_PRESETS = ['left', 'right', 'left-edge', 'right-edge'] as con
 export type SwipePreset = (typeof SWIPE_PRESETS)[number];
 export const SWIPE_PATTERNS = ['one-way', 'ping-pong'] as const;
 export type SwipePattern = (typeof SWIPE_PATTERNS)[number];
-const SWIPE_PRESET_ENUM = defineStringEnum(SWIPE_PRESETS, {
-  message: 'gesture swipe requires left, right, left-edge, or right-edge',
-});
+export const SWIPE_REPETITION_MAX = 200;
+export const SWIPE_PAUSE_MAX_MS = 10_000;
+export const SWIPE_SERIES_MAX_SCHEDULED_DURATION_MS = 60_000;
 const SCROLL_DIRECTION_ENUM = defineStringEnum(SCROLL_DIRECTIONS, {
   message: (direction) => `Unknown direction: ${direction}`,
 });
@@ -30,7 +30,7 @@ export type GestureReferenceFrame = {
   referenceHeight: number;
 };
 
-export type GesturePoint = {
+type GesturePoint = {
   x: number;
   y: number;
 };
@@ -159,8 +159,17 @@ export function buildSwipePresetGesturePlan(
   };
 }
 
-export function parseSwipePreset(input: string | undefined): SwipePreset {
-  return SWIPE_PRESET_ENUM.parse(input);
+export function gestureDirectionDelta(direction: ScrollDirection, distance: number): GesturePoint {
+  switch (direction) {
+    case 'up':
+      return { x: 0, y: -distance };
+    case 'down':
+      return { x: 0, y: distance };
+    case 'left':
+      return { x: -distance, y: 0 };
+    case 'right':
+      return { x: distance, y: 0 };
+  }
 }
 
 export function inferGestureReferenceFrame(
diff --git a/src/core/__tests__/capabilities.test.ts b/src/core/__tests__/capabilities.test.ts
index fafa78ef1..9852bbc38 100644
--- a/src/core/__tests__/capabilities.test.ts
+++ b/src/core/__tests__/capabilities.test.ts
@@ -1,6 +1,6 @@
 import { test } from 'vitest';
 import assert from 'node:assert/strict';
-import { isCommandSupportedOnDevice, unsupportedHintForDevice } from '../capabilities.ts';
+import { isCommandSupportedOnDevice } from '../capabilities.ts';
 import { matchesPlatformSelector, type DeviceInfo } from '../../kernel/device.ts';
 import { WEB_DESKTOP_DEVICE } from '../../__tests__/test-utils/index.ts';
 
@@ -87,16 +87,6 @@ function assertCommandSupport(commands: string[], checks: SupportCheck[]): void
 
 test('device capability matrix stays consistent across shared command groups', () => {
   const scenarios: Array<{ commands: string[]; checks: SupportCheck[] }> = [
-    {
-      commands: ['pinch'],
-      checks: [
-        { device: iosSimulator, expected: true, label: 'on iOS sim' },
-        { device: iosDevice, expected: false, label: 'on iOS device' },
-        { device: androidDevice, expected: true, label: 'on Android' },
-        { device: macOsDevice, expected: false, label: 'on macOS' },
-        { device: tvOsSimulator, expected: false, label: 'on tvOS simulator' },
-      ],
-    },
     {
       commands: ['alert'],
       checks: [
@@ -163,52 +153,12 @@ test('device capability matrix stays consistent across shared command groups', (
       ],
     },
     {
-      commands: ['swipe'],
-      checks: [
-        { device: iosSimulator, expected: true, label: 'on iOS sim' },
-        { device: iosDevice, expected: true, label: 'on iOS device' },
-        { device: androidDevice, expected: true, label: 'on Android' },
-        { device: macOsDevice, expected: true, label: 'on macOS' },
-      ],
-    },
-    {
-      commands: ['pan'],
-      checks: [
-        { device: iosSimulator, expected: true, label: 'on iOS sim' },
-        { device: iosDevice, expected: true, label: 'on iOS device' },
-        { device: androidDevice, expected: true, label: 'on Android' },
-        { device: macOsDevice, expected: true, label: 'on macOS' },
-        { device: linuxDevice, expected: true, label: 'on Linux' },
-      ],
-    },
-    {
-      commands: ['fling'],
+      commands: ['gesture', 'swipe'],
       checks: [
         { device: iosSimulator, expected: true, label: 'on iOS sim' },
         { device: iosDevice, expected: true, label: 'on iOS device' },
         { device: androidDevice, expected: true, label: 'on Android' },
         { device: macOsDevice, expected: true, label: 'on macOS' },
-        { device: linuxDevice, expected: false, label: 'on Linux' },
-      ],
-    },
-    {
-      commands: ['rotate-gesture'],
-      checks: [
-        { device: iosSimulator, expected: true, label: 'on iOS sim' },
-        { device: iosDevice, expected: false, label: 'on iOS device' },
-        { device: androidDevice, expected: true, label: 'on Android' },
-        { device: macOsDevice, expected: false, label: 'on macOS' },
-        { device: tvOsSimulator, expected: false, label: 'on tvOS simulator' },
-      ],
-    },
-    {
-      commands: ['transform-gesture'],
-      checks: [
-        { device: iosSimulator, expected: true, label: 'on iOS sim' },
-        { device: iosDevice, expected: false, label: 'on iOS device' },
-        { device: androidDevice, expected: true, label: 'on Android' },
-        { device: macOsDevice, expected: false, label: 'on macOS' },
-        { device: tvOsSimulator, expected: false, label: 'on tvOS simulator' },
       ],
     },
   ];
@@ -282,6 +232,7 @@ test('macOS supports the Apple runner interaction core but excludes mobile-only
       'scroll',
       'snapshot',
       'swipe',
+      'gesture',
       'trigger-app-event',
       'type',
       'wait',
@@ -295,7 +246,6 @@ test('macOS supports the Apple runner interaction core but excludes mobile-only
       'home',
       'install',
       'install-from-source',
-      'pinch',
       'push',
       'reinstall',
       'rotate',
@@ -339,11 +289,6 @@ test('tvOS follows iOS capability matrix by device kind', () => {
     ['push', 'settings', 'alert'],
     [{ device: tvOsSimulator, expected: true, label: 'on tvOS simulator' }],
   );
-  assert.equal(
-    isCommandSupportedOnDevice('pinch', tvOsSimulator),
-    false,
-    'pinch on tvOS simulator',
-  );
   assert.equal(
     isCommandSupportedOnDevice('keyboard', tvOsSimulator),
     false,
@@ -394,7 +339,6 @@ test('Linux supports desktop interaction commands and blocks mobile/unsupported
       'logs',
       'network',
       'perf',
-      'pinch',
       'push',
       'record',
       'reinstall',
@@ -439,16 +383,14 @@ test('web supports only the initial browser interaction slice', () => {
       'boot',
       'clipboard',
       'diff',
-      'fling',
+      'gesture',
       'home',
       'install',
       'install-from-source',
       'keyboard',
       'logs',
       'longpress',
-      'pan',
       'perf',
-      'pinch',
       'push',
       'reinstall',
       'rotate',
@@ -487,33 +429,3 @@ test('unknown commands default to supported', () => {
   assert.equal(isCommandSupportedOnDevice('some-future-cmd', androidDevice), true);
   assert.equal(isCommandSupportedOnDevice('some-future-cmd', linuxDevice), true);
 });
-
-test('synthesis gestures carry an actionable unsupported hint at admission', () => {
-  // macOS / tvOS / physical iOS are rejected at admission; the hint redirects to where the
-  // two-finger synthesis path actually works, so callers do not just see a bare "not supported".
-  for (const command of ['pinch', 'rotate-gesture', 'transform-gesture']) {
-    assert.match(
-      unsupportedHintForDevice(command, macOsDevice) ?? '',
-      /multi-touch/i,
-      `${command} macOS hint`,
-    );
-    assert.match(
-      unsupportedHintForDevice(command, tvOsSimulator) ?? '',
-      /touch/i,
-      `${command} tvOS hint`,
-    );
-    assert.match(
-      unsupportedHintForDevice(command, iosDevice) ?? '',
-      /simulator/i,
-      `${command} iOS device hint`,
-    );
-    // Where the gesture IS supported there is nothing to hint.
-    assert.equal(
-      unsupportedHintForDevice(command, iosSimulator),
-      undefined,
-      `${command} iOS sim (supported) hint`,
-    );
-  }
-  // Commands without a hint hook return undefined (admission keeps its generic message).
-  assert.equal(unsupportedHintForDevice('tap', macOsDevice), undefined);
-});
diff --git a/src/core/__tests__/capability-plugin-routing-parity.test.ts b/src/core/__tests__/capability-plugin-routing-parity.test.ts
index f8b3c7357..c7026934a 100644
--- a/src/core/__tests__/capability-plugin-routing-parity.test.ts
+++ b/src/core/__tests__/capability-plugin-routing-parity.test.ts
@@ -106,10 +106,6 @@ const SAMPLE_DEVICES: DeviceInfo[] = [
 const isNotMacOs = (device: DeviceInfo): boolean => !isMacOs(device);
 const isMacOsOrAppleSimulator = (device: DeviceInfo): boolean =>
   isMacOs(device) || device.kind === 'simulator';
-const isIosMobileSimulator = (device: DeviceInfo): boolean =>
-  isIosFamily(device) && device.kind === 'simulator' && device.target !== 'tv';
-const supportsSynthesisGesture = (device: DeviceInfo): boolean =>
-  device.platform === 'android' || isIosMobileSimulator(device);
 const supportsAndroidOrIosNonTv = (device: DeviceInfo): boolean =>
   device.platform === 'android' || (isIosFamily(device) && device.target !== 'tv');
 const supportsTvRemote = (device: DeviceInfo): boolean =>
@@ -121,16 +117,6 @@ const supportsHostAudioProbe = (device: DeviceInfo): boolean =>
     (isMacOs(device) ||
       (isIosFamily(device) && device.kind === 'simulator') ||
       (device.platform === 'android' && device.kind === 'emulator')));
-const synthesisGestureUnsupportedHint = (device: DeviceInfo): string | undefined => {
-  if (isMacOs(device))
-    return 'macOS automation has no multi-touch input — this gesture is supported on Android and the iOS simulator only.';
-  if (isIosFamily(device) && device.target === 'tv')
-    return 'tvOS has no touch input — this gesture is supported on Android and the iOS simulator only.';
-  if (isIosFamily(device) && device.kind === 'device')
-    return 'Two-finger gesture synthesis is iOS-simulator only — not available on physical iOS devices.';
-  return undefined;
-};
-
 // Which commands carry which supports()/unsupportedHint() closure today. The
 // end-to-end assertions cross-check this map against production: a command that
 // gains/loses a closure (or whose closure body changes) breaks parity.
@@ -154,9 +140,6 @@ const SUPPORTS_REF: Record<string, (device: DeviceInfo) => boolean> = {
   settings: (device) =>
     device.platform === 'android' || isMacOs(device) || device.kind === 'simulator',
   audio: supportsHostAudioProbe,
-  pinch: supportsSynthesisGesture,
-  'rotate-gesture': supportsSynthesisGesture,
-  'transform-gesture': supportsSynthesisGesture,
 };
 const HINT_REF: Record<string, (device: DeviceInfo) => string | undefined> = {
   'tv-remote': (device) => {
@@ -170,9 +153,6 @@ const HINT_REF: Record<string, (device: DeviceInfo) => string | undefined> = {
     }
     return isMacOs(device) ? 'tv-remote is supported only on tvOS devices.' : undefined;
   },
-  pinch: synthesisGestureUnsupportedHint,
-  'rotate-gesture': synthesisGestureUnsupportedHint,
-  'transform-gesture': synthesisGestureUnsupportedHint,
 };
 
 // Independent reference for `isCommandSupportedOnDevice` over NON-WEB platforms,
diff --git a/src/core/__tests__/dispatch-interactions.test.ts b/src/core/__tests__/dispatch-interactions.test.ts
index 50bbcb30b..e4b63e07c 100644
--- a/src/core/__tests__/dispatch-interactions.test.ts
+++ b/src/core/__tests__/dispatch-interactions.test.ts
@@ -11,14 +11,7 @@ vi.mock('../../platforms/apple/core/runner/runner-client.ts', async (importOrigi
   return { ...actual, runAppleRunnerCommand: mockRunAppleRunnerCommand };
 });
 
-import {
-  handlePanCommand,
-  handlePressCommand,
-  handleRotateGestureCommand,
-  handleSwipeCommand,
-  handleSwipePresetCommand,
-  handleTransformGestureCommand,
-} from '../dispatch-interactions.ts';
+import { handlePressCommand } from '../dispatch-interactions.ts';
 import type { Interactor } from '../interactor-types.ts';
 import type { RunnerCommand } from '../../platforms/apple/core/runner/runner-contract.ts';
 import { AppError } from '../../kernel/errors.ts';
@@ -46,22 +39,16 @@ function makeUnusedInteractor(): Interactor {
     close: fail,
     tap: fail,
     doubleTap: fail,
-    swipe: fail,
-    pan: fail,
-    fling: fail,
     longPress: fail,
     focus: fail,
     type: fail,
     fill: fail,
     scroll: fail,
-    pinch: fail,
     screenshot: fail,
     snapshot: fail,
     back: fail,
     home: fail,
     rotate: fail,
-    rotateGesture: fail,
-    transformGesture: fail,
     appSwitcher: fail,
     tvRemote: fail,
     readClipboard: fail,
@@ -70,211 +57,6 @@ function makeUnusedInteractor(): Interactor {
   };
 }
 
-test('handleRotateGestureCommand defaults velocity sign to match degrees', async () => {
-  const calls: unknown[][] = [];
-  const interactor = {
-    ...makeUnusedInteractor(),
-    rotateGesture: async (...args: unknown[]) => {
-      calls.push(args);
-    },
-  };
-
-  const result = await handleRotateGestureCommand(IOS_SIMULATOR, interactor, [
-    '-215',
-    '200',
-    '420',
-  ]);
-
-  assert.deepEqual(calls, [[-215, 200, 420, -1]]);
-  assert.deepEqual(result, {
-    degrees: -215,
-    x: 200,
-    y: 420,
-    velocity: -1,
-    message: 'Rotated gesture -215 degrees',
-  });
-});
-
-test('handleSwipePresetCommand resolves Android in-page swipe to content lane', async () => {
-  const calls: unknown[][] = [];
-  const interactor = {
-    ...makeUnusedInteractor(),
-    snapshot: async () => ({
-      backend: 'android' as const,
-      nodes: [
-        {
-          index: 0,
-          type: 'application',
-          rect: { x: 0, y: 0, width: 400, height: 800 },
-        },
-      ],
-    }),
-    swipe: async (...args: unknown[]) => {
-      calls.push(args);
-    },
-  };
-
-  const result = await handleSwipePresetCommand(
-    ANDROID_EMULATOR,
-    interactor,
-    ['left', '300'],
-    undefined,
-  );
-
-  assert.deepEqual(calls, [[340, 400, 60, 400, 300]]);
-  assert.deepEqual(result, {
-    x1: 340,
-    y1: 400,
-    x2: 60,
-    y2: 400,
-    preset: 'left',
-    durationMs: 300,
-    effectiveDurationMs: 300,
-    timingMode: 'direct',
-    count: 1,
-    pauseMs: 0,
-    pattern: 'one-way',
-    message: 'Swiped left',
-  });
-});
-
-test('handleSwipeCommand preserves iOS swipe duration through dispatch', async () => {
-  const calls: unknown[][] = [];
-  const interactor = {
-    ...makeUnusedInteractor(),
-    swipe: async (...args: unknown[]) => {
-      calls.push(args);
-    },
-  };
-
-  const result = await handleSwipeCommand(
-    IOS_SIMULATOR,
-    interactor,
-    ['100', '200', '180', '200', '300'],
-    undefined,
-  );
-
-  assert.deepEqual(calls, [[100, 200, 180, 200, 300]]);
-  assert.deepEqual(result, {
-    x1: 100,
-    y1: 200,
-    x2: 180,
-    y2: 200,
-    durationMs: 300,
-    effectiveDurationMs: 300,
-    timingMode: 'direct',
-    count: 1,
-    pauseMs: 0,
-    pattern: 'one-way',
-    message: 'Swiped',
-  });
-});
-
-test('handleSwipeCommand fuses repeated swipes into sequence drag steps with ping-pong unrolled', async () => {
-  mockRunAppleRunnerCommand.mockResolvedValueOnce({
-    gestureStartUptimeMs: 100,
-    gestureEndUptimeMs: 720,
-    completedSteps: 2,
-    sequenceResults: [
-      { ok: true, kind: 'drag' },
-      { ok: true, kind: 'drag' },
-    ],
-  });
-  const interactor = makeUnusedInteractor();
-
-  const result = await handleSwipeCommand(
-    IOS_SIMULATOR,
-    interactor,
-    ['100', '650', '100', '450', '120'],
-    {
-      count: 2,
-      pauseMs: 50,
-      pattern: 'ping-pong',
-      appBundleId: 'com.example.App',
-    },
-  );
-
-  assert.deepEqual(mockRunAppleRunnerCommand.mock.calls[0]?.[1], {
-    command: 'sequence',
-    steps: [
-      // Ping-pong is unrolled daemon-side: odd indices swap endpoints, replacing the
-      // runner-side pattern handling of the retired dragSeries command.
-      {
-        kind: 'drag',
-        x: 100,
-        y: 650,
-        x2: 100,
-        y2: 450,
-        durationMs: 120,
-        synthesized: true,
-        dragSemantics: 'swipe',
-        pauseMs: 50,
-      },
-      {
-        kind: 'drag',
-        x: 100,
-        y: 450,
-        x2: 100,
-        y2: 650,
-        durationMs: 120,
-        synthesized: true,
-        dragSemantics: 'swipe',
-      },
-    ],
-    appBundleId: 'com.example.App',
-  });
-  assert.equal(result.timingMode, 'runner-sequence');
-  assert.equal(result.completedSteps, 2);
-  assert.equal(result.message, 'Swiped 2 times (ping-pong)');
-});
-
-test('handlePanCommand preserves interactor result metadata', async () => {
-  const calls: unknown[][] = [];
-  const interactor = {
-    ...makeUnusedInteractor(),
-    pan: async (...args: unknown[]) => {
-      calls.push(args);
-      return { backend: 'xctest' };
-    },
-  };
-
-  const result = await handlePanCommand(interactor, ['196', '122', '80', '0', '500']);
-
-  assert.deepEqual(calls, [[196, 122, 276, 122, 500]]);
-  assert.deepEqual(result, {
-    x: 196,
-    y: 122,
-    dx: 80,
-    dy: 0,
-    x2: 276,
-    y2: 122,
-    durationMs: 500,
-    backend: 'xctest',
-    message: 'Panned (196, 122) by (80, 0)',
-  });
-});
-
-test('handleRotateGestureCommand routes Android through the interactor', async () => {
-  const calls: unknown[][] = [];
-  const interactor = {
-    ...makeUnusedInteractor(),
-    rotateGesture: async (...args: unknown[]) => {
-      calls.push(args);
-      return { backend: 'android-multitouch-helper' };
-    },
-  };
-
-  const result = await handleRotateGestureCommand(ANDROID_EMULATOR, interactor, ['145']);
-
-  assert.deepEqual(calls, [[145, undefined, undefined, 1]]);
-  assert.deepEqual(result, {
-    degrees: 145,
-    velocity: 1,
-    backend: 'android-multitouch-helper',
-    message: 'Rotated gesture 145 degrees',
-  });
-});
-
 test('handlePressCommand fuses an iOS jitter series into one sequence runner request', async () => {
   mockRunAppleRunnerCommand.mockResolvedValueOnce({
     completedSteps: 3,
@@ -562,38 +344,3 @@ test('handlePressCommand on Android keeps the direct path even with hold', async
   assert.equal(longPresses.length, 3);
   assert.equal(result.pressed, true);
 });
-
-test('handleTransformGestureCommand routes iOS simulator through the interactor', async () => {
-  const calls: unknown[][] = [];
-  const interactor = {
-    ...makeUnusedInteractor(),
-    transformGesture: async (...args: unknown[]) => {
-      calls.push(args);
-      return { backend: 'xctest' };
-    },
-  };
-
-  const result = await handleTransformGestureCommand(IOS_SIMULATOR, interactor, [
-    '200',
-    '420',
-    '80',
-    '-40',
-    '2',
-    '35',
-  ]);
-
-  assert.deepEqual(calls, [
-    [{ x: 200, y: 420, dx: 80, dy: -40, scale: 2, degrees: 35, durationMs: undefined }],
-  ]);
-  assert.deepEqual(result, {
-    x: 200,
-    y: 420,
-    dx: 80,
-    dy: -40,
-    scale: 2,
-    degrees: 35,
-    durationMs: undefined,
-    backend: 'xctest',
-    message: 'Requested transform gesture by (80, -40), scale 2, rotate 35 degrees',
-  });
-});
diff --git a/src/core/__tests__/dispatch-pinch.test.ts b/src/core/__tests__/dispatch-pinch.test.ts
deleted file mode 100644
index 22768bd59..000000000
--- a/src/core/__tests__/dispatch-pinch.test.ts
+++ /dev/null
@@ -1,48 +0,0 @@
-import { test } from 'vitest';
-import assert from 'node:assert/strict';
-import { dispatchCommand } from '../dispatch.ts';
-import { AppError } from '../../kernel/errors.ts';
-import { MACOS_DEVICE, TVOS_SIMULATOR } from '../../__tests__/test-utils/device-fixtures.ts';
-
-test('dispatch pinch rejects helper-backed macOS surfaces', async () => {
-  await assert.rejects(
-    () => dispatchCommand(MACOS_DEVICE, 'pinch', ['1.5'], undefined, { surface: 'desktop' }),
-    (error: unknown) =>
-      error instanceof AppError &&
-      error.code === 'UNSUPPORTED_OPERATION' &&
-      /macOS app sessions/i.test(error.message),
-  );
-});
-
-test('dispatch pinch rejects tvOS before runner call', async () => {
-  await assert.rejects(
-    () => dispatchCommand(TVOS_SIMULATOR, 'pinch', ['1.5']),
-    (error: unknown) =>
-      error instanceof AppError &&
-      error.code === 'UNSUPPORTED_OPERATION' &&
-      /pinch is not supported on tvOS/i.test(error.message),
-  );
-});
-
-// tvOS is focus-only: coordinate multi-touch gestures have no meaning off the focused
-// element, so rotate/transform reject up front (mirroring pinch above). This pins the
-// UNSUPPORTED coordinate-gesture half of the tvOS interaction contract.
-test('dispatch rotate-gesture rejects tvOS before runner call', async () => {
-  await assert.rejects(
-    () => dispatchCommand(TVOS_SIMULATOR, 'rotate-gesture', ['90']),
-    (error: unknown) =>
-      error instanceof AppError &&
-      error.code === 'UNSUPPORTED_OPERATION' &&
-      /rotate is not supported on tvOS/i.test(error.message),
-  );
-});
-
-test('dispatch transform-gesture rejects tvOS before runner call', async () => {
-  await assert.rejects(
-    () => dispatchCommand(TVOS_SIMULATOR, 'transform-gesture', ['1', '2', '3', '4', '1.5', '90']),
-    (error: unknown) =>
-      error instanceof AppError &&
-      error.code === 'UNSUPPORTED_OPERATION' &&
-      /transform is not supported on tvOS/i.test(error.message),
-  );
-});
diff --git a/src/core/__tests__/dispatch-series.test.ts b/src/core/__tests__/dispatch-series.test.ts
index 641709120..19fa04c22 100644
--- a/src/core/__tests__/dispatch-series.test.ts
+++ b/src/core/__tests__/dispatch-series.test.ts
@@ -2,7 +2,6 @@ import { test } from 'vitest';
 import assert from 'node:assert/strict';
 import {
   requireIntInRange,
-  shouldUseIosDragSeries,
   shouldUseIosPressSequence,
   chunkRunnerSequenceStepsByBudget,
 } from '../dispatch-series.ts';
@@ -48,16 +47,6 @@ test('requireIntInRange throws for non-finite values', () => {
   }
 });
 
-// --- shouldUseIosDragSeries ---
-
-test('shouldUseIosDragSeries returns true for iOS with count > 1', () => {
-  assert.equal(shouldUseIosDragSeries(iosDevice, 2), true);
-});
-
-test('shouldUseIosDragSeries returns false when count is 1', () => {
-  assert.equal(shouldUseIosDragSeries(iosDevice, 1), false);
-});
-
 // --- shouldUseIosPressSequence ---
 
 test('shouldUseIosPressSequence returns true for any iOS multi-press variant', () => {
diff --git a/src/core/__tests__/gesture-capabilities.test.ts b/src/core/__tests__/gesture-capabilities.test.ts
new file mode 100644
index 000000000..bb10df868
--- /dev/null
+++ b/src/core/__tests__/gesture-capabilities.test.ts
@@ -0,0 +1,108 @@
+import assert from 'node:assert/strict';
+import { test } from 'vitest';
+import type { GestureSemanticInput } from '../../contracts/gesture-plan-types.ts';
+import {
+  normalizePublicGesture,
+  normalizePublicSwipeMotion,
+} from '../../contracts/gesture-normalization.ts';
+import { requireGestureSupported } from '../capabilities.ts';
+import { AppError } from '../../kernel/errors.ts';
+import type { DeviceInfo } from '../../kernel/device.ts';
+
+const oneFingerPan: GestureSemanticInput = {
+  intent: 'pan',
+  origin: { x: 100, y: 200 },
+  delta: { x: 40, y: -20 },
+};
+const twoFingerPan: GestureSemanticInput = { ...oneFingerPan, pointerCount: 2 };
+const pinch: GestureSemanticInput = { intent: 'pinch', scale: 1.2 };
+const fling: GestureSemanticInput = {
+  intent: 'fling',
+  direction: 'left',
+  origin: { x: 100, y: 200 },
+};
+
+const device = (fields: Partial<DeviceInfo>): DeviceInfo => ({
+  platform: 'android',
+  id: 'test-device',
+  name: 'Test device',
+  kind: 'emulator',
+  ...fields,
+});
+
+function assertSupported(input: GestureSemanticInput, target: DeviceInfo): void {
+  assert.doesNotThrow(() => requireGestureSupported(input, target));
+}
+
+function assertUnsupported(
+  input: GestureSemanticInput,
+  target: DeviceInfo,
+  expected: RegExp,
+): void {
+  assert.throws(
+    () => requireGestureSupported(input, target),
+    (error: unknown) =>
+      error instanceof AppError &&
+      error.code === 'UNSUPPORTED_OPERATION' &&
+      expected.test(error.message),
+  );
+}
+
+test('Android phones and emulators support single- and multi-touch gesture plans', () => {
+  for (const kind of ['device', 'emulator'] as const) {
+    const target = device({ kind });
+    assertSupported(oneFingerPan, target);
+    assertSupported(twoFingerPan, target);
+    assertSupported(pinch, target);
+  }
+});
+
+test('iOS and iPadOS simulators support multi-touch while physical devices do not', () => {
+  for (const appleOs of ['ios', 'ipados'] as const) {
+    const simulator = device({ platform: 'apple', appleOs, kind: 'simulator' });
+    const physical = device({ platform: 'apple', appleOs, kind: 'device' });
+    assertSupported(oneFingerPan, simulator);
+    assertSupported(twoFingerPan, simulator);
+    assertSupported(pinch, simulator);
+    assertSupported(oneFingerPan, physical);
+    assertUnsupported(twoFingerPan, physical, /physical iOS devices/);
+    assert.throws(
+      () => requireGestureSupported(pinch, physical),
+      (error: unknown) =>
+        error instanceof AppError && /iOS-simulator only/.test(String(error.details?.hint)),
+    );
+  }
+});
+
+test('TV, spatial, watch, desktop, Linux, and web gesture policy stays explicit', () => {
+  const androidTv = device({ target: 'tv' });
+  const tvOs = device({ platform: 'apple', appleOs: 'tvos', kind: 'simulator', target: 'tv' });
+  const visionOs = device({ platform: 'apple', appleOs: 'visionos', kind: 'simulator' });
+  const watchOs = device({ platform: 'apple', appleOs: 'watchos', kind: 'simulator' });
+  const macOs = device({ platform: 'apple', appleOs: 'macos', kind: 'device', target: 'desktop' });
+  const linux = device({ platform: 'linux', kind: 'device', target: 'desktop' });
+  const web = device({ platform: 'web', kind: 'device', target: 'desktop' });
+
+  assertSupported(oneFingerPan, androidTv);
+  assertUnsupported(twoFingerPan, androidTv, /Android TV/);
+  assert.throws(
+    () => requireGestureSupported(twoFingerPan, androidTv),
+    (error: unknown) =>
+      error instanceof AppError &&
+      /Android TV has no touch input/.test(String(error.details?.hint)),
+  );
+  assertUnsupported(twoFingerPan, tvOs, /tvOS/);
+  assertUnsupported(twoFingerPan, visionOs, /visionOS/i);
+  assertUnsupported(oneFingerPan, watchOs, /watchos/);
+  assertSupported(oneFingerPan, macOs);
+  assertUnsupported(twoFingerPan, macOs, /macOS/);
+  assertSupported(oneFingerPan, linux);
+  assertSupported(
+    normalizePublicSwipeMotion({ from: { x: 10, y: 20 }, to: { x: 110, y: 20 } }).gesture,
+    linux,
+  );
+  assertSupported(normalizePublicGesture({ kind: 'swipe', preset: 'left' }).gesture, linux);
+  assertUnsupported(fling, linux, /Linux/);
+  assertUnsupported(twoFingerPan, linux, /linux/i);
+  assertUnsupported(oneFingerPan, web, /web/);
+});
diff --git a/src/core/__tests__/gesture-plan-test-utils.ts b/src/core/__tests__/gesture-plan-test-utils.ts
new file mode 100644
index 000000000..856838f7e
--- /dev/null
+++ b/src/core/__tests__/gesture-plan-test-utils.ts
@@ -0,0 +1,85 @@
+import assert from 'node:assert/strict';
+import type { Point, Rect } from '../../kernel/snapshot.ts';
+import { buildGesturePlan, type MultiTouchGesturePlan } from '../../contracts/gesture-plan.ts';
+
+export const PORTRAIT: Rect = { x: 0, y: 0, width: 390, height: 844 };
+export const LANDSCAPE: Rect = { x: 0, y: 0, width: 844, height: 390 };
+
+export function requireTwoPointerPlan(
+  plan: ReturnType<typeof buildGesturePlan>,
+): MultiTouchGesturePlan {
+  assert.equal(plan.topology, 'two');
+  return plan as MultiTouchGesturePlan;
+}
+
+export function finalSpan(plan: MultiTouchGesturePlan): number {
+  return distance(
+    requiredPoint(plan.pointers[0].samples.at(-1)?.point),
+    requiredPoint(plan.pointers[1].samples.at(-1)?.point),
+  );
+}
+
+export function initialSpan(plan: MultiTouchGesturePlan): number {
+  return distance(
+    requiredPoint(plan.pointers[0].samples[0]?.point),
+    requiredPoint(plan.pointers[1].samples[0]?.point),
+  );
+}
+
+export function centroid(plan: MultiTouchGesturePlan, index: number): Point {
+  const first = requiredPoint(
+    index === -1 ? plan.pointers[0].samples.at(-1)?.point : plan.pointers[0].samples[index]?.point,
+  );
+  const second = requiredPoint(
+    index === -1 ? plan.pointers[1].samples.at(-1)?.point : plan.pointers[1].samples[index]?.point,
+  );
+  return { x: (first.x + second.x) / 2, y: (first.y + second.y) / 2 };
+}
+
+export function rotationDelta(plan: MultiTouchGesturePlan): number {
+  const start = vectorAngle(
+    requiredPoint(plan.pointers[0].samples[0]?.point),
+    requiredPoint(plan.pointers[1].samples[0]?.point),
+  );
+  const end = vectorAngle(
+    requiredPoint(plan.pointers[0].samples.at(-1)?.point),
+    requiredPoint(plan.pointers[1].samples.at(-1)?.point),
+  );
+  return normalizeDegrees(end - start);
+}
+
+export function assertAllSamplesInViewport(plan: MultiTouchGesturePlan): void {
+  for (const pointer of plan.pointers) {
+    for (const { point } of pointer.samples) {
+      assert.ok(point.x >= plan.viewport.x && point.x <= plan.viewport.x + plan.viewport.width);
+      assert.ok(point.y >= plan.viewport.y && point.y <= plan.viewport.y + plan.viewport.height);
+    }
+  }
+}
+
+export function requiredPoint(point: Point | undefined): Point {
+  assert.ok(point);
+  return point;
+}
+
+export function distance(left: Point, right: Point): number {
+  return Math.hypot(right.x - left.x, right.y - left.y);
+}
+
+export function normalizedAngle(first: Point, second: Point): number {
+  return Math.abs(normalizeDegrees(vectorAngle(first, second)));
+}
+
+export function isErrorWithReason(error: unknown, code: string, reason: string): boolean {
+  if (!error || typeof error !== 'object') return false;
+  const candidate = error as { code?: unknown; details?: { reason?: unknown } };
+  return candidate.code === code && candidate.details?.reason === reason;
+}
+
+function vectorAngle(first: Point, second: Point): number {
+  return (Math.atan2(first.y - second.y, first.x - second.x) * 180) / Math.PI;
+}
+
+function normalizeDegrees(degrees: number): number {
+  return ((degrees + 180) % 360) - 180;
+}
diff --git a/src/core/__tests__/gesture-plan-viewport.test.ts b/src/core/__tests__/gesture-plan-viewport.test.ts
new file mode 100644
index 000000000..dab3b6236
--- /dev/null
+++ b/src/core/__tests__/gesture-plan-viewport.test.ts
@@ -0,0 +1,159 @@
+import assert from 'node:assert/strict';
+import { describe, test } from 'vitest';
+import { buildGesturePlan, GESTURE_SAMPLE_INTERVAL_MS } from '../../contracts/gesture-plan.ts';
+import {
+  assertAllSamplesInViewport,
+  isErrorWithReason,
+  LANDSCAPE,
+  PORTRAIT,
+  requireTwoPointerPlan,
+} from './gesture-plan-test-utils.ts';
+
+describe('viewport-aware multi-touch geometry', () => {
+  test.each([
+    ['portrait center', PORTRAIT, { x: 195, y: 422 }],
+    ['landscape center', LANDSCAPE, { x: 422, y: 195 }],
+  ])('%s keeps every positive/negative rotation sample in bounds', (_name, viewport, origin) => {
+    for (const degrees of [-60, 60]) {
+      const plan = requireTwoPointerPlan(
+        buildGesturePlan(
+          {
+            intent: 'transform',
+            origin,
+            delta: { x: 0, y: 0 },
+            scale: 1,
+            degrees,
+            durationMs: 300,
+          },
+          viewport,
+        ),
+      );
+      assertAllSamplesInViewport(plan);
+    }
+  });
+
+  test.each([
+    ['top-left', PORTRAIT, { x: 30, y: 30 }],
+    ['top-right', PORTRAIT, { x: 360, y: 30 }],
+    ['bottom-left', PORTRAIT, { x: 30, y: 814 }],
+    ['bottom-right', PORTRAIT, { x: 360, y: 814 }],
+    ['top edge', PORTRAIT, { x: 195, y: 30 }],
+    ['bottom edge', PORTRAIT, { x: 195, y: 814 }],
+    ['left edge', PORTRAIT, { x: 30, y: 422 }],
+    ['right edge', PORTRAIT, { x: 360, y: 422 }],
+  ])('%s fails instead of shrinking the requested pointer geometry', (_name, viewport, origin) => {
+    assert.throws(
+      () =>
+        buildGesturePlan(
+          {
+            intent: 'transform',
+            origin,
+            delta: { x: 0, y: 0 },
+            scale: 1,
+            degrees: 60,
+            durationMs: 300,
+          },
+          viewport,
+        ),
+      (error: unknown) =>
+        isErrorWithReason(error, 'INVALID_ARGS', 'GESTURE_TRAJECTORY_OUT_OF_BOUNDS'),
+    );
+  });
+
+  test('single-pointer trajectories also fail outside the active viewport', () => {
+    for (const [origin, delta] of [
+      [
+        { x: 0, y: 100 },
+        { x: 20, y: 0 },
+      ],
+      [
+        { x: 200, y: 100 },
+        { x: 300, y: 0 },
+      ],
+    ] as const) {
+      assert.throws(
+        () => buildGesturePlan({ intent: 'pan', origin, delta }, PORTRAIT),
+        (error: unknown) =>
+          isErrorWithReason(error, 'INVALID_ARGS', 'GESTURE_TRAJECTORY_OUT_OF_BOUNDS'),
+      );
+    }
+  });
+
+  test('positive and negative translation choose geometry that keeps the full path in bounds', () => {
+    for (const delta of [
+      { x: 80, y: 40 },
+      { x: -80, y: -40 },
+    ]) {
+      const plan = requireTwoPointerPlan(
+        buildGesturePlan(
+          {
+            intent: 'transform',
+            origin: { x: 195, y: 422 },
+            delta,
+            scale: 1.4,
+            degrees: -30,
+            durationMs: 640,
+          },
+          PORTRAIT,
+        ),
+      );
+      assertAllSamplesInViewport(plan);
+    }
+  });
+
+  test('very small and impossible trajectories fail early with structured recovery details', () => {
+    for (const [viewport, origin, delta] of [
+      [
+        { x: 0, y: 0, width: 40, height: 40 },
+        { x: 20, y: 20 },
+        { x: 0, y: 0 },
+      ],
+      [PORTRAIT, { x: 195, y: 422 }, { x: 300, y: 0 }],
+    ] as const) {
+      assert.throws(
+        () =>
+          buildGesturePlan(
+            {
+              intent: 'transform',
+              origin,
+              delta,
+              scale: 1,
+              degrees: 0,
+            },
+            viewport,
+          ),
+        (error: unknown) =>
+          isErrorWithReason(error, 'INVALID_ARGS', 'GESTURE_TRAJECTORY_OUT_OF_BOUNDS'),
+      );
+    }
+  });
+
+  test('sample cadence is deterministic for short and long durations', () => {
+    const short = buildTransformPlan(16);
+    const long = buildTransformPlan(10_000);
+
+    assert.deepEqual(
+      short.pointers[0].samples.map((sample) => sample.offsetMs),
+      [0, 5, 11, 16],
+    );
+    assert.equal(long.pointers[0].samples.length, 626);
+    assert.equal(long.pointers[0].samples.at(-1)?.offsetMs, 10_000);
+    assert.equal(long.pointers[0].samples[1]?.offsetMs, GESTURE_SAMPLE_INTERVAL_MS);
+  });
+});
+
+function buildTransformPlan(durationMs: number) {
+  return requireTwoPointerPlan(
+    buildGesturePlan(
+      {
+        intent: 'transform',
+        origin: { x: 195, y: 422 },
+        delta: { x: 10, y: 0 },
+        scale: 1.1,
+        degrees: 5,
+        durationMs,
+      },
+      PORTRAIT,
+    ),
+  );
+}
diff --git a/src/core/__tests__/gesture-plan.test.ts b/src/core/__tests__/gesture-plan.test.ts
new file mode 100644
index 000000000..25f44930d
--- /dev/null
+++ b/src/core/__tests__/gesture-plan.test.ts
@@ -0,0 +1,221 @@
+import assert from 'node:assert/strict';
+import { describe, test } from 'vitest';
+import { buildGesturePlan, GESTURE_INITIAL_ANGLE_DEGREES } from '../../contracts/gesture-plan.ts';
+import {
+  centroid,
+  distance,
+  finalSpan,
+  initialSpan,
+  LANDSCAPE,
+  normalizedAngle,
+  PORTRAIT,
+  requiredPoint,
+  requireTwoPointerPlan,
+  rotationDelta,
+} from './gesture-plan-test-utils.ts';
+
+describe('single-pointer plans', () => {
+  test('pan defaults to one pointer and preserves endpoints and duration', () => {
+    const plan = buildGesturePlan(
+      { intent: 'pan', origin: { x: 100, y: 200 }, delta: { x: -40, y: 25 } },
+      PORTRAIT,
+    );
+    assert.equal(plan.topology, 'single');
+    assert.equal(plan.intent, 'pan');
+    assert.equal(plan.durationMs, 500);
+    assert.deepEqual(plan.pointers[0].samples[0]?.point, { x: 100, y: 200 });
+    assert.deepEqual(plan.pointers[0].samples.at(-1)?.point, { x: 60, y: 225 });
+  });
+
+  test('fling has one fixed internal schedule and no public duration', () => {
+    const directional = buildGesturePlan(
+      { intent: 'fling', direction: 'up', origin: { x: 50, y: 100 }, distance: 80 },
+      PORTRAIT,
+    );
+    const endpoints = buildGesturePlan(
+      { intent: 'fling', from: { x: 50, y: 100 }, to: { x: 230, y: 100 } },
+      PORTRAIT,
+    );
+    assert.equal(directional.durationMs, 100);
+    assert.equal(endpoints.durationMs, 100);
+    assert.deepEqual(directional.pointers[0].samples.at(-1)?.point, { x: 50, y: 20 });
+    assert.deepEqual(endpoints.pointers[0].samples.at(-1)?.point, { x: 230, y: 100 });
+  });
+
+  test('planner resolves swipe presets inside the active viewport', () => {
+    const viewport = { x: 20, y: 30, width: 400, height: 800 };
+    const fling = buildGesturePlan({ intent: 'fling', preset: 'left' }, viewport);
+    const pan = buildGesturePlan({ intent: 'pan', preset: 'right', durationMs: 400 }, viewport);
+
+    assert.deepEqual(fling.pointers[0].samples[0]?.point, { x: 360, y: 430 });
+    assert.deepEqual(fling.pointers[0].samples.at(-1)?.point, { x: 80, y: 430 });
+    assert.equal(pan.durationMs, 400);
+    assert.deepEqual(pan.pointers[0].samples[0]?.point, { x: 80, y: 430 });
+    assert.deepEqual(pan.pointers[0].samples.at(-1)?.point, { x: 360, y: 430 });
+  });
+});
+
+describe('two-pointer plans', () => {
+  test('rejects finite rotations that overflow generated coordinates', () => {
+    assert.throws(
+      () => buildGesturePlan({ intent: 'rotate', degrees: Number.MAX_VALUE }, PORTRAIT),
+      (error: unknown) =>
+        error instanceof Error &&
+        'code' in error &&
+        error.code === 'INVALID_ARGS' &&
+        error.message === 'Gesture motion produces non-finite pointer coordinates' &&
+        'details' in error &&
+        (error.details as { reason?: string }).reason === 'GESTURE_TRAJECTORY_NON_FINITE',
+    );
+  });
+
+  test('two-finger pan moves in parallel with constant span and angle', () => {
+    const plan = requireTwoPointerPlan(
+      buildGesturePlan(
+        {
+          intent: 'pan',
+          pointerCount: 2,
+          origin: { x: 195, y: 422 },
+          delta: { x: 60, y: -30 },
+          durationMs: 500,
+        },
+        PORTRAIT,
+      ),
+    );
+    const span = initialSpan(plan);
+    assert.equal(plan.intent, 'pan');
+    for (let index = 0; index < plan.pointers[0].samples.length; index += 1) {
+      const first = requiredPoint(plan.pointers[0].samples[index]?.point);
+      const second = requiredPoint(plan.pointers[1].samples[index]?.point);
+      assert.ok(Math.abs(distance(first, second) - span) < 1e-8);
+      assert.ok(Math.abs(normalizedAngle(first, second) - 90) < 1e-8);
+    }
+    assert.deepEqual(centroid(plan, -1), { x: 255, y: 392 });
+  });
+
+  test('pinch constrains translation and rotation', () => {
+    for (const scale of [0.5, 2]) {
+      const plan = requireTwoPointerPlan(buildGesturePlan({ intent: 'pinch', scale }, PORTRAIT));
+      assert.deepEqual(centroid(plan, 0), centroid(plan, -1));
+      assert.ok(Math.abs(finalSpan(plan) / initialSpan(plan) - scale) < 1e-8);
+      assert.ok(Math.abs(rotationDelta(plan)) < 1e-8);
+    }
+  });
+
+  test('rotate constrains translation and scale', () => {
+    for (const degrees of [-45, 45]) {
+      const plan = requireTwoPointerPlan(
+        buildGesturePlan({ intent: 'rotate', degrees }, LANDSCAPE),
+      );
+      assert.deepEqual(centroid(plan, 0), centroid(plan, -1));
+      assert.ok(Math.abs(finalSpan(plan) - initialSpan(plan)) < 1e-8);
+      assert.ok(Math.abs(rotationDelta(plan) - degrees) < 1e-8);
+    }
+  });
+
+  test('transform progresses every component atomically', () => {
+    const plan = requireTwoPointerPlan(
+      buildGesturePlan(
+        {
+          intent: 'transform',
+          origin: { x: 200, y: 400 },
+          delta: { x: -80, y: 40 },
+          scale: 1.5,
+          degrees: 36,
+          durationMs: 640,
+        },
+        PORTRAIT,
+      ),
+    );
+    const midpointIndex = plan.pointers[0].samples.findIndex(({ offsetMs }) => offsetMs === 320);
+    const midpoint = centroid(plan, midpointIndex);
+    const midpointSpan = distance(
+      requiredPoint(plan.pointers[0].samples[midpointIndex]?.point),
+      requiredPoint(plan.pointers[1].samples[midpointIndex]?.point),
+    );
+    assert.deepEqual(midpoint, { x: 160, y: 420 });
+    assert.ok(Math.abs(midpointSpan / initialSpan(plan) - 1.25) < 1e-8);
+    assert.ok(Math.abs(rotationDeltaThrough(plan, midpointIndex) - 18) < 1e-8);
+    assert.deepEqual(centroid(plan, -1), { x: 120, y: 440 });
+    assert.ok(Math.abs(finalSpan(plan) / initialSpan(plan) - 1.5) < 1e-8);
+    assert.ok(Math.abs(rotationDelta(plan) - 36) < 1e-8);
+  });
+
+  test('initial geometry is deterministic and viewport-relative', () => {
+    for (const viewport of [PORTRAIT, LANDSCAPE]) {
+      const plan = requireTwoPointerPlan(buildGesturePlan({ intent: 'pinch', scale: 1 }, viewport));
+      assert.equal(initialSpan(plan), Math.min(viewport.width, viewport.height) * 0.4);
+      assert.ok(
+        Math.abs(
+          normalizedAngle(
+            requiredPoint(plan.pointers[0].samples[0]?.point),
+            requiredPoint(plan.pointers[1].samples[0]?.point),
+          ) - Math.abs(GESTURE_INITIAL_ANGLE_DEGREES),
+        ) < 1e-8,
+      );
+    }
+
+    const androidPinch = requireTwoPointerPlan(
+      buildGesturePlan({ intent: 'pinch', scale: 1 }, PORTRAIT, 'android'),
+    );
+    assert.ok(
+      Math.abs(
+        normalizedAngle(
+          requiredPoint(androidPinch.pointers[0].samples[0]?.point),
+          requiredPoint(androidPinch.pointers[1].samples[0]?.point),
+        ),
+      ) < 1e-8,
+    );
+    assert.equal(androidPinch.pointers[0].samples[1]?.offsetMs, 16);
+    assert.equal(
+      requireTwoPointerPlan(buildGesturePlan({ intent: 'pinch', scale: 1 }, PORTRAIT, 'ios'))
+        .pointers[0].samples[1]?.offsetMs,
+      17,
+    );
+  });
+});
+
+test('invalid and non-finite values fail before execution', () => {
+  const cases = [
+    () =>
+      buildGesturePlan(
+        { intent: 'pan', origin: { x: NaN, y: 1 }, delta: { x: 1, y: 1 } },
+        PORTRAIT,
+      ),
+    () =>
+      buildGesturePlan(
+        { intent: 'pan', origin: { x: 100, y: 100 }, delta: { x: 1, y: 1 }, pointerCount: 3 as 1 },
+        PORTRAIT,
+      ),
+    () => buildGesturePlan({ intent: 'pinch', scale: Infinity }, PORTRAIT),
+    () => buildGesturePlan({ intent: 'rotate', degrees: NaN }, PORTRAIT),
+    () =>
+      buildGesturePlan(
+        {
+          intent: 'transform',
+          origin: { x: 100, y: 100 },
+          delta: { x: 1, y: 1 },
+          scale: 0,
+          degrees: 0,
+        },
+        PORTRAIT,
+      ),
+  ];
+  for (const run of cases) assert.throws(run, /finite|greater than 0|must be 1 or 2/);
+});
+
+function rotationDeltaThrough(plan: Parameters<typeof rotationDelta>[0], index: number): number {
+  const start = Math.atan2(
+    requiredPoint(plan.pointers[0].samples[0]?.point).y -
+      requiredPoint(plan.pointers[1].samples[0]?.point).y,
+    requiredPoint(plan.pointers[0].samples[0]?.point).x -
+      requiredPoint(plan.pointers[1].samples[0]?.point).x,
+  );
+  const end = Math.atan2(
+    requiredPoint(plan.pointers[0].samples[index]?.point).y -
+      requiredPoint(plan.pointers[1].samples[index]?.point).y,
+    requiredPoint(plan.pointers[0].samples[index]?.point).x -
+      requiredPoint(plan.pointers[1].samples[index]?.point).x,
+  );
+  return ((end - start) * 180) / Math.PI;
+}
diff --git a/src/core/batch.ts b/src/core/batch.ts
index dd8125ab3..247f0f19a 100644
--- a/src/core/batch.ts
+++ b/src/core/batch.ts
@@ -24,6 +24,7 @@ const batchAllowedStepKeys = new Set<string>(BATCH_DAEMON_STEP_KEYS);
 export type DaemonBatchStep = {
   command: string;
   positionals?: string[];
+  input?: Record<string, unknown>;
   flags?: Record<string, unknown>;
   runtime?: DaemonRequest['runtime'];
 };
@@ -43,6 +44,7 @@ export type BatchInvoke = (req: BatchRequest) => Promise<DaemonResponse>;
 export type NormalizedBatchStep = {
   command: string;
   positionals: string[];
+  input?: Record<string, unknown>;
   flags: Record<string, unknown>;
   runtime?: DaemonRequest['runtime'];
 };
@@ -158,7 +160,7 @@ export function validateAndNormalizeBatchSteps(
       const fields = unknownKeys.map((key) => `"${key}"`).join(', ');
       throw new AppError(
         'INVALID_ARGS',
-        `Batch step ${index + 1} has unknown field(s): ${fields}. Allowed fields: command, positionals, flags, runtime.`,
+        `Batch step ${index + 1} has unknown field(s): ${fields}. Allowed fields: command, positionals, input, flags, runtime.`,
       );
     }
     const command = normalizeBatchCommandName(step.command);
@@ -179,9 +181,13 @@ export function validateAndNormalizeBatchSteps(
     if (step.flags !== undefined && !isRecord(step.flags)) {
       throw new AppError('INVALID_ARGS', `Batch step ${index + 1} flags must be an object.`);
     }
+    if (step.input !== undefined && !isRecord(step.input)) {
+      throw new AppError('INVALID_ARGS', `Batch step ${index + 1} input must be an object.`);
+    }
     normalized.push({
       command,
       positionals: positionals as string[],
+      input: step.input as Record<string, unknown> | undefined,
       flags: (step.flags ?? {}) as Record<string, unknown>,
       runtime: parseBatchStepRuntime(step.runtime, index + 1),
     });
@@ -269,6 +275,7 @@ async function runBatchStep(
     session: sessionName,
     command: step.command,
     positionals: step.positionals,
+    input: step.input,
     flags: stepFlags,
     runtime: step.runtime === undefined ? req.runtime : step.runtime,
     meta: batchStepMeta(req.meta, isFinalStep),
diff --git a/src/core/capabilities.ts b/src/core/capabilities.ts
index 9bbf85055..2bce044a7 100644
--- a/src/core/capabilities.ts
+++ b/src/core/capabilities.ts
@@ -3,6 +3,9 @@ import { commandDescriptors } from './command-descriptor/registry.ts';
 import { tryGetPlugin } from './platform-plugin/plugin.ts';
 import { registerBuiltinPlatformPlugins } from './interactors/register-builtins.ts';
 import type { DeviceInfo } from '../kernel/device.ts';
+import { AppError } from '../kernel/errors.ts';
+import type { GestureSemanticInput } from '../contracts/gesture-plan-types.ts';
+import { assertAppleMultiTouchSupported } from '../contracts/apple-multitouch-support.ts';
 
 // Populate the PlatformPlugin registry once at module load (idempotent; registers
 // only lazy closures, so no leaf code is imported and CLI cold-start is unaffected
@@ -136,3 +139,52 @@ export function supportedPlatformsForCommand(command: string): string[] {
   }
   return supported;
 }
+
+export function requireGestureSupported(input: GestureSemanticInput, device: DeviceInfo): void {
+  if (device.platform === 'web' || device.appleOs === 'watchos') {
+    throw unsupportedGesture(input, gesturePlatformMessage(input, device));
+  }
+  if (isMultiTouchGesture(input)) {
+    requireMultiTouchGestureSupported(input, device);
+    return;
+  }
+  if (device.appleOs === 'visionos') {
+    throw unsupportedGesture(input, gesturePlatformMessage(input, device));
+  }
+  // Linux can preserve public coordinate/preset swipe through its drag primitive, but cannot
+  // honor the velocity semantics authored by `gesture fling`.
+  if (input.intent === 'fling' && 'direction' in input && device.platform === 'linux') {
+    throw unsupportedGesture(input, 'gesture fling is not supported on Linux');
+  }
+}
+
+function isMultiTouchGesture(input: GestureSemanticInput): boolean {
+  if (input.intent === 'pan') return ('pointerCount' in input ? input.pointerCount : 1) === 2;
+  return input.intent === 'pinch' || input.intent === 'rotate' || input.intent === 'transform';
+}
+
+function requireMultiTouchGestureSupported(input: GestureSemanticInput, device: DeviceInfo): void {
+  if (device.platform === 'android') {
+    if (device.target !== 'tv') return;
+    throw unsupportedGesture(
+      input,
+      `gesture ${input.intent} is not supported on Android TV`,
+      'Android TV has no touch input — this gesture is supported on Android phones, tablets, and the iOS simulator only.',
+    );
+  }
+  if (device.platform !== 'apple') {
+    throw unsupportedGesture(input, gesturePlatformMessage(input, device));
+  }
+  assertAppleMultiTouchSupported(device, input.intent);
+}
+
+function gesturePlatformMessage(input: GestureSemanticInput, device: DeviceInfo): string {
+  return `gesture ${input.intent} is not supported on ${device.appleOs ?? device.platform}`;
+}
+
+function unsupportedGesture(input: GestureSemanticInput, message: string, hint?: string): AppError {
+  return new AppError('UNSUPPORTED_OPERATION', message, {
+    gesture: input.intent,
+    ...(hint ? { hint } : {}),
+  });
+}
diff --git a/src/core/command-descriptor/__tests__/parity.test.ts b/src/core/command-descriptor/__tests__/parity.test.ts
index 14220cb50..636d4c869 100644
--- a/src/core/command-descriptor/__tests__/parity.test.ts
+++ b/src/core/command-descriptor/__tests__/parity.test.ts
@@ -47,7 +47,6 @@ const NO_CAPABILITY_PUBLIC_COMMANDS = new Set<string>([
   PUBLIC_COMMANDS.devices,
   PUBLIC_COMMANDS.doctor,
   PUBLIC_COMMANDS.events,
-  PUBLIC_COMMANDS.gesture,
   PUBLIC_COMMANDS.prepare,
   PUBLIC_COMMANDS.replay,
   PUBLIC_COMMANDS.test,
@@ -169,11 +168,10 @@ test('platform dispatch command list is built from descriptor dispatch facets',
 
   assert.deepEqual(listRegisteredDispatchCommandNames(), dispatchCommands);
   assert.ok(dispatchCommands.includes('read'), 'read stays dispatch-only');
-  assert.ok(dispatchCommands.includes('swipe-preset'), 'swipe-preset stays dispatch-only');
   assert.equal(
     (dispatchCommands as readonly string[]).includes(PUBLIC_COMMANDS.gesture),
     false,
-    'gesture remains a daemon command that expands before platform dispatch',
+    'gesture executes through the typed runtime/backend seam',
   );
 });
 
@@ -224,12 +222,7 @@ const NON_BATCHABLE_COMMANDS = [
   PUBLIC_COMMANDS.batch,
   PUBLIC_COMMANDS.replay,
   PUBLIC_COMMANDS.prepare,
-  'pinch',
   'viewport',
-  'pan',
-  'fling',
-  'rotate-gesture',
-  'transform-gesture',
 ];
 
 test('structured-batch allowlist is built from descriptors', () => {
@@ -291,6 +284,7 @@ test('capability-checked command list is built from descriptor capabilities', ()
 
   assert.deepEqual(listCapabilityCheckedCommandNames(), expected);
   assert.ok(expectedNames.has(PUBLIC_COMMANDS.snapshot), 'snapshot remains capability-checked');
+  assert.ok(expectedNames.has(PUBLIC_COMMANDS.gesture), 'gesture remains capability-checked');
   assert.equal(
     expectedNames.has(PUBLIC_COMMANDS.capabilities),
     false,
diff --git a/src/core/command-descriptor/registry.ts b/src/core/command-descriptor/registry.ts
index 4c74752d5..ab33a90c9 100644
--- a/src/core/command-descriptor/registry.ts
+++ b/src/core/command-descriptor/registry.ts
@@ -771,7 +771,8 @@ export const RAW_COMMAND_DESCRIPTORS = [
     name: 'gesture',
     ...(ownerFilesEnabled ? { ownerFiles: ['src/commands/interaction/index.ts'] as const } : {}),
     catalog: { group: 'public' },
-    daemon: { route: 'generic', replayScopedAction: true, androidBlockingDialogGuard: true },
+    daemon: { route: 'interaction', replayScopedAction: true, androidBlockingDialogGuard: true },
+    capability: ALL_DEVICE_COMMAND_CAPABILITY,
     timeoutPolicy: DEFAULT_TIMEOUT_POLICY,
     batchable: true,
   },
@@ -831,34 +832,11 @@ export const RAW_COMMAND_DESCRIPTORS = [
     name: 'swipe',
     ...(ownerFilesEnabled ? { ownerFiles: ['src/commands/interaction/index.ts'] as const } : {}),
     catalog: { group: 'public' },
-    daemon: { route: 'generic', replayScopedAction: true, androidBlockingDialogGuard: true },
-    dispatch: {},
+    daemon: { route: 'interaction', replayScopedAction: true, androidBlockingDialogGuard: true },
     capability: { apple: APPLE_SIM_AND_DEVICE, android: ANDROID_ALL, linux: LINUX_DEVICE },
     timeoutPolicy: DEFAULT_TIMEOUT_POLICY,
     batchable: true,
   },
-  {
-    name: 'swipe-preset',
-    ...(ownerFilesEnabled ? { ownerFiles: ['src/core/dispatch.ts'] as const } : {}),
-    catalog: { group: 'dispatch-alias' },
-    dispatch: {},
-    timeoutPolicy: DEFAULT_TIMEOUT_POLICY,
-    batchable: false,
-  },
-  {
-    name: 'pinch',
-    ...(ownerFilesEnabled ? { ownerFiles: ['src/core/dispatch.ts'] as const } : {}),
-    catalog: { group: 'dispatch-alias' },
-    daemon: { route: 'generic', replayScopedAction: true, androidBlockingDialogGuard: true },
-    dispatch: {},
-    capability: {
-      apple: APPLE_SIM_AND_DEVICE,
-      android: ANDROID_ALL,
-      linux: LINUX_NONE,
-    },
-    timeoutPolicy: DEFAULT_TIMEOUT_POLICY,
-    batchable: false,
-  },
   {
     name: 'focus',
     ...(ownerFilesEnabled ? { ownerFiles: ['src/commands/interaction/index.ts'] as const } : {}),
@@ -889,55 +867,6 @@ export const RAW_COMMAND_DESCRIPTORS = [
     timeoutPolicy: DEFAULT_TIMEOUT_POLICY,
     batchable: false,
   },
-  {
-    name: 'pan',
-    ...(ownerFilesEnabled ? { ownerFiles: ['src/core/dispatch.ts'] as const } : {}),
-    catalog: { group: 'dispatch-alias' },
-    daemon: { route: 'generic', androidBlockingDialogGuard: true },
-    dispatch: {},
-    capability: { apple: APPLE_SIM_AND_DEVICE, android: ANDROID_ALL, linux: LINUX_DEVICE },
-    timeoutPolicy: DEFAULT_TIMEOUT_POLICY,
-    batchable: false,
-  },
-  {
-    name: 'fling',
-    ...(ownerFilesEnabled ? { ownerFiles: ['src/core/dispatch.ts'] as const } : {}),
-    catalog: { group: 'dispatch-alias' },
-    daemon: { route: 'generic', androidBlockingDialogGuard: true },
-    dispatch: {},
-    capability: { apple: APPLE_SIM_AND_DEVICE, android: ANDROID_ALL, linux: LINUX_NONE },
-    timeoutPolicy: DEFAULT_TIMEOUT_POLICY,
-    batchable: false,
-  },
-  {
-    name: 'rotate-gesture',
-    ...(ownerFilesEnabled ? { ownerFiles: ['src/core/dispatch.ts'] as const } : {}),
-    catalog: { group: 'dispatch-alias' },
-    daemon: { route: 'generic', androidBlockingDialogGuard: true },
-    dispatch: {},
-    capability: {
-      apple: APPLE_SIM_AND_DEVICE,
-      android: ANDROID_ALL,
-      linux: LINUX_NONE,
-    },
-    timeoutPolicy: DEFAULT_TIMEOUT_POLICY,
-    batchable: false,
-  },
-  {
-    name: 'transform-gesture',
-    ...(ownerFilesEnabled ? { ownerFiles: ['src/core/dispatch.ts'] as const } : {}),
-    catalog: { group: 'dispatch-alias' },
-    daemon: { route: 'generic', androidBlockingDialogGuard: true },
-    dispatch: {},
-    capability: {
-      apple: APPLE_SIM_AND_DEVICE,
-      android: ANDROID_ALL,
-      linux: LINUX_NONE,
-    },
-    timeoutPolicy: DEFAULT_TIMEOUT_POLICY,
-    batchable: false,
-  },
-
   // -- capability/batch-only commands (no daemon route) --
   {
     name: 'app-switcher',
diff --git a/src/core/dispatch-interactions.ts b/src/core/dispatch-interactions.ts
index 9f6c38189..3a70e594c 100644
--- a/src/core/dispatch-interactions.ts
+++ b/src/core/dispatch-interactions.ts
@@ -8,25 +8,13 @@ import {
 } from '../kernel/device.ts';
 import { successText, withSuccessText } from '../utils/success-text.ts';
 import { findMistargetedTypeRefToken } from '../utils/type-target-warning.ts';
-import {
-  buildSwipePresetGesturePlan,
-  inferGestureReferenceFrame,
-  parseScrollDirection,
-  parseSwipePreset,
-  SCROLL_DIRECTIONS,
-  SWIPE_PATTERNS,
-  type ScrollDirection,
-  type SwipePattern,
-  type SwipePreset,
-  type TransformGestureParams,
-} from '../contracts/scroll-gesture.ts';
+import { parseScrollDirection, type ScrollDirection } from '../contracts/scroll-gesture.ts';
 import {
   assertExclusiveScrollDistanceInputs,
   honoredScrollDurationMs,
   normalizeScrollDurationMs,
   type ScrollCommandOptions,
 } from '../contracts/scroll-command.ts';
-import { isStringMember, parseStringMember } from '../utils/string-enum.ts';
 import {
   getClickButtonValidationError,
   resolveClickButton,
@@ -41,7 +29,6 @@ import {
 } from '../utils/scroll-edge-state.ts';
 import {
   requireIntInRange,
-  shouldUseIosDragSeries,
   shouldUseIosPressSequence,
   chunkRunnerSequenceStepsByBudget,
   computeDeterministicJitter,
@@ -449,39 +436,6 @@ function buildPressSequenceSteps(
   });
 }
 
-// Unrolls a swipe series into `sequence` drag steps, replacing the retired `dragSeries` runner
-// command. Ping-pong becomes per-step endpoint swapping (odd indices reversed), matching the
-// runner-side performDragSeries the daemon no longer invokes. iOS touch targets request the same
-// synthesized, duration-aware drag path as one-shot swipe; macOS/tvOS keep coordinate drag.
-function buildSwipeSequenceSteps(params: {
-  device: DeviceInfo;
-  x1: number;
-  y1: number;
-  x2: number;
-  y2: number;
-  count: number;
-  pauseMs: number;
-  pattern: string;
-  effectiveDurationMs: number;
-}): RunnerSequenceStep[] {
-  const { device, x1, y1, x2, y2, count, pauseMs, pattern, effectiveDurationMs } = params;
-  const synthesized = isIosFamily(device) && !isTvOsDevice(device);
-  return Array.from({ length: count }, (_, index) => {
-    const reverse = pattern === 'ping-pong' && index % 2 === 1;
-    const isLast = index === count - 1;
-    return {
-      kind: 'drag' as const,
-      x: reverse ? x2 : x1,
-      y: reverse ? y2 : y1,
-      x2: reverse ? x1 : x2,
-      y2: reverse ? y1 : y2,
-      durationMs: effectiveDurationMs,
-      ...(synthesized ? { synthesized: true, dragSemantics: 'swipe' as const } : {}),
-      ...(!isLast && pauseMs > 0 ? { pauseMs } : {}),
-    };
-  });
-}
-
 // Sequence step errors carry a chunk-local failedStepIndex and completedSteps; rebase both onto the
 // global series so the error names the true step and completed count across chunk boundaries.
 function remapSequenceErrorStepIndex(error: unknown, stepOffset: number): unknown {
@@ -558,199 +512,6 @@ function runnerOptionsFromContext(context: DispatchContext | undefined): RunnerC
   };
 }
 
-export async function handleSwipeCommand(
-  device: DeviceInfo,
-  interactor: Interactor,
-  positionals: string[],
-  context: DispatchContext | undefined,
-): Promise<Record<string, unknown>> {
-  const x1 = Number(positionals[0]);
-  const y1 = Number(positionals[1]);
-  const x2 = Number(positionals[2]);
-  const y2 = Number(positionals[3]);
-  if ([x1, y1, x2, y2].some(Number.isNaN)) {
-    throw new AppError('INVALID_ARGS', 'swipe requires x1 y1 x2 y2 [durationMs]');
-  }
-
-  const requestedDurationMs = positionals[4] ? Number(positionals[4]) : 250;
-  return await runSwipeCoordinates({
-    device,
-    interactor,
-    context,
-    x1,
-    y1,
-    x2,
-    y2,
-    requestedDurationMs,
-  });
-}
-
-export async function handleSwipePresetCommand(
-  device: DeviceInfo,
-  interactor: Interactor,
-  positionals: string[],
-  context: DispatchContext | undefined,
-): Promise<Record<string, unknown>> {
-  const preset = parseSwipePreset(positionals[0]);
-  const requestedDurationMs = positionals[1] ? Number(positionals[1]) : 300;
-  const snapshot = await interactor.snapshot({ appBundleId: context?.appBundleId });
-  const frame = inferGestureReferenceFrame(snapshot.nodes ?? []);
-  if (!frame) {
-    throw new AppError('COMMAND_FAILED', 'Cannot infer viewport for gesture swipe preset');
-  }
-  const plan = buildSwipePresetGesturePlan(preset, frame);
-  return await runSwipeCoordinates({
-    device,
-    interactor,
-    context,
-    x1: plan.x1,
-    y1: plan.y1,
-    x2: plan.x2,
-    y2: plan.y2,
-    requestedDurationMs,
-    preset,
-  });
-}
-
-// fallow-ignore-next-line complexity
-async function runSwipeCoordinates(params: {
-  device: DeviceInfo;
-  interactor: Interactor;
-  context: DispatchContext | undefined;
-  x1: number;
-  y1: number;
-  x2: number;
-  y2: number;
-  requestedDurationMs: number;
-  preset?: SwipePreset;
-}): Promise<Record<string, unknown>> {
-  const { device, interactor, context, x1, y1, x2, y2, requestedDurationMs, preset } = params;
-  const durationMs = requireIntInRange(requestedDurationMs, 'durationMs', 16, 10_000);
-  const effectiveDurationMs = durationMs;
-  const count = requireIntInRange(context?.count ?? 1, 'count', 1, 200);
-  const pauseMs = requireIntInRange(context?.pauseMs ?? 0, 'pause-ms', 0, 10_000);
-  const pattern = context?.pattern ?? 'one-way';
-  if (!isStringMember(SWIPE_PATTERNS, pattern)) {
-    throw new AppError('INVALID_ARGS', `Invalid pattern: ${pattern}`);
-  }
-
-  if (shouldUseIosDragSeries(device, count)) {
-    const aggregated = await runIosSequenceChunks(
-      device,
-      buildSwipeSequenceSteps({
-        device,
-        x1,
-        y1,
-        x2,
-        y2,
-        count,
-        pauseMs,
-        pattern,
-        effectiveDurationMs,
-      }),
-      context,
-    );
-    return {
-      x1,
-      y1,
-      x2,
-      y2,
-      ...(preset ? { preset } : {}),
-      durationMs,
-      effectiveDurationMs,
-      timingMode: 'runner-sequence',
-      count,
-      pauseMs,
-      pattern,
-      ...aggregated,
-      ...successText(formatSwipeMessage(count, pattern)),
-    };
-  }
-
-  await runRepeatedSeries(count, pauseMs, async (index) => {
-    const reverse = pattern === 'ping-pong' && index % 2 === 1;
-    if (reverse) await interactor.swipe(x2, y2, x1, y1, effectiveDurationMs);
-    else await interactor.swipe(x1, y1, x2, y2, effectiveDurationMs);
-  });
-
-  return withSuccessText(
-    {
-      x1,
-      y1,
-      x2,
-      y2,
-      ...(preset ? { preset } : {}),
-      durationMs,
-      effectiveDurationMs,
-      timingMode: 'direct',
-      count,
-      pauseMs,
-      pattern,
-    },
-    preset ? `Swiped ${preset}` : formatSwipeMessage(count, pattern),
-  );
-}
-
-export async function handlePanCommand(
-  interactor: Interactor,
-  positionals: string[],
-): Promise<Record<string, unknown>> {
-  const x = Number(positionals[0]);
-  const y = Number(positionals[1]);
-  const dx = Number(positionals[2]);
-  const dy = Number(positionals[3]);
-  if ([x, y, dx, dy].some((value) => !Number.isFinite(value))) {
-    throw new AppError('INVALID_ARGS', 'gesture pan requires x y dx dy [durationMs]');
-  }
-  const requestedDurationMs = positionals[4] ? Number(positionals[4]) : 500;
-  const durationMs = requireIntInRange(requestedDurationMs, 'durationMs', 16, 10_000);
-  const x2 = x + dx;
-  const y2 = y + dy;
-  const interactionResult = await interactor.pan(x, y, x2, y2, durationMs);
-  return {
-    x,
-    y,
-    dx,
-    dy,
-    x2,
-    y2,
-    durationMs,
-    ...(interactionResult ?? {}),
-    ...successText(`Panned (${x}, ${y}) by (${dx}, ${dy})`),
-  };
-}
-
-export async function handleFlingCommand(
-  interactor: Interactor,
-  positionals: string[],
-): Promise<Record<string, unknown>> {
-  const direction = parseGestureDirection(positionals[0], 'fling direction');
-  const x = Number(positionals[1]);
-  const y = Number(positionals[2]);
-  if (![x, y].every(Number.isFinite)) {
-    throw new AppError(
-      'INVALID_ARGS',
-      'gesture fling requires direction x y [distance] [durationMs]',
-    );
-  }
-  const distanceInput = positionals[3] ? Number(positionals[3]) : 180;
-  const distance = requireFinitePositiveNumber(distanceInput, 'distance');
-  const requestedDurationMs = positionals[4] ? Number(positionals[4]) : 50;
-  const durationMs = requireIntInRange(requestedDurationMs, 'durationMs', 16, 1_000);
-  const { x2, y2 } = pointOffsetByDirection(x, y, direction, distance);
-  await interactor.fling(x, y, x2, y2, durationMs);
-  return {
-    direction,
-    x,
-    y,
-    x2,
-    y2,
-    distance,
-    durationMs,
-    ...successText(`Flung ${direction}`),
-  };
-}
-
 export async function handleScrollCommand(
   interactor: Interactor,
   positionals: string[],
@@ -873,182 +634,6 @@ function parseScrollTarget(input: string): {
   return { direction: parseScrollDirection(input) };
 }
 
-export async function handlePinchCommand(
-  device: DeviceInfo,
-  interactor: Interactor,
-  positionals: string[],
-  context: DispatchContext | undefined,
-): Promise<Record<string, unknown>> {
-  // Cross-platform TV-target gate (also rejects Android TV, which shares target: 'tv');
-  // NOT narrowed to the tvOS Apple-OS leaf (isTvOsDevice) so Android-TV behavior is unchanged.
-  if (device.target === 'tv') {
-    throw new AppError('UNSUPPORTED_OPERATION', 'gesture pinch is not supported on tvOS');
-  }
-  if (isMacOs(device) && context?.surface && context.surface !== 'app') {
-    throw new AppError(
-      'UNSUPPORTED_OPERATION',
-      'gesture pinch is only supported in macOS app sessions. Re-open the target app without --surface desktop|menubar|frontmost-app first.',
-    );
-  }
-  const scale = Number(positionals[0]);
-  const x = positionals[1] ? Number(positionals[1]) : undefined;
-  const y = positionals[2] ? Number(positionals[2]) : undefined;
-  if (Number.isNaN(scale) || scale <= 0) {
-    throw new AppError('INVALID_ARGS', 'gesture pinch requires scale > 0');
-  }
-  const interactionResult = await interactor.pinch(scale, x, y);
-  return { scale, x, y, ...interactionResult, ...successText(`Pinched to scale ${scale}`) };
-}
-
-export async function handleRotateGestureCommand(
-  device: DeviceInfo,
-  interactor: Interactor,
-  positionals: string[],
-): Promise<Record<string, unknown>> {
-  // Cross-platform TV-target gate (also rejects Android TV) — see handlePinchCommand.
-  if (device.target === 'tv') {
-    throw new AppError('UNSUPPORTED_OPERATION', 'gesture rotate is not supported on tvOS');
-  }
-  if (isMacOs(device)) {
-    throw new AppError(
-      'UNSUPPORTED_OPERATION',
-      'gesture rotate is not supported on macOS; XCTest rotation gestures are available only for iOS app sessions.',
-    );
-  }
-
-  const { degrees, x, y, velocity } = parseRotateGestureParams(positionals);
-
-  const interactionResult = await interactor.rotateGesture(degrees, x, y, velocity);
-  return {
-    degrees,
-    ...(x !== undefined && y !== undefined ? { x, y } : {}),
-    velocity,
-    ...interactionResult,
-    ...successText(`Rotated gesture ${degrees} degrees`),
-  };
-}
-
-export async function handleTransformGestureCommand(
-  device: DeviceInfo,
-  interactor: Interactor,
-  positionals: string[],
-): Promise<Record<string, unknown>> {
-  // Cross-platform TV-target gate (also rejects Android TV) — see handlePinchCommand.
-  if (device.target === 'tv') {
-    throw new AppError('UNSUPPORTED_OPERATION', 'gesture transform is not supported on tvOS');
-  }
-  const supportedIosSimulator = isIosFamily(device) && device.kind === 'simulator';
-  if (device.platform !== 'android' && !supportedIosSimulator) {
-    throw new AppError(
-      'UNSUPPORTED_OPERATION',
-      'gesture transform is currently supported on Android and iOS simulators',
-    );
-  }
-
-  const params = parseTransformGestureParams(positionals);
-  const interactionResult = await interactor.transformGesture(params);
-  return {
-    ...params,
-    ...interactionResult,
-    ...successText(
-      `Requested transform gesture by (${params.dx}, ${params.dy}), scale ${params.scale}, rotate ${params.degrees} degrees`,
-    ),
-  };
-}
-
-type RotateGestureParams = {
-  degrees: number;
-  x?: number;
-  y?: number;
-  velocity: number;
-};
-
-function parseRotateGestureParams(positionals: string[]): RotateGestureParams {
-  const degrees = Number(positionals[0]);
-  if (!Number.isFinite(degrees)) {
-    throw new AppError('INVALID_ARGS', 'gesture rotate requires degrees [x] [y] [velocity]');
-  }
-
-  const center = parseOptionalGestureCenter(positionals[1], positionals[2]);
-  const velocity = Number(positionals[3] ?? (degrees >= 0 ? 1 : -1));
-  if (!Number.isFinite(velocity) || velocity === 0) {
-    throw new AppError('INVALID_ARGS', 'gesture rotate velocity must be a non-zero number');
-  }
-
-  return { degrees, ...center, velocity: Math.abs(velocity) * (degrees >= 0 ? 1 : -1) };
-}
-
-function parseTransformGestureParams(positionals: string[]): TransformGestureParams {
-  const x = Number(positionals[0]);
-  const y = Number(positionals[1]);
-  const dx = Number(positionals[2]);
-  const dy = Number(positionals[3]);
-  const scale = Number(positionals[4]);
-  const degrees = Number(positionals[5]);
-  if (![x, y, dx, dy, scale, degrees].every(Number.isFinite)) {
-    throw new AppError(
-      'INVALID_ARGS',
-      'gesture transform requires x y dx dy scale degrees [durationMs]',
-    );
-  }
-  if (scale <= 0) {
-    throw new AppError('INVALID_ARGS', 'gesture transform scale must be > 0');
-  }
-  const durationMs =
-    positionals[6] === undefined
-      ? undefined
-      : requireIntInRange(Number(positionals[6]), 'durationMs', 16, 10_000);
-  return { x, y, dx, dy, scale, degrees, durationMs };
-}
-
-function parseOptionalGestureCenter(
-  xInput: string | undefined,
-  yInput: string | undefined,
-): Pick<RotateGestureParams, 'x' | 'y'> {
-  if (xInput === undefined && yInput === undefined) return {};
-  if (xInput === undefined || yInput === undefined) {
-    throw new AppError('INVALID_ARGS', 'gesture rotate center requires both x and y');
-  }
-
-  const x = Number(xInput);
-  const y = Number(yInput);
-  if (!Number.isFinite(x) || !Number.isFinite(y)) {
-    throw new AppError('INVALID_ARGS', 'gesture rotate center requires finite x and y');
-  }
-  return { x, y };
-}
-
-function parseGestureDirection(input: string | undefined, field: string): ScrollDirection {
-  return parseStringMember(SCROLL_DIRECTIONS, input, {
-    message: `${field} must be up, down, left, or right`,
-  });
-}
-
-function requireFinitePositiveNumber(value: number, field: string): number {
-  if (!Number.isFinite(value) || value <= 0) {
-    throw new AppError('INVALID_ARGS', `${field} must be a positive number`);
-  }
-  return value;
-}
-
-function pointOffsetByDirection(
-  x: number,
-  y: number,
-  direction: ScrollDirection,
-  distance: number,
-): { x2: number; y2: number } {
-  switch (direction) {
-    case 'up':
-      return { x2: x, y2: y - distance };
-    case 'down':
-      return { x2: x, y2: y + distance };
-    case 'left':
-      return { x2: x - distance, y2: y };
-    case 'right':
-      return { x2: x + distance, y2: y };
-  }
-}
-
 export async function handleReadCommand(
   device: DeviceInfo,
   positionals: string[],
@@ -1113,11 +698,6 @@ function formatPressMessage(params: { x: number; y: number; button?: ClickButton
   return `Tapped (${params.x}, ${params.y})`;
 }
 
-function formatSwipeMessage(count: number, pattern: SwipePattern): string {
-  if (count <= 1) return 'Swiped';
-  return pattern === 'ping-pong' ? `Swiped ${count} times (ping-pong)` : `Swiped ${count} times`;
-}
-
 function formatTextLengthMessage(action: 'Typed' | 'Filled', text: string): string {
   return `${action} ${Array.from(text).length} chars`;
 }
diff --git a/src/core/dispatch-series.ts b/src/core/dispatch-series.ts
index ca8535f1e..827319dff 100644
--- a/src/core/dispatch-series.ts
+++ b/src/core/dispatch-series.ts
@@ -14,10 +14,6 @@ const DETERMINISTIC_JITTER_PATTERN: ReadonlyArray<readonly [number, number]> = [
   [-1, -1],
 ];
 
-export function shouldUseIosDragSeries(device: DeviceInfo, count: number): boolean {
-  return isApplePlatform(device.platform) && count > 1;
-}
-
 /**
  * Whether a press series should fuse into one or more `sequence` runner requests. Every Apple
  * multi-press variant fuses — plain, double-tap, hold, and jitter series — so the budget chunker
diff --git a/src/core/dispatch.ts b/src/core/dispatch.ts
index 01dca1763..74fe439b7 100644
--- a/src/core/dispatch.ts
+++ b/src/core/dispatch.ts
@@ -19,18 +19,11 @@ import { isKeyboardAction, type KeyboardAction } from '../utils/keyboard-actions
 import type { DispatchContext } from './dispatch-context.ts';
 import {
   handleFillCommand,
-  handleFlingCommand,
   handleFocusCommand,
   handleLongPressCommand,
-  handlePanCommand,
-  handlePinchCommand,
   handlePressCommand,
   handleReadCommand,
-  handleRotateGestureCommand,
   handleScrollCommand,
-  handleSwipeCommand,
-  handleSwipePresetCommand,
-  handleTransformGestureCommand,
   handleTypeCommand,
 } from './dispatch-interactions.ts';
 import { readNotificationPayload } from './dispatch-payload.ts';
@@ -38,6 +31,8 @@ import { parseDeviceRotation } from '../contracts/device-rotation.ts';
 import { parseTvRemoteButton } from '../contracts/tv-remote.ts';
 import { readViewportDimension } from './viewport-dimension.ts';
 import type { DescriptorDispatchCommandName } from './command-descriptor/registry.ts';
+import type { GesturePlan } from '../contracts/gesture-plan-types.ts';
+import type { Rect } from '../kernel/snapshot.ts';
 
 export { resolveTargetDevice } from './dispatch-resolve.ts';
 export type { CommandFlags, DispatchContext } from './dispatch-context.ts';
@@ -49,17 +44,7 @@ export async function dispatchCommand(
   outPath?: string,
   context?: DispatchContext,
 ): Promise<Record<string, unknown> | void> {
-  const runnerCtx: RunnerContext = {
-    requestId: context?.requestId,
-    appBundleId: context?.appBundleId,
-    verbose: context?.verbose,
-    logPath: context?.logPath,
-    traceLogPath: context?.traceLogPath,
-    iosXctestrunFile: context?.iosXctestrunFile,
-    iosXctestDerivedDataPath: context?.iosXctestDerivedDataPath,
-    iosXctestEnvDir: context?.iosXctestEnvDir,
-    runnerLeaseContext: context?.runnerLeaseContext,
-  };
+  const runnerCtx = runnerContextFromDispatchContext(context);
   const interactor = await getInteractor(device, runnerCtx);
   emitDiagnostic({
     level: 'debug',
@@ -90,6 +75,40 @@ export async function dispatchCommand(
   );
 }
 
+export async function dispatchGesturePlan(
+  device: DeviceInfo,
+  plan: GesturePlan,
+  context?: DispatchContext,
+): Promise<Record<string, unknown> | void> {
+  const interactor = await getInteractor(device, runnerContextFromDispatchContext(context));
+  if (!interactor.performGesture) {
+    throw new AppError('UNSUPPORTED_OPERATION', 'Gesture execution is unavailable');
+  }
+  return await interactor.performGesture(plan);
+}
+
+export async function dispatchGestureViewport(
+  device: DeviceInfo,
+  context?: DispatchContext,
+): Promise<Rect | undefined> {
+  const interactor = await getInteractor(device, runnerContextFromDispatchContext(context));
+  return await interactor.gestureViewport?.();
+}
+
+function runnerContextFromDispatchContext(context?: DispatchContext): RunnerContext {
+  return {
+    requestId: context?.requestId,
+    appBundleId: context?.appBundleId,
+    verbose: context?.verbose,
+    logPath: context?.logPath,
+    traceLogPath: context?.traceLogPath,
+    iosXctestrunFile: context?.iosXctestrunFile,
+    iosXctestDerivedDataPath: context?.iosXctestDerivedDataPath,
+    iosXctestEnvDir: context?.iosXctestEnvDir,
+    runnerLeaseContext: context?.runnerLeaseContext,
+  };
+}
+
 type DispatchCommand = DescriptorDispatchCommandName;
 
 type DispatchHandlerArgs = {
@@ -127,12 +146,6 @@ const DISPATCH_HANDLERS: Record<DispatchCommand, DispatchHandler> = {
   },
   press: ({ device, interactor, positionals, context }) =>
     handlePressCommand(device, interactor, positionals, context),
-  swipe: ({ device, interactor, positionals, context }) =>
-    handleSwipeCommand(device, interactor, positionals, context),
-  'swipe-preset': ({ device, interactor, positionals, context }) =>
-    handleSwipePresetCommand(device, interactor, positionals, context),
-  pan: ({ interactor, positionals }) => handlePanCommand(interactor, positionals),
-  fling: ({ interactor, positionals }) => handleFlingCommand(interactor, positionals),
   longpress: ({ interactor, positionals }) => handleLongPressCommand(interactor, positionals),
   focus: ({ interactor, positionals }) => handleFocusCommand(interactor, positionals),
   type: ({ interactor, positionals, context }) =>
@@ -141,12 +154,6 @@ const DISPATCH_HANDLERS: Record<DispatchCommand, DispatchHandler> = {
     handleFillCommand(interactor, positionals, context),
   scroll: ({ interactor, positionals, context }) =>
     handleScrollCommand(interactor, positionals, context),
-  pinch: ({ device, interactor, positionals, context }) =>
-    handlePinchCommand(device, interactor, positionals, context),
-  'rotate-gesture': ({ device, interactor, positionals }) =>
-    handleRotateGestureCommand(device, interactor, positionals),
-  'transform-gesture': ({ device, interactor, positionals }) =>
-    handleTransformGestureCommand(device, interactor, positionals),
   'trigger-app-event': ({ device, interactor, positionals, context }) =>
     handleTriggerAppEventCommand(device, interactor, positionals, context),
   screenshot: ({ interactor, positionals, outPath, context }) =>
diff --git a/src/core/interactor-types.ts b/src/core/interactor-types.ts
index b30cdf62f..5f441ceb1 100644
--- a/src/core/interactor-types.ts
+++ b/src/core/interactor-types.ts
@@ -1,13 +1,15 @@
 import type { BackMode } from '../contracts/back-mode.ts';
 import type { DeviceRotation } from '../contracts/device-rotation.ts';
-import type { ScrollDirection, TransformGestureParams } from '../contracts/scroll-gesture.ts';
+import type { ScrollDirection } from '../contracts/scroll-gesture.ts';
 import type { TvRemoteButton } from '../contracts/tv-remote.ts';
+import type { GesturePlan } from '../contracts/gesture-plan-types.ts';
 import type { SettingOptions } from '../platforms/permission-utils.ts';
 import type { SessionSurface } from '../contracts/session-surface.ts';
 import type { BackendSnapshotResult } from '../backend.ts';
 import type { RunnerLogicalLeaseContext } from './runner-lease-context.ts';
 import type {
   RawSnapshotNode,
+  Rect,
   SnapshotBackend,
   SnapshotOptions as BaseSnapshotOptions,
 } from '../kernel/snapshot.ts';
@@ -92,27 +94,6 @@ export type Interactor = {
   tap(x: number, y: number): Promise<Record<string, unknown> | void>;
   tapElementSelector?(selector: ElementSelectorTapOptions): Promise<Record<string, unknown> | void>;
   doubleTap(x: number, y: number): Promise<Record<string, unknown> | void>;
-  swipe(
-    x1: number,
-    y1: number,
-    x2: number,
-    y2: number,
-    durationMs?: number,
-  ): Promise<Record<string, unknown> | void>;
-  pan(
-    x1: number,
-    y1: number,
-    x2: number,
-    y2: number,
-    durationMs?: number,
-  ): Promise<Record<string, unknown> | void>;
-  fling(
-    x1: number,
-    y1: number,
-    x2: number,
-    y2: number,
-    durationMs?: number,
-  ): Promise<Record<string, unknown> | void>;
   longPress(x: number, y: number, durationMs?: number): Promise<Record<string, unknown> | void>;
   focus(x: number, y: number): Promise<Record<string, unknown> | void>;
   type(text: string, delayMs?: number): Promise<void>;
@@ -131,20 +112,14 @@ export type Interactor = {
     direction: ScrollDirection,
     options?: { amount?: number; pixels?: number; durationMs?: number },
   ): Promise<Record<string, unknown> | void>;
-  pinch(scale: number, x?: number, y?: number): Promise<Record<string, unknown> | void>;
   screenshot(outPath: string, options?: ScreenshotOptions): Promise<void>;
   setViewport?(width: number, height: number): Promise<Record<string, unknown> | void>;
   snapshot(options?: SnapshotOptions): Promise<SnapshotResult>;
+  gestureViewport?(): Promise<Rect>;
   back(mode?: BackMode): Promise<void>;
   home(): Promise<void>;
   rotate(orientation: DeviceRotation): Promise<void>;
-  rotateGesture(
-    degrees: number,
-    x?: number,
-    y?: number,
-    velocity?: number,
-  ): Promise<Record<string, unknown> | void>;
-  transformGesture(options: TransformGestureParams): Promise<Record<string, unknown> | void>;
+  performGesture?(plan: GesturePlan): Promise<Record<string, unknown> | void>;
   appSwitcher(): Promise<void>;
   tvRemote(button: TvRemoteButton, durationMs?: number): Promise<void>;
   readClipboard(): Promise<string>;
diff --git a/src/core/interactors/android.ts b/src/core/interactors/android.ts
index 00b7c5c6e..26918ecaa 100644
--- a/src/core/interactors/android.ts
+++ b/src/core/interactors/android.ts
@@ -17,10 +17,8 @@ import {
   typeAndroid,
 } from '../../platforms/android/input-actions.ts';
 import {
-  pinchAndroid,
-  rotateGestureAndroid,
-  swipeGestureAndroid,
-  transformGestureAndroid,
+  performGestureAndroid,
+  readAndroidGestureViewport,
 } from '../../platforms/android/multitouch-helper.ts';
 import {
   readAndroidClipboardText,
@@ -50,18 +48,13 @@ export function createAndroidInteractor(device: DeviceInfo): Interactor {
       await pressAndroid(device, x, y);
       await pressAndroid(device, x, y);
     },
-    swipe: (x1, y1, x2, y2, durationMs) =>
-      swipeGestureAndroid(device, { x1, y1, x2, y2, durationMs }),
-    pan: (x1, y1, x2, y2, durationMs) =>
-      swipeGestureAndroid(device, { x1, y1, x2, y2, durationMs }),
-    fling: (x1, y1, x2, y2, durationMs) =>
-      swipeGestureAndroid(device, { x1, y1, x2, y2, durationMs }),
     longPress: (x, y, durationMs) => longPressAndroid(device, x, y, durationMs),
     focus: (x, y) => focusAndroid(device, x, y),
     type: (text, delayMs) => typeAndroid(device, text, delayMs),
     fill: (x, y, text, delayMs) => fillAndroid(device, x, y, text, delayMs),
     scroll: (direction, options) => scrollAndroid(device, direction, options),
-    pinch: (scale, x, y) => pinchAndroid(device, { scale, x, y }),
+    performGesture: (plan) => performGestureAndroid(device, plan),
+    gestureViewport: () => readAndroidGestureViewport(device),
     screenshot: (outPath, options) => screenshotAndroid(device, outPath, options),
     snapshot: async (options) => {
       const result = await withDiagnosticTimer(
@@ -89,9 +82,6 @@ export function createAndroidInteractor(device: DeviceInfo): Interactor {
     back: (_mode) => backAndroid(device),
     home: () => homeAndroid(device),
     rotate: (orientation) => rotateAndroid(device, orientation),
-    rotateGesture: (degrees, x, y, velocity) =>
-      rotateGestureAndroid(device, { degrees, x, y, velocity }),
-    transformGesture: (options) => transformGestureAndroid(device, options),
     appSwitcher: () => appSwitcherAndroid(device),
     tvRemote: (button, durationMs) => pressAndroidTvRemote(device, button, durationMs),
     readClipboard: () => readAndroidClipboardText(device),
diff --git a/src/core/interactors/linux.ts b/src/core/interactors/linux.ts
index 599b6934a..198e72b4f 100644
--- a/src/core/interactors/linux.ts
+++ b/src/core/interactors/linux.ts
@@ -17,6 +17,7 @@ import {
   swipeLinux,
   typeLinux,
 } from '../../platforms/linux/input-actions.ts';
+import { singlePointerPlanEndpoints } from '../../contracts/gesture-plan.ts';
 import { screenshotLinux } from '../../platforms/linux/screenshot.ts';
 import { snapshotLinux } from '../../platforms/linux/snapshot.ts';
 import type { Interactor } from '../interactor-types.ts';
@@ -28,18 +29,20 @@ export function createLinuxInteractor(): Interactor {
     close: (app) => closeLinuxApp(app),
     tap: (x, y) => pressLinux(x, y),
     doubleTap: (x, y) => doubleClickLinux(x, y),
-    swipe: (x1, y1, x2, y2, durationMs) => swipeLinux(x1, y1, x2, y2, durationMs),
-    pan: (x1, y1, x2, y2, durationMs) => swipeLinux(x1, y1, x2, y2, durationMs),
-    fling: () => {
-      throw new AppError('UNSUPPORTED_OPERATION', 'gesture fling not supported on Linux');
-    },
     longPress: (x, y, durationMs) => longPressLinux(x, y, durationMs),
     focus: (x, y) => focusLinux(x, y),
     type: (text, delayMs) => typeLinux(text, delayMs),
     fill: (x, y, text, delayMs) => fillLinux(x, y, text, delayMs),
     scroll: (direction, options) => scrollLinux(direction, options),
-    pinch: () => {
-      throw new AppError('UNSUPPORTED_OPERATION', 'gesture pinch not supported on Linux');
+    performGesture: async (plan) => {
+      if (plan.topology === 'two') {
+        throw new AppError(
+          'UNSUPPORTED_OPERATION',
+          'Multi-touch gestures are not supported on Linux',
+        );
+      }
+      const { start, end } = singlePointerPlanEndpoints(plan);
+      await swipeLinux(start.x, start.y, end.x, end.y, plan.durationMs);
     },
     screenshot: (outPath, options) => screenshotLinux(outPath, options),
     snapshot: async (options) => {
@@ -59,12 +62,6 @@ export function createLinuxInteractor(): Interactor {
     rotate: () => {
       throw new AppError('UNSUPPORTED_OPERATION', 'rotate not supported on Linux');
     },
-    rotateGesture: () => {
-      throw new AppError('UNSUPPORTED_OPERATION', 'gesture rotate not supported on Linux');
-    },
-    transformGesture: () => {
-      throw new AppError('UNSUPPORTED_OPERATION', 'gesture transform not supported on Linux');
-    },
     appSwitcher: () => {
       throw new AppError('UNSUPPORTED_OPERATION', 'appSwitcher not yet supported on Linux');
     },
diff --git a/src/core/interactors/web.ts b/src/core/interactors/web.ts
index c46f12eca..36d9a31fd 100644
--- a/src/core/interactors/web.ts
+++ b/src/core/interactors/web.ts
@@ -11,15 +11,11 @@ export function createWebInteractor(): Interactor {
     close: (target) => provider().close(target),
     tap: (x, y) => provider().click(x, y),
     doubleTap: () => unsupportedWebOperation('doubleTap'),
-    swipe: () => unsupportedWebOperation('swipe'),
-    pan: () => unsupportedWebOperation('pan'),
-    fling: () => unsupportedWebOperation('fling'),
     longPress: () => unsupportedWebOperation('longPress'),
     focus: (x, y) => provider().click(x, y),
     type: (text, delayMs) => provider().typeText(text, { delayMs }),
     fill: (x, y, text, delayMs) => provider().fill(x, y, text, { delayMs }),
     scroll: (direction, options) => provider().scroll(direction, options),
-    pinch: () => unsupportedWebOperation('pinch'),
     screenshot: (outPath, options) => provider().screenshot(outPath, options),
     setViewport: (width, height) => provider().setViewport(width, height),
     snapshot: async (options) => {
@@ -37,8 +33,6 @@ export function createWebInteractor(): Interactor {
     back: () => unsupportedWebOperation('back'),
     home: () => unsupportedWebOperation('home'),
     rotate: () => unsupportedWebOperation('rotate'),
-    rotateGesture: () => unsupportedWebOperation('rotateGesture'),
-    transformGesture: () => unsupportedWebOperation('transformGesture'),
     appSwitcher: () => unsupportedWebOperation('appSwitcher'),
     tvRemote: () => unsupportedWebOperation('tvRemote'),
     readClipboard: () => unsupportedWebOperation('readClipboard'),
diff --git a/src/core/platform-plugin/__tests__/apple-os-capability-table-parity.test.ts b/src/core/platform-plugin/__tests__/apple-os-capability-table-parity.test.ts
index 676748e72..bd68354bf 100644
--- a/src/core/platform-plugin/__tests__/apple-os-capability-table-parity.test.ts
+++ b/src/core/platform-plugin/__tests__/apple-os-capability-table-parity.test.ts
@@ -4,6 +4,7 @@ import { isAudioProbeSupportedDevice } from '../../../kernel/audio-probe-support
 import {
   isIosFamily,
   isMacOs,
+  resolveDeviceAppleOs,
   DEVICE_TARGETS,
   PLATFORMS,
   type AppleOS,
@@ -23,10 +24,7 @@ import {
   VISIONOS_SIMULATOR,
   WEB_DESKTOP_DEVICE,
 } from '../../../__tests__/test-utils/index.ts';
-import {
-  APPLE_OS_CAPABILITIES,
-  resolveDeviceAppleOs,
-} from '../../../platforms/apple/capabilities.ts';
+import { APPLE_OS_CAPABILITIES } from '../../../platforms/apple/capabilities.ts';
 import { getPlugin } from '../plugin.ts';
 import { registerBuiltinPlatformPlugins } from '../../interactors/register-builtins.ts';
 
@@ -49,25 +47,11 @@ registerBuiltinPlatformPlugins();
 const isNotMacOs = (device: DeviceInfo): boolean => !isMacOs(device);
 const isMacOsOrAppleSimulator = (device: DeviceInfo): boolean =>
   isMacOs(device) || device.kind === 'simulator';
-const isIosMobileSimulator = (device: DeviceInfo): boolean =>
-  isIosFamily(device) && device.kind === 'simulator' && device.target !== 'tv';
-const supportsSynthesisGesture = (device: DeviceInfo): boolean =>
-  device.platform === 'android' || isIosMobileSimulator(device);
 const supportsAndroidOrIosNonTv = (device: DeviceInfo): boolean =>
   device.platform === 'android' || (isIosFamily(device) && device.target !== 'tv');
 const supportsTvRemote = (device: DeviceInfo): boolean =>
   (device.platform === 'android' && device.target === 'tv') ||
   (isIosFamily(device) && device.target === 'tv');
-const synthesisGestureUnsupportedHint = (device: DeviceInfo): string | undefined => {
-  if (isMacOs(device))
-    return 'macOS automation has no multi-touch input — this gesture is supported on Android and the iOS simulator only.';
-  if (isIosFamily(device) && device.target === 'tv')
-    return 'tvOS has no touch input — this gesture is supported on Android and the iOS simulator only.';
-  if (isIosFamily(device) && device.kind === 'device')
-    return 'Two-finger gesture synthesis is iOS-simulator only — not available on physical iOS devices.';
-  return undefined;
-};
-
 const SUPPORTS_REF: Record<string, (device: DeviceInfo) => boolean> = {
   boot: isNotMacOs,
   install: isNotMacOs,
@@ -92,9 +76,6 @@ const SUPPORTS_REF: Record<string, (device: DeviceInfo) => boolean> = {
   // assertion stays strict (catches a dropped command) and confirms the rebase
   // did not alter it.
   audio: isAudioProbeSupportedDevice,
-  pinch: supportsSynthesisGesture,
-  'rotate-gesture': supportsSynthesisGesture,
-  'transform-gesture': supportsSynthesisGesture,
 };
 const HINT_REF: Record<string, (device: DeviceInfo) => string | undefined> = {
   'tv-remote': (device) => {
@@ -108,9 +89,6 @@ const HINT_REF: Record<string, (device: DeviceInfo) => string | undefined> = {
     }
     return isMacOs(device) ? 'tv-remote is supported only on tvOS devices.' : undefined;
   },
-  pinch: synthesisGestureUnsupportedHint,
-  'rotate-gesture': synthesisGestureUnsupportedHint,
-  'transform-gesture': synthesisGestureUnsupportedHint,
 };
 
 // ---------------------------------------------------------------------------
@@ -165,16 +143,13 @@ const SAMPLE_DEVICES: DeviceInfo[] = [
   ...buildSyntheticMatrix(),
 ];
 
-test('the per-AppleOS table row keys are exhaustive and iOS/iPadOS/visionOS share one row', () => {
+test('the per-AppleOS capability table row keys are exhaustive', () => {
   const rows: AppleOS[] = ['ios', 'ipados', 'tvos', 'watchos', 'visionos', 'macos'];
   for (const os of rows) {
     assert.ok(APPLE_OS_CAPABILITIES[os], `capability row present for ${os}`);
   }
-  // The iOS family is capability-identical today; sharing ONE frozen row is the
-  // invariant that makes a stored `appleOs: 'ipados' | 'visionos'` read exactly what
-  // the legacy target-inference produced for an unlabeled iOS record.
+  // iOS/iPadOS share the same platform capability profile.
   assert.equal(APPLE_OS_CAPABILITIES.ios, APPLE_OS_CAPABILITIES.ipados);
-  assert.equal(APPLE_OS_CAPABILITIES.ios, APPLE_OS_CAPABILITIES.visionos);
 });
 
 test('resolveDeviceAppleOs prefers the stored discriminant, else infers from target', () => {
diff --git a/src/daemon/__tests__/daemon-command-registry.test.ts b/src/daemon/__tests__/daemon-command-registry.test.ts
index 8e5832ca7..5b69c986d 100644
--- a/src/daemon/__tests__/daemon-command-registry.test.ts
+++ b/src/daemon/__tests__/daemon-command-registry.test.ts
@@ -97,7 +97,6 @@ test('daemon command registry preserves replay and recording traits', () => {
     PUBLIC_COMMANDS.is,
     PUBLIC_COMMANDS.keyboard,
     PUBLIC_COMMANDS.longPress,
-    'pinch',
     PUBLIC_COMMANDS.press,
     PUBLIC_COMMANDS.record,
     PUBLIC_COMMANDS.reactNative,
@@ -129,15 +128,10 @@ test('daemon command registry preserves Android modal and lock-policy traits', (
     PUBLIC_COMMANDS.home,
     PUBLIC_COMMANDS.keyboard,
     PUBLIC_COMMANDS.longPress,
-    'fling',
-    'pan',
-    'pinch',
     PUBLIC_COMMANDS.press,
     PUBLIC_COMMANDS.rotate,
-    'rotate-gesture',
     PUBLIC_COMMANDS.scroll,
     PUBLIC_COMMANDS.swipe,
-    'transform-gesture',
     PUBLIC_COMMANDS.type,
   ]) {
     assert.equal(shouldGuardAndroidBlockingDialog(command), true, `${command} Android guard`);
diff --git a/src/daemon/__tests__/recording-gestures.test.ts b/src/daemon/__tests__/recording-gestures.test.ts
index c02cde7bc..a636e14c5 100644
--- a/src/daemon/__tests__/recording-gestures.test.ts
+++ b/src/daemon/__tests__/recording-gestures.test.ts
@@ -194,6 +194,186 @@ test('swipe visualization prefers native gesture duration when available', () =>
   assert.equal(event.durationMs, 780);
 });
 
+test('canonical gesture results record pan, fling, and pinch visualization telemetry', () => {
+  const session = makeSession();
+
+  recordTouchVisualizationEvent(
+    session,
+    'gesture',
+    ['pan', '40', '100', '120', '-20', '360'],
+    {
+      kind: 'pan',
+      from: { x: 40, y: 100 },
+      to: { x: 160, y: 80 },
+      durationMs: 360,
+      pointerCount: 1,
+    },
+    {},
+    1_500,
+    1_860,
+  );
+  recordTouchVisualizationEvent(
+    session,
+    'gesture',
+    ['fling', 'left', '260', '400', '180'],
+    {
+      kind: 'fling',
+      from: { x: 260, y: 400 },
+      to: { x: 80, y: 400 },
+      durationMs: 180,
+      pointerCount: 1,
+    },
+    {},
+    1_900,
+    2_080,
+  );
+  recordTouchVisualizationEvent(
+    session,
+    'gesture',
+    ['pinch', '1.5', '201', '437'],
+    {
+      kind: 'pinch',
+      from: { x: 201, y: 437 },
+      to: { x: 201, y: 437 },
+      scale: 1.5,
+      durationMs: 280,
+      pointerCount: 2,
+    },
+    {},
+    2_100,
+    2_380,
+  );
+
+  assert.deepEqual(session.recording?.gestureEvents, [
+    {
+      kind: 'swipe',
+      tMs: 500,
+      x: 40,
+      y: 100,
+      x2: 160,
+      y2: 80,
+      referenceWidth: 402,
+      referenceHeight: 874,
+      durationMs: 360,
+    },
+    {
+      kind: 'swipe',
+      tMs: 900,
+      x: 260,
+      y: 400,
+      x2: 80,
+      y2: 400,
+      referenceWidth: 402,
+      referenceHeight: 874,
+      durationMs: 180,
+    },
+    {
+      kind: 'pinch',
+      tMs: 1_100,
+      x: 201,
+      y: 437,
+      referenceWidth: 402,
+      referenceHeight: 874,
+      scale: 1.5,
+      durationMs: 280,
+    },
+  ]);
+});
+
+test('canonical rotate records centroid visualization telemetry', () => {
+  const session = makeSession();
+
+  recordTouchVisualizationEvent(
+    session,
+    'gesture',
+    ['rotate', '35', '201', '437'],
+    {
+      kind: 'rotate',
+      from: { x: 201, y: 437 },
+      to: { x: 201, y: 437 },
+      durationMs: 300,
+      pointerCount: 2,
+    },
+    {},
+    1_500,
+    1_800,
+  );
+
+  assert.deepEqual(session.recording?.gestureEvents, [
+    {
+      kind: 'swipe',
+      tMs: 500,
+      x: 201,
+      y: 437,
+      x2: 201,
+      y2: 437,
+      referenceWidth: 402,
+      referenceHeight: 874,
+      durationMs: 300,
+    },
+  ]);
+});
+
+test('canonical multi-touch travel does not acquire one-finger back-swipe semantics', () => {
+  const session = makeSession();
+
+  recordTouchVisualizationEvent(
+    session,
+    'gesture',
+    ['transform', '10', '437', '170', '0', '1.4', '25', '600'],
+    {
+      kind: 'transform',
+      from: { x: 10, y: 437 },
+      to: { x: 180, y: 437 },
+      durationMs: 600,
+      pointerCount: 2,
+    },
+    {},
+    1_500,
+    2_100,
+  );
+  recordTouchVisualizationEvent(
+    session,
+    'gesture',
+    ['pan', '392', '437', '-170', '0', '400'],
+    {
+      kind: 'pan',
+      from: { x: 392, y: 437 },
+      to: { x: 222, y: 437 },
+      durationMs: 400,
+      pointerCount: 2,
+    },
+    {},
+    2_200,
+    2_600,
+  );
+
+  assert.deepEqual(session.recording?.gestureEvents, [
+    {
+      kind: 'swipe',
+      tMs: 500,
+      x: 10,
+      y: 437,
+      x2: 180,
+      y2: 437,
+      referenceWidth: 402,
+      referenceHeight: 874,
+      durationMs: 600,
+    },
+    {
+      kind: 'swipe',
+      tMs: 1_200,
+      x: 392,
+      y: 437,
+      x2: 222,
+      y2: 437,
+      referenceWidth: 402,
+      referenceHeight: 874,
+      durationMs: 400,
+    },
+  ]);
+});
+
 test('telemetry is still captured when touch overlays are hidden', () => {
   const session = makeSession();
   if (session.recording) {
diff --git a/src/daemon/__tests__/request-handler-catalog.test.ts b/src/daemon/__tests__/request-handler-catalog.test.ts
index 62a4d1cb2..184513d1a 100644
--- a/src/daemon/__tests__/request-handler-catalog.test.ts
+++ b/src/daemon/__tests__/request-handler-catalog.test.ts
@@ -42,13 +42,11 @@ test('catalog commands use generic routing only when intentionally passthrough o
     PUBLIC_COMMANDS.appSwitcher,
     PUBLIC_COMMANDS.back,
     PUBLIC_COMMANDS.focus,
-    PUBLIC_COMMANDS.gesture,
     PUBLIC_COMMANDS.home,
     PUBLIC_COMMANDS.installFromSource,
     PUBLIC_COMMANDS.rotate,
     PUBLIC_COMMANDS.screenshot,
     PUBLIC_COMMANDS.scroll,
-    PUBLIC_COMMANDS.swipe,
     PUBLIC_COMMANDS.tvRemote,
     PUBLIC_COMMANDS.viewport,
   ].sort();
@@ -60,9 +58,6 @@ test('catalog commands use generic routing only when intentionally passthrough o
     .sort();
 
   assert.deepEqual(genericCatalogCommands, intentionalGenericCatalogCommands);
-  for (const command of ['fling', 'pan', 'pinch', 'rotate-gesture', 'transform-gesture']) {
-    assert.equal(getDaemonCommandRoute(command), 'generic', `${command} passthrough route`);
-  }
 });
 
 test('lease handler executes commands owned by the lease route', async () => {
diff --git a/src/daemon/__tests__/request-handler-chain.test.ts b/src/daemon/__tests__/request-handler-chain.test.ts
index 7103a2af5..f7e3aac86 100644
--- a/src/daemon/__tests__/request-handler-chain.test.ts
+++ b/src/daemon/__tests__/request-handler-chain.test.ts
@@ -6,8 +6,18 @@ import { LeaseRegistry } from '../lease-registry.ts';
 import { runRequestHandlerChain } from '../request-handler-chain.ts';
 import { getDaemonRouteOwnerFiles } from '../route-owner-files.ts';
 import type { DaemonRequest, DaemonResponse } from '../types.ts';
-import { makeIosSession } from '../../__tests__/test-utils/index.ts';
+import {
+  LINUX_DEVICE,
+  makeIosSession,
+  makeSession,
+  makeSnapshotState,
+} from '../../__tests__/test-utils/index.ts';
 import { makeSessionStore } from '../../__tests__/test-utils/store-factory.ts';
+import { dispatchSwipeViaRuntime } from '../handlers/interaction-gesture.ts';
+import {
+  createLocalLinuxToolProvider,
+  withLinuxToolProvider,
+} from '../../platforms/linux/tool-provider.ts';
 
 function makeRequest(command: string, positionals: string[] = []): DaemonRequest {
   return {
@@ -70,13 +80,112 @@ test('request handler chain routes trace commands to the record-trace family', a
 });
 
 test('request handler chain leaves generic commands for fallback dispatch', async () => {
-  for (const command of ['back', 'gesture', 'home', 'screenshot', 'scroll', 'swipe']) {
+  for (const command of ['back', 'home', 'screenshot', 'scroll']) {
     const response = await runRequestHandlerChain(makeChainParams(makeRequest(command)));
 
     assert.equal(response, null, `${command} should fall through to generic dispatch`);
   }
 });
 
+test('request handler chain routes gesture through the interaction runtime', async () => {
+  const response = await runRequestHandlerChain(makeChainParams(makeRequest('gesture')));
+
+  assert.equal(response?.ok, false);
+  if (response?.ok !== false) throw new Error('Expected invalid gesture response');
+  assert.equal(response.error.code, 'INVALID_ARGS');
+});
+
+test('request handler chain routes swipe through the interaction runtime', async () => {
+  const response = await runRequestHandlerChain(makeChainParams(makeRequest('swipe')));
+
+  assert.equal(response?.ok, false);
+  if (response?.ok !== false) throw new Error('Expected invalid swipe response');
+  assert.equal(response.error.code, 'INVALID_ARGS');
+});
+
+test('swipe rejects repetition inputs that can monopolize the request', async () => {
+  const cases = [
+    {
+      input: { count: 201 },
+      message: 'Expected count to be at most 200.',
+    },
+    {
+      input: { pauseMs: 10_001 },
+      message: 'Expected pauseMs to be at most 10000.',
+    },
+    {
+      input: { count: 7, durationMs: 10_000 },
+      message: 'Swipe series must fit within 60000ms.',
+    },
+  ];
+
+  for (const { input, message } of cases) {
+    const req = {
+      ...makeRequest('swipe'),
+      input: {
+        from: { x: 10, y: 20 },
+        to: { x: 110, y: 20 },
+        ...input,
+      },
+    };
+    const response = await runRequestHandlerChain(makeChainParams(req));
+
+    assert.equal(response?.ok, false);
+    if (response?.ok !== false) throw new Error('Expected invalid swipe response');
+    assert.equal(response.error.code, 'INVALID_ARGS');
+    assert.equal(response.error.message, message);
+  }
+});
+
+test('duration-less public coordinate swipe retains Linux drag behavior', async () => {
+  const sessionStore = makeSessionStore('agent-device-linux-swipe-');
+  sessionStore.set('linux-swipe', makeSession('linux-swipe', { device: LINUX_DEVICE }));
+  const drags: number[][] = [];
+  const provider = createLocalLinuxToolProvider({
+    input: {
+      click: async () => {},
+      doubleClick: async () => {},
+      longPress: async () => {},
+      drag: async (...values) => {
+        drags.push(values);
+      },
+      scroll: async () => {},
+      typeText: async () => {},
+      key: async () => {},
+    },
+  });
+
+  const response = await withLinuxToolProvider(
+    provider,
+    async () =>
+      await dispatchSwipeViaRuntime({
+        req: {
+          ...makeRequest('swipe'),
+          session: 'linux-swipe',
+          input: { from: { x: 10, y: 20 }, to: { x: 110, y: 20 } },
+        },
+        sessionName: 'linux-swipe',
+        sessionStore,
+        contextFromFlags: () => ({}),
+        captureSnapshotForSession: async () =>
+          makeSnapshotState([
+            {
+              index: 0,
+              rect: { x: 0, y: 0, width: 200, height: 200 },
+              visibleToUser: true,
+            },
+          ]),
+      }),
+  );
+
+  assert.equal(response.ok, true);
+  if (!response.ok) return;
+  assert.ok(response.data);
+  assert.equal(response.data.kind, 'fling');
+  assert.equal(response.data.durationMs, 100);
+  assert.deepEqual(drags, [[10, 20, 110, 20, 100]]);
+});
+
 test('request handler chain routes lease commands to the lease family', async () => {
   const response = await runRequestHandlerChain({
     ...makeChainParams({
diff --git a/src/daemon/__tests__/request-router-recording-health.test.ts b/src/daemon/__tests__/request-router-recording-health.test.ts
index c6879d5a5..d6dc2a189 100644
--- a/src/daemon/__tests__/request-router-recording-health.test.ts
+++ b/src/daemon/__tests__/request-router-recording-health.test.ts
@@ -4,14 +4,23 @@ import path from 'node:path';
 
 vi.mock('../../core/dispatch.ts', async (importOriginal) => {
   const actual = await importOriginal<typeof import('../../core/dispatch.ts')>();
-  return { ...actual, dispatchCommand: vi.fn(async () => ({})) };
+  return {
+    ...actual,
+    dispatchCommand: vi.fn(async () => ({})),
+    dispatchGesturePlan: vi.fn(async () => ({})),
+    dispatchGestureViewport: vi.fn(async () => ({ x: 0, y: 0, width: 390, height: 844 })),
+  };
 });
 
 vi.mock('../../platforms/apple/core/runner/runner-client.ts', () => ({
   getRunnerSessionSnapshot: vi.fn(),
 }));
 
-import { dispatchCommand } from '../../core/dispatch.ts';
+import {
+  dispatchCommand,
+  dispatchGesturePlan,
+  dispatchGestureViewport,
+} from '../../core/dispatch.ts';
 import { getRunnerSessionSnapshot } from '../../platforms/apple/core/runner/runner-client.ts';
 import { createRequestHandler } from '../request-router.ts';
 import type { SessionState } from '../types.ts';
@@ -19,11 +28,17 @@ import { LeaseRegistry } from '../lease-registry.ts';
 import { makeSessionStore } from '../../__tests__/test-utils/store-factory.ts';
 
 const mockDispatch = vi.mocked(dispatchCommand);
+const mockDispatchGesturePlan = vi.mocked(dispatchGesturePlan);
+const mockDispatchGestureViewport = vi.mocked(dispatchGestureViewport);
 const mockGetRunnerSessionSnapshot = vi.mocked(getRunnerSessionSnapshot);
 
 beforeEach(() => {
   mockDispatch.mockReset();
   mockDispatch.mockResolvedValue({});
+  mockDispatchGesturePlan.mockReset();
+  mockDispatchGesturePlan.mockResolvedValue({});
+  mockDispatchGestureViewport.mockReset();
+  mockDispatchGestureViewport.mockResolvedValue({ x: 0, y: 0, width: 390, height: 844 });
   mockGetRunnerSessionSnapshot.mockReset();
 });
 
@@ -80,7 +95,7 @@ test('router blocks non-record commands when recording was invalidated', async (
   expect(mockDispatch).not.toHaveBeenCalled();
 });
 
-test('router allows iOS simulator gestures during overlay recording after runner restart', async () => {
+test('router allows canonical iOS simulator gestures during overlay recording after runner restart', async () => {
   const sessionStore = makeSessionStore('agent-device-router-recording-health-');
   const session: SessionState = {
     name: 'default',
@@ -111,14 +126,6 @@ test('router allows iOS simulator gestures during overlay recording after runner
     alive: true,
     sessionId: 'runner-after',
   });
-  mockDispatch.mockResolvedValue({
-    action: 'pinch',
-    scale: 1.2,
-    x: 100,
-    y: 200,
-    durationMs: 280,
-  });
-
   const handler = createRequestHandler({
     logPath: path.join(os.tmpdir(), 'daemon.log'),
     token: 'test-token',
@@ -130,14 +137,16 @@ test('router allows iOS simulator gestures during overlay recording after runner
   const response = await handler({
     token: 'test-token',
     session: 'default',
-    command: 'pinch',
-    positionals: ['1.2', '100', '200'],
+    command: 'gesture',
+    positionals: [],
+    input: { kind: 'pinch', scale: 1.2, origin: { x: 100, y: 200 } },
     meta: { requestId: 'req-simulator-runner-restart' },
   });
 
   expect(response.ok).toBe(true);
   expect(mockGetRunnerSessionSnapshot).not.toHaveBeenCalled();
-  expect(mockDispatch).toHaveBeenCalled();
+  expect(mockDispatchGestureViewport).toHaveBeenCalledOnce();
+  expect(mockDispatchGesturePlan).toHaveBeenCalledOnce();
   const recording = sessionStore.get('default')?.recording;
   expect(recording?.invalidatedReason).toBeUndefined();
   expect(recording?.gestureEvents).toHaveLength(1);
diff --git a/src/daemon/__tests__/session-store.test.ts b/src/daemon/__tests__/session-store.test.ts
index 6318c4fdb..149a30ff1 100644
--- a/src/daemon/__tests__/session-store.test.ts
+++ b/src/daemon/__tests__/session-store.test.ts
@@ -490,6 +490,15 @@ test('writeSessionLog preserves interaction series flags for click/press/swipe',
     },
     result: {},
   });
+  fixture.store.recordAction(fixture.session, {
+    command: 'gesture',
+    positionals: ['pan', '195', '443', '48', '0', '500'],
+    flags: {
+      platform: 'ios',
+      pointerCount: 2,
+    },
+    result: {},
+  });
   recordClose(fixture.store, fixture.session);
 
   const script = writeScript(fixture);
@@ -498,6 +507,7 @@ test('writeSessionLog preserves interaction series flags for click/press/swipe',
     /press 201 545 --count 4 --interval-ms 8/,
     /swipe 10 20 30 40 --count 3 --pause-ms 12 --pattern ping-pong/,
     /fill @e5 "search" --delay-ms 40/,
+    /gesture "pan" 195 443 48 0 500 --pointer-count 2/,
   ]);
 });
 
diff --git a/src/daemon/handlers/__tests__/session-capabilities.test.ts b/src/daemon/handlers/__tests__/session-capabilities.test.ts
index 4beed6613..363f851d9 100644
--- a/src/daemon/handlers/__tests__/session-capabilities.test.ts
+++ b/src/daemon/handlers/__tests__/session-capabilities.test.ts
@@ -34,7 +34,16 @@ test('capabilities reports supported commands for the selected session device',
     kind: 'emulator',
   });
   expect(response.data?.availableCommands).toEqual(
-    expect.arrayContaining(['open', 'screenshot', 'snapshot', 'press', 'fill', 'network', 'perf']),
+    expect.arrayContaining([
+      'open',
+      'screenshot',
+      'snapshot',
+      'press',
+      'fill',
+      'network',
+      'perf',
+      PUBLIC_COMMANDS.gesture,
+    ]),
   );
   expect(response.data?.availableCommands).not.toContain(PUBLIC_COMMANDS.capabilities);
   expect(response.data?.availableCommands).not.toContain(PUBLIC_COMMANDS.devices);
diff --git a/src/daemon/handlers/__tests__/session-replay-vars.test.ts b/src/daemon/handlers/__tests__/session-replay-vars.test.ts
index 0f3c324f2..6116ccdc3 100644
--- a/src/daemon/handlers/__tests__/session-replay-vars.test.ts
+++ b/src/daemon/handlers/__tests__/session-replay-vars.test.ts
@@ -42,6 +42,7 @@ const LOC = { file: 'test.ad', line: 1 };
 type CapturedInvocation = {
   command: string;
   positionals?: string[];
+  input?: Record<string, unknown>;
   flags?: CommandFlags;
 };
 
@@ -65,7 +66,12 @@ async function runReplayFixture(params: {
   fs.writeFileSync(scriptPath, params.script);
   const calls: CapturedInvocation[] = [];
   const invoke = async (req: DaemonRequest): Promise<DaemonResponse> => {
-    calls.push({ command: req.command, positionals: req.positionals, flags: req.flags });
+    calls.push({
+      command: req.command,
+      positionals: req.positionals,
+      input: req.input,
+      flags: req.flags,
+    });
     if (params.invoke) return await params.invoke(req);
     return { ok: true, data: {} };
   };
@@ -475,6 +481,52 @@ test('runReplayScriptFile dispatches resolved literals with file env overridden
   }
 });
 
+test('.ad replay normalizes resolved gesture and swipe syntax into structured daemon input', async () => {
+  const { response, calls } = await runReplayFixture({
+    label: 'structured-gesture-input',
+    script: [
+      'env X=10',
+      'gesture pan ${X} 20 30 40 500 --pointer-count 2',
+      'swipe ${X} 20 30 40 300 --count 2 --pause-ms 5 --pattern ping-pong',
+      '',
+    ].join('\n'),
+  });
+
+  assert.equal(response.ok, true);
+  assert.deepEqual(
+    calls.map((call) => ({
+      command: call.command,
+      positionals: call.positionals,
+      input: call.input,
+    })),
+    [
+      {
+        command: 'gesture',
+        positionals: [],
+        input: {
+          kind: 'pan',
+          origin: { x: 10, y: 20 },
+          delta: { x: 30, y: 40 },
+          pointerCount: 2,
+          durationMs: 500,
+        },
+      },
+      {
+        command: 'swipe',
+        positionals: [],
+        input: {
+          from: { x: 10, y: 20 },
+          to: { x: 30, y: 40 },
+          durationMs: 300,
+          count: 2,
+          pauseMs: 5,
+          pattern: 'ping-pong',
+        },
+      },
+    ],
+  );
+});
+
 test('runReplayScriptFile reports snapshot diagnostics from per-action session samples', async () => {
   const root = fs.mkdtempSync(path.join(os.tmpdir(), 'agent-device-replay-snapshot-samples-'));
   const scriptPath = path.join(root, 'flow.ad');
@@ -1655,7 +1707,12 @@ test('runReplayScriptFile resolves Maestro swipe.label from a labeled element re
     ].join('\n'),
     flags: { replayBackend: 'maestro' },
     invoke: async (req) => {
-      calls.push({ command: req.command, positionals: req.positionals, flags: req.flags });
+      calls.push({
+        command: req.command,
+        positionals: req.positionals,
+        input: req.input,
+        flags: req.flags,
+      });
       if (req.command === 'snapshot') {
         return {
           ok: true,
@@ -1676,10 +1733,10 @@ test('runReplayScriptFile resolves Maestro swipe.label from a labeled element re
 
   assert.equal(response.ok, true);
   assert.deepEqual(
-    calls.map((call) => [call.command, call.positionals]),
+    calls.map((call) => [call.command, call.input]),
     [
-      ['snapshot', []],
-      ['swipe', ['110', '250', '110', '8', '400']],
+      ['snapshot', undefined],
+      ['swipe', { from: { x: 110, y: 250 }, to: { x: 110, y: 8 }, durationMs: 400 }],
     ],
   );
 });
@@ -1699,7 +1756,12 @@ test('runReplayScriptFile keeps Maestro swipe.label anchored to the matched labe
     ].join('\n'),
     flags: { replayBackend: 'maestro', platform: 'ios' },
     invoke: async (req) => {
-      calls.push({ command: req.command, positionals: req.positionals, flags: req.flags });
+      calls.push({
+        command: req.command,
+        positionals: req.positionals,
+        input: req.input,
+        flags: req.flags,
+      });
       if (req.command === 'snapshot') {
         return {
           ok: true,
@@ -1729,10 +1791,10 @@ test('runReplayScriptFile keeps Maestro swipe.label anchored to the matched labe
 
   assert.equal(response.ok, true);
   assert.deepEqual(
-    calls.map((call) => [call.command, call.positionals]),
+    calls.map((call) => [call.command, call.input]),
     [
-      ['snapshot', []],
-      ['swipe', ['100', '124', '100', '8', '400']],
+      ['snapshot', undefined],
+      ['swipe', { from: { x: 100, y: 124 }, to: { x: 100, y: 8 }, durationMs: 400 }],
     ],
   );
 });
@@ -1755,7 +1817,12 @@ test('runReplayScriptFile resolves Maestro screen swipes from the snapshot frame
     ].join('\n'),
     flags: { replayBackend: 'maestro' },
     invoke: async (req) => {
-      calls.push({ command: req.command, positionals: req.positionals, flags: req.flags });
+      calls.push({
+        command: req.command,
+        positionals: req.positionals,
+        input: req.input,
+        flags: req.flags,
+      });
       if (req.command === 'snapshot') {
         return {
           ok: true,
@@ -1776,11 +1843,11 @@ test('runReplayScriptFile resolves Maestro screen swipes from the snapshot frame
 
   assert.equal(response.ok, true);
   assert.deepEqual(
-    calls.map((call) => [call.command, call.positionals]),
+    calls.map((call) => [call.command, call.input]),
     [
-      ['gesture', ['swipe', 'left', '300']],
-      ['snapshot', []],
-      ['swipe', ['360', '400', '40', '400', '300']],
+      ['gesture', { kind: 'swipe', preset: 'left', durationMs: 300 }],
+      ['snapshot', undefined],
+      ['swipe', { from: { x: 360, y: 400 }, to: { x: 40, y: 400 }, durationMs: 300 }],
     ],
   );
 });
@@ -1803,7 +1870,12 @@ test('runReplayScriptFile delegates Android directional swipes and preserves per
     ].join('\n'),
     flags: { replayBackend: 'maestro', platform: 'android' },
     invoke: async (req) => {
-      calls.push({ command: req.command, positionals: req.positionals, flags: req.flags });
+      calls.push({
+        command: req.command,
+        positionals: req.positionals,
+        input: req.input,
+        flags: req.flags,
+      });
       if (req.command === 'snapshot') {
         return {
           ok: true,
@@ -1824,11 +1896,11 @@ test('runReplayScriptFile delegates Android directional swipes and preserves per
 
   assert.equal(response.ok, true);
   assert.deepEqual(
-    calls.map((call) => [call.command, call.positionals]),
+    calls.map((call) => [call.command, call.input]),
     [
-      ['gesture', ['swipe', 'left', '300']],
-      ['snapshot', []],
-      ['swipe', ['360', '400', '40', '400', '300']],
+      ['gesture', { kind: 'swipe', preset: 'left', durationMs: 300 }],
+      ['snapshot', undefined],
+      ['swipe', { from: { x: 360, y: 400 }, to: { x: 40, y: 400 }, durationMs: 300 }],
     ],
   );
 });
diff --git a/src/daemon/handlers/interaction-common.ts b/src/daemon/handlers/interaction-common.ts
index 218b9abf9..96968d836 100644
--- a/src/daemon/handlers/interaction-common.ts
+++ b/src/daemon/handlers/interaction-common.ts
@@ -34,6 +34,7 @@ export function finalizeTouchInteraction(params: {
   sessionStore: SessionStore;
   command: string;
   positionals: string[];
+  actionCommand?: string;
   retryPositionals?: string[];
   flags: CommandFlags | undefined;
   result: Record<string, unknown>;
@@ -49,6 +50,7 @@ export function finalizeTouchInteraction(params: {
     sessionStore,
     command,
     positionals,
+    actionCommand = command,
     retryPositionals,
     flags,
     result,
@@ -75,13 +77,17 @@ export function finalizeTouchInteraction(params: {
     flags,
     preSnapshot: session.snapshot,
   });
-  if (isNavigationSensitiveAction(command)) {
-    markAndroidSnapshotFreshness(session, command, androidFreshnessBaseline ?? session.snapshot);
+  if (isNavigationSensitiveAction(actionCommand)) {
+    markAndroidSnapshotFreshness(
+      session,
+      actionCommand,
+      androidFreshnessBaseline ?? session.snapshot,
+    );
   }
-  markPostGestureStabilization(session, command, retryPositionals ?? positionals, flags);
+  markPostGestureStabilization(session, actionCommand, retryPositionals ?? positionals, flags);
   recordTouchVisualizationEvent(
     session,
-    command,
+    actionCommand,
     positionals,
     result,
     (actionFlags ?? {}) as Record<string, unknown>,
diff --git a/src/daemon/handlers/interaction-gesture.ts b/src/daemon/handlers/interaction-gesture.ts
new file mode 100644
index 000000000..e057f8e73
--- /dev/null
+++ b/src/daemon/handlers/interaction-gesture.ts
@@ -0,0 +1,267 @@
+import { readGesturePayload, type GesturePayload } from '../../contracts/gesture-input.ts';
+import {
+  gesturePayloadToPositionals,
+  normalizePublicGesture,
+  normalizePublicSwipeMotion,
+  type GestureDeprecation,
+  type SwipePayload,
+} from '../../contracts/gesture-normalization.ts';
+import { requireGestureSupported } from '../../core/capabilities.ts';
+import { GESTURE_FLING_DURATION_MS } from '../../contracts/gesture-plan.ts';
+import {
+  SWIPE_PAUSE_MAX_MS,
+  SWIPE_REPETITION_MAX,
+  SWIPE_SERIES_MAX_SCHEDULED_DURATION_MS,
+} from '../../contracts/scroll-gesture.ts';
+import { AppError, normalizeError } from '../../kernel/errors.ts';
+import { readOptionalInteger } from '../../kernel/input-validation.ts';
+import type { Point } from '../../kernel/snapshot.ts';
+import { isActiveProviderDevice } from '../../provider-device-runtime.ts';
+import { sleep } from '../../utils/timeouts.ts';
+import type { DaemonResponse, SessionState } from '../types.ts';
+import { ensureAndroidBlockingSystemDialogReady } from '../android-system-dialog.ts';
+import type { InteractionHandlerParams } from './interaction-common.ts';
+import { finalizeTouchInteraction } from './interaction-common.ts';
+import { createInteractionRuntime } from './interaction-runtime.ts';
+import type { CaptureSnapshotForSession } from './interaction-snapshot.ts';
+import { noActiveSessionError } from './response.ts';
+
+type GestureHandlerParams = InteractionHandlerParams & {
+  captureSnapshotForSession: CaptureSnapshotForSession;
+};
+
+type GestureRuntime = ReturnType<typeof createInteractionRuntime>;
+type GestureRuntimeResult = Awaited<ReturnType<GestureRuntime['interactions']['gesture']>>;
+
+type GestureInteractionOutcome = {
+  positionals: string[];
+  flags: InteractionHandlerParams['req']['flags'];
+  responseData: Record<string, unknown>;
+  recordingResultExtra?: Record<string, unknown>;
+};
+
+export async function dispatchGestureViaRuntime(
+  params: GestureHandlerParams,
+): Promise<DaemonResponse> {
+  return await dispatchGestureInteraction(params, 'gesture', async (session) => {
+    const input = readGesturePayload(params.req.input);
+    const normalized = normalizePublicGesture(input);
+    requireGestureSupported(normalized.gesture, session.device);
+    const result = await createInteractionRuntime(params).interactions.gesture({
+      session: params.sessionName,
+      requestId: params.req.meta?.requestId,
+      gesture: normalized.gesture,
+    });
+    return {
+      positionals: gesturePayloadToPositionals(input),
+      flags: gestureReplayFlags(input, params.req.flags),
+      responseData: gestureResponseData(result, normalized.deprecations),
+      ...(input.kind === 'pinch' ? { recordingResultExtra: { scale: input.scale } } : {}),
+    };
+  });
+}
+
+export async function dispatchSwipeViaRuntime(
+  params: GestureHandlerParams,
+): Promise<DaemonResponse> {
+  return await dispatchGestureInteraction(params, 'swipe', async (session) => {
+    const input = readSwipeInput(params.req.input);
+    requireGestureSupported(normalizePublicSwipeMotion(input).gesture, session.device);
+    const count = input.count ?? 1;
+    const pauseMs = input.pauseMs ?? 0;
+    const pattern = input.pattern ?? 'one-way';
+    const runtime = createInteractionRuntime(params);
+    const result = await runSwipeRepetitions(runtime, params, input, count, pauseMs, pattern);
+    return {
+      positionals: swipeReplayPositionals(input),
+      flags: params.req.flags,
+      responseData: gestureResponseData(result, result.deprecations ?? [], {
+        from: input.from,
+        to: input.to,
+        x1: input.from.x,
+        y1: input.from.y,
+        x2: input.to.x,
+        y2: input.to.y,
+        effectiveDurationMs: result.durationMs,
+        timingMode: 'direct',
+        count,
+        pauseMs,
+        pattern,
+      }),
+    };
+  });
+}
+
+async function dispatchGestureInteraction(
+  params: GestureHandlerParams,
+  command: 'gesture' | 'swipe',
+  run: (session: SessionState) => Promise<GestureInteractionOutcome>,
+): Promise<DaemonResponse> {
+  const session = params.sessionStore.get(params.sessionName);
+  if (!session) return noActiveSessionError();
+  const actionStartedAt = Date.now();
+  try {
+    const providerDevice = isActiveProviderDevice(session.device);
+    const readiness = providerDevice
+      ? ({ status: 'clear' } as const)
+      : await ensureAndroidBlockingSystemDialogReady({
+          session,
+          command,
+          phase: 'before-command',
+        });
+    const outcome = await run(session);
+    if (!providerDevice) {
+      await ensureAndroidBlockingSystemDialogReady({
+        session,
+        command,
+        phase: 'after-command',
+      });
+    }
+    const responseData = { ...outcome.responseData };
+    if (readiness.status === 'recovered') {
+      const existingWarning =
+        typeof responseData.warning === 'string' ? `${responseData.warning} ` : '';
+      responseData.warning = `${existingWarning}${readiness.warning}`;
+    }
+    return finalizeTouchInteraction({
+      session,
+      sessionStore: params.sessionStore,
+      command,
+      actionCommand: command,
+      positionals: outcome.positionals,
+      flags: outcome.flags,
+      result: { ...responseData, ...(outcome.recordingResultExtra ?? {}) },
+      responseData,
+      actionStartedAt,
+      actionFinishedAt: Date.now(),
+    });
+  } catch (error) {
+    return { ok: false, error: normalizeError(error) };
+  }
+}
+
+function gestureResponseData(
+  result: GestureRuntimeResult,
+  deprecations: readonly GestureDeprecation[],
+  extra: Record<string, unknown> = {},
+): Record<string, unknown> {
+  return {
+    kind: result.kind,
+    durationMs: result.durationMs,
+    pointerCount: result.pointerCount,
+    from: result.from,
+    to: result.to,
+    ...(result.backendResult ?? {}),
+    ...extra,
+    ...(deprecations.length > 0 ? { deprecations } : {}),
+    message: result.message,
+  };
+}
+
+function readSwipeInput(input: unknown): SwipePayload {
+  if (!input || typeof input !== 'object' || Array.isArray(input)) {
+    throw new AppError('INVALID_ARGS', 'swipe requires structured object input');
+  }
+  const record = input as Record<string, unknown>;
+  const pattern = record.pattern;
+  if (pattern !== undefined && pattern !== 'one-way' && pattern !== 'ping-pong') {
+    throw new AppError('INVALID_ARGS', 'swipe pattern must be one-way or ping-pong');
+  }
+  const payload: SwipePayload = {
+    from: readSwipePoint(record.from, 'swipe from'),
+    to: readSwipePoint(record.to, 'swipe to'),
+    durationMs: readOptionalInteger(record, 'durationMs', { min: 16, max: 10_000 }),
+    count: readOptionalInteger(record, 'count', { min: 1, max: SWIPE_REPETITION_MAX }),
+    pauseMs: readOptionalInteger(record, 'pauseMs', { min: 0, max: SWIPE_PAUSE_MAX_MS }),
+    pattern,
+  };
+  assertSwipeSeriesFitsRequest(payload);
+  return payload;
+}
+
+function assertSwipeSeriesFitsRequest(input: SwipePayload): void {
+  const count = input.count ?? 1;
+  const pauseMs = input.pauseMs ?? 0;
+  const gestureDurationMs = input.durationMs ?? GESTURE_FLING_DURATION_MS;
+  const scheduledDurationMs = count * gestureDurationMs + Math.max(0, count - 1) * pauseMs;
+  if (scheduledDurationMs <= SWIPE_SERIES_MAX_SCHEDULED_DURATION_MS) return;
+  throw new AppError(
+    'INVALID_ARGS',
+    `Swipe series must fit within ${SWIPE_SERIES_MAX_SCHEDULED_DURATION_MS}ms.`,
+    {
+      count,
+      pauseMs,
+      gestureDurationMs,
+      scheduledDurationMs,
+      hint: 'Reduce --count, --pause-ms, or the deprecated swipe duration.',
+    },
+  );
+}
+
+function readSwipePoint(value: unknown, field: string): Point {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) {
+    throw new AppError('INVALID_ARGS', `${field} must be a point`);
+  }
+  const point = value as Record<string, unknown>;
+  if (typeof point.x !== 'number' || !Number.isFinite(point.x)) {
+    throw new AppError('INVALID_ARGS', `${field} x must be finite`);
+  }
+  if (typeof point.y !== 'number' || !Number.isFinite(point.y)) {
+    throw new AppError('INVALID_ARGS', `${field} y must be finite`);
+  }
+  return { x: point.x, y: point.y };
+}
+
+function swipeReplayPositionals(input: SwipePayload): string[] {
+  return [
+    String(input.from.x),
+    String(input.from.y),
+    String(input.to.x),
+    String(input.to.y),
+    ...(input.durationMs === undefined ? [] : [String(input.durationMs)]),
+  ];
+}
+
+async function runSwipeRepetitions(
+  runtime: ReturnType<typeof createInteractionRuntime>,
+  params: InteractionHandlerParams,
+  input: SwipePayload,
+  count: number,
+  pauseMs: number,
+  pattern: 'one-way' | 'ping-pong',
+) {
+  let result: Awaited<ReturnType<typeof runtime.interactions.gesture>> | undefined;
+  const deprecations = normalizePublicSwipeMotion(input).deprecations;
+  for (let index = 0; index < count; index += 1) {
+    const normalized = normalizePublicSwipeMotion(swipeMotionAtIndex(input, pattern, index));
+    result = await runtime.interactions.gesture({
+      session: params.sessionName,
+      requestId: params.req.meta?.requestId,
+      gesture: normalized.gesture,
+    });
+    if (pauseMs > 0 && index + 1 < count) await sleep(pauseMs);
+  }
+  if (!result) throw new Error('Swipe orchestration did not execute a gesture.');
+  return {
+    ...result,
+    ...(deprecations.length > 0 ? { deprecations } : {}),
+  };
+}
+
+function swipeMotionAtIndex(
+  input: SwipePayload,
+  pattern: 'one-way' | 'ping-pong',
+  index: number,
+): SwipePayload {
+  const reverse = pattern === 'ping-pong' && index % 2 === 1;
+  if (!reverse) return input;
+  return { ...input, from: input.to, to: input.from };
+}
+
+function gestureReplayFlags(
+  input: GesturePayload,
+  flags: InteractionHandlerParams['req']['flags'],
+): InteractionHandlerParams['req']['flags'] {
+  if (input.kind !== 'pan' || input.pointerCount === undefined) return flags;
+  return { ...flags, pointerCount: input.pointerCount };
+}
diff --git a/src/daemon/handlers/interaction-runtime.ts b/src/daemon/handlers/interaction-runtime.ts
index 48b655687..50d83044f 100644
--- a/src/daemon/handlers/interaction-runtime.ts
+++ b/src/daemon/handlers/interaction-runtime.ts
@@ -1,4 +1,8 @@
-import { dispatchCommand } from '../../core/dispatch.ts';
+import {
+  dispatchCommand,
+  dispatchGesturePlan,
+  dispatchGestureViewport,
+} from '../../core/dispatch.ts';
 import { publicPlatformString } from '../../kernel/device.ts';
 import type {
   AgentDeviceBackend,
@@ -61,6 +65,11 @@ function createInteractionBackend(
         },
       ),
     }),
+    resolveGestureViewport: async () =>
+      await dispatchGestureViewport(
+        session.device,
+        params.contextFromFlags(req.flags, session.appBundleId, session.trace?.outPath),
+      ),
     tap: async (_context, point): Promise<BackendActionResult> =>
       toBackendActionResult(
         await dispatchCommand(
@@ -111,6 +120,14 @@ function createInteractionBackend(
           params.contextFromFlags(req.flags, session.appBundleId, session.trace?.outPath),
         ),
       ),
+    performGesture: async (_context, plan): Promise<BackendActionResult> =>
+      toBackendActionResult(
+        await dispatchGesturePlan(
+          session.device,
+          plan,
+          params.contextFromFlags(req.flags, session.appBundleId, session.trace?.outPath),
+        ),
+      ),
     typeText: async (_context, text): Promise<BackendActionResult> =>
       toBackendActionResult(
         await dispatchCommand(
diff --git a/src/daemon/handlers/interaction.ts b/src/daemon/handlers/interaction.ts
index 64d9ec849..b331fffdc 100644
--- a/src/daemon/handlers/interaction.ts
+++ b/src/daemon/handlers/interaction.ts
@@ -14,6 +14,7 @@ import {
   ensureAndroidBlockingSystemDialogReady,
   recoverAndroidBlockingSystemDialog,
 } from '../android-system-dialog.ts';
+import { dispatchGestureViaRuntime, dispatchSwipeViaRuntime } from './interaction-gesture.ts';
 
 export async function handleInteractionCommands(
   params: InteractionHandlerParams,
@@ -28,6 +29,16 @@ export async function handleInteractionCommands(
   }
 
   switch (params.req.command) {
+    case PUBLIC_COMMANDS.gesture:
+      return await dispatchGestureViaRuntime({
+        ...params,
+        captureSnapshotForSession,
+      });
+    case PUBLIC_COMMANDS.swipe:
+      return await dispatchSwipeViaRuntime({
+        ...params,
+        captureSnapshotForSession,
+      });
     case PUBLIC_COMMANDS.type:
       return await dispatchTypeViaRuntime({
         ...params,
diff --git a/src/daemon/handlers/session-replay-action-runtime.ts b/src/daemon/handlers/session-replay-action-runtime.ts
index ae0444b90..8a699fa30 100644
--- a/src/daemon/handlers/session-replay-action-runtime.ts
+++ b/src/daemon/handlers/session-replay-action-runtime.ts
@@ -14,6 +14,10 @@ import {
   type ReplayActionBlockInvoker,
 } from '../../replay/control-flow-runtime.ts';
 import { AppError, normalizeError } from '../../kernel/errors.ts';
+import {
+  gesturePayloadFromPositionals,
+  swipePayloadFromPositionals,
+} from '../../contracts/gesture-normalization.ts';
 
 type ReplayBaseRequest = Omit<DaemonRequest, 'command' | 'positionals'>;
 
@@ -169,11 +173,7 @@ async function invokeResolvedReplayAction(params: {
       invoke,
       invokeReplayAction,
     })) ??
-    (await invoke({
-      ...baseReq,
-      command: resolved.command,
-      positionals: resolved.positionals ?? [],
-    }));
+    (await invoke(buildReplayInteractionRequest(baseReq, resolved)));
   if (response.ok) {
     const outputEnv = readReplayOutputEnv(response.data);
     if (outputEnv) mergeReplayVarScopeValues(scope, outputEnv);
@@ -181,6 +181,34 @@ async function invokeResolvedReplayAction(params: {
   return response;
 }
 
+function buildReplayInteractionRequest(
+  baseReq: ReplayBaseRequest,
+  action: SessionAction,
+): DaemonRequest {
+  const positionals = action.positionals ?? [];
+  if (action.command === 'gesture') {
+    return {
+      ...baseReq,
+      command: action.command,
+      positionals: [],
+      input: gesturePayloadFromPositionals(positionals, baseReq.flags?.pointerCount),
+    };
+  }
+  if (action.command === 'swipe') {
+    return {
+      ...baseReq,
+      command: action.command,
+      positionals: [],
+      input: swipePayloadFromPositionals(positionals, {
+        count: baseReq.flags?.count,
+        pauseMs: baseReq.flags?.pauseMs,
+        pattern: baseReq.flags?.pattern,
+      }),
+    };
+  }
+  return { ...baseReq, command: action.command, positionals };
+}
+
 async function invokeReplayControl(params: {
   control: SessionAction['replayControl'] | undefined;
   baseReq: ReplayBaseRequest;
diff --git a/src/daemon/recording-gesture-events.ts b/src/daemon/recording-gesture-events.ts
new file mode 100644
index 000000000..bc14339f6
--- /dev/null
+++ b/src/daemon/recording-gesture-events.ts
@@ -0,0 +1,140 @@
+import type { RecordingGestureEvent } from './types.ts';
+import type { TouchReferenceFrame as ReferenceFrame } from './touch-reference-frame.ts';
+import { readRecordingNumber, resolveRecordingDurationMs } from './recording-values.ts';
+
+const DEFAULT_GESTURE_TRAVEL_DURATION_MS = 250;
+const DEFAULT_PINCH_DURATION_MS = 280;
+
+type SwipeTravelEventOptions = {
+  referenceFrame?: ReferenceFrame;
+  classifyBackSwipe?: boolean;
+};
+
+export function buildCanonicalGestureEvents(
+  positionals: string[],
+  result: Record<string, unknown>,
+  tMs: number,
+  gestureDurationMs: number,
+  referenceFrame?: ReferenceFrame,
+): RecordingGestureEvent[] {
+  switch (result.kind) {
+    case 'pan':
+    case 'fling':
+    case 'rotate':
+    case 'transform': {
+      const from = readPoint(result.from);
+      const to = readPoint(result.to);
+      if (!from || !to) return [];
+      const allowBackSwipeClassification =
+        (result.kind === 'pan' || result.kind === 'fling') &&
+        readRecordingNumber(result.pointerCount) !== 2;
+      return [
+        buildSwipeTravelEvent(
+          tMs,
+          from.x,
+          from.y,
+          to.x,
+          to.y,
+          resolveRecordingDurationMs(
+            gestureDurationMs,
+            [result.durationMs],
+            DEFAULT_GESTURE_TRAVEL_DURATION_MS,
+          ),
+          {
+            referenceFrame,
+            classifyBackSwipe: allowBackSwipeClassification,
+          },
+        ),
+      ];
+    }
+    case 'pinch': {
+      const center = readPoint(result.from);
+      const scale = readRecordingNumber(result.scale) ?? readRecordingNumber(positionals[1]);
+      if (!center || scale === undefined || scale <= 0) return [];
+      return [
+        {
+          kind: 'pinch',
+          tMs,
+          x: center.x,
+          y: center.y,
+          ...referenceFrame,
+          scale,
+          durationMs: resolveRecordingDurationMs(
+            gestureDurationMs,
+            [result.durationMs],
+            DEFAULT_PINCH_DURATION_MS,
+          ),
+        },
+      ];
+    }
+    default:
+      return [];
+  }
+}
+
+export function buildSwipeTravelEvent(
+  tMs: number,
+  x: number,
+  y: number,
+  x2: number,
+  y2: number,
+  durationMs: number,
+  options: SwipeTravelEventOptions = {},
+): RecordingGestureEvent {
+  const { referenceFrame, classifyBackSwipe = true } = options;
+  const kind = classifyBackSwipe ? classifySwipeKind(x, y, x2, y2, referenceFrame) : 'swipe';
+  if (kind === 'back-swipe') {
+    return {
+      kind,
+      tMs,
+      x,
+      y,
+      x2,
+      y2,
+      ...referenceFrame,
+      durationMs,
+      edge: resolveBackSwipeEdge(x, x2, referenceFrame),
+    };
+  }
+  return { kind, tMs, x, y, x2, y2, ...referenceFrame, durationMs };
+}
+
+function classifySwipeKind(
+  x1: number,
+  y1: number,
+  x2: number,
+  y2: number,
+  referenceFrame?: ReferenceFrame,
+): 'swipe' | 'back-swipe' {
+  if (!referenceFrame) return 'swipe';
+  const horizontalDistance = Math.abs(x2 - x1);
+  const verticalDistance = Math.abs(y2 - y1);
+  if (horizontalDistance <= verticalDistance * 1.25) return 'swipe';
+
+  const edgeInset = referenceFrame.referenceWidth * 0.08;
+  if (x1 <= edgeInset && x2 > x1) return 'back-swipe';
+  if (x1 >= referenceFrame.referenceWidth - edgeInset && x2 < x1) return 'back-swipe';
+  return 'swipe';
+}
+
+function resolveBackSwipeEdge(
+  startX: number,
+  endX: number,
+  referenceFrame?: ReferenceFrame,
+): 'left' | 'right' {
+  if (referenceFrame) {
+    const edgeInset = referenceFrame.referenceWidth * 0.08;
+    if (startX <= edgeInset) return 'left';
+    if (startX >= referenceFrame.referenceWidth - edgeInset) return 'right';
+  }
+  return endX >= startX ? 'left' : 'right';
+}
+
+function readPoint(value: unknown): { x: number; y: number } | undefined {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) return undefined;
+  const point = value as Record<string, unknown>;
+  const x = readRecordingNumber(point.x);
+  const y = readRecordingNumber(point.y);
+  if (x === undefined || y === undefined) return undefined;
+  return { x, y };
+}
diff --git a/src/daemon/recording-gestures.ts b/src/daemon/recording-gestures.ts
index 80726af7f..308aff93c 100644
--- a/src/daemon/recording-gestures.ts
+++ b/src/daemon/recording-gestures.ts
@@ -16,10 +16,11 @@ import {
   getSnapshotReferenceFrame,
   type TouchReferenceFrame as ReferenceFrame,
 } from './touch-reference-frame.ts';
+import { buildCanonicalGestureEvents, buildSwipeTravelEvent } from './recording-gesture-events.ts';
+import { readRecordingNumber, resolveRecordingDurationMs } from './recording-values.ts';
 
 const DEFAULT_TAP_GAP_MS = 90;
 const DEFAULT_SWIPE_DURATION_MS = 250;
-const DEFAULT_PINCH_DURATION_MS = 280;
 const DEFAULT_SCROLL_REFERENCE_FRAME: ReferenceFrame = {
   referenceWidth: 1000,
   referenceHeight: 1000,
@@ -39,28 +40,28 @@ export function recordTouchVisualizationEvent(
 
   const merged = { ...fallback, ...(result ?? {}) };
   const reportedDurationMs =
-    readNumber(merged.effectiveDurationMs) ?? readNumber(merged.durationMs);
+    readRecordingNumber(merged.effectiveDurationMs) ?? readRecordingNumber(merged.durationMs);
   const timingSource = {
     recordingStartedAt: recording.startedAt,
     gestureClockOriginAtMs: recording.gestureClockOriginAtMs,
     gestureClockOriginUptimeMs: recording.gestureClockOriginUptimeMs,
     runnerStartedAtUptimeMs:
       recording.platform === 'ios-device-runner' ? recording.runnerStartedAtUptimeMs : undefined,
-    gestureStartUptimeMs: readNumber(merged.gestureStartUptimeMs),
-    gestureEndUptimeMs: readNumber(merged.gestureEndUptimeMs),
+    gestureStartUptimeMs: readRecordingNumber(merged.gestureStartUptimeMs),
+    gestureEndUptimeMs: readRecordingNumber(merged.gestureEndUptimeMs),
     fallbackStartedAtMs: startedAtMs,
     fallbackFinishedAtMs: finishedAtMs,
   };
   const gestureDurationMs = resolveGestureDurationMs({
-    gestureStartUptimeMs: readNumber(merged.gestureStartUptimeMs),
-    gestureEndUptimeMs: readNumber(merged.gestureEndUptimeMs),
+    gestureStartUptimeMs: readRecordingNumber(merged.gestureStartUptimeMs),
+    gestureEndUptimeMs: readRecordingNumber(merged.gestureEndUptimeMs),
     reportedDurationMs,
     fallbackStartedAtMs: startedAtMs,
     fallbackFinishedAtMs: finishedAtMs,
   });
   const tMs =
     isIosFamily(session.device) &&
-    readNumber(merged.gestureStartUptimeMs) === undefined &&
+    readRecordingNumber(merged.gestureStartUptimeMs) === undefined &&
     shouldAnchorTapVisualizationNearCompletion(command, merged)
       ? resolveTapVisualizationOffsetMs({ ...timingSource, gestureDurationMs })
       : resolveGestureOffsetMs(timingSource);
@@ -104,12 +105,12 @@ export function augmentScrollVisualizationResult(
   const contentDirection = readDirection(merged.direction) ?? readDirection(positionals[0]);
   if (!contentDirection) return result;
 
-  const amountValue = readNumber(merged.amount) ?? readNumber(positionals[1]);
-  const pixelValue = readNumber(merged.pixels);
-  const durationMs = readNumber(merged.durationMs) ?? DEFAULT_SWIPE_DURATION_MS;
+  const amountValue = readRecordingNumber(merged.amount) ?? readRecordingNumber(positionals[1]);
+  const pixelValue = readRecordingNumber(merged.pixels);
+  const durationMs = readRecordingNumber(merged.durationMs) ?? DEFAULT_SWIPE_DURATION_MS;
   const explicitTravel = readTravelCoordinates(merged, []);
-  const explicitReferenceWidth = readNumber(merged.referenceWidth);
-  const explicitReferenceHeight = readNumber(merged.referenceHeight);
+  const explicitReferenceWidth = readRecordingNumber(merged.referenceWidth);
+  const explicitReferenceHeight = readRecordingNumber(merged.referenceHeight);
   const fallbackReferenceFrame =
     explicitReferenceWidth !== undefined &&
     explicitReferenceWidth > 0 &&
@@ -198,10 +199,8 @@ const gestureEventBuilders: Record<string, GestureEventBuilder> = {
     buildFocusEvents(positionals, result, tMs, referenceFrame),
   longpress: buildLongPressEvents,
   scroll: buildScrollEvents,
-  pan: buildSwipeEvents,
-  fling: buildSwipeEvents,
+  gesture: buildCanonicalGestureEvents,
   swipe: buildSwipeEvents,
-  pinch: buildPinchEvents,
 };
 
 function shouldAnchorTapVisualizationNearCompletion(
@@ -214,9 +213,9 @@ function shouldAnchorTapVisualizationNearCompletion(
     case 'focus':
       return true;
     case 'press': {
-      const count = clampInt(readNumber(result.count), 1) ?? 1;
+      const count = clampInt(readRecordingNumber(result.count), 1) ?? 1;
       const doubleTap = result.doubleTap === true;
-      const holdMs = clampInt(readNumber(result.holdMs), 1);
+      const holdMs = clampInt(readRecordingNumber(result.holdMs), 1);
       return count === 1 && !doubleTap && holdMs === undefined;
     }
     case 'react-native':
@@ -236,10 +235,10 @@ function buildPressEvents(
   if (!coordinates) return [];
   const { x, y } = coordinates;
 
-  const count = clampInt(readNumber(result.count), 1) ?? 1;
-  const intervalMs = clampInt(readNumber(result.intervalMs), 0) ?? 0;
+  const count = clampInt(readRecordingNumber(result.count), 1) ?? 1;
+  const intervalMs = clampInt(readRecordingNumber(result.intervalMs), 0) ?? 0;
   const doubleTap = result.doubleTap === true;
-  const holdMs = clampInt(readNumber(result.holdMs), 1);
+  const holdMs = clampInt(readRecordingNumber(result.holdMs), 1);
   const events: RecordingGestureEvent[] = [];
 
   for (let index = 0; index < count; index += 1) {
@@ -278,9 +277,9 @@ function buildLongPressEvents(
   const coordinates = readCoordinates(result, positionals);
   if (!coordinates) return [];
   const { x, y } = coordinates;
-  const durationMs = resolveDurationMs(
+  const durationMs = resolveRecordingDurationMs(
     gestureDurationMs,
-    [readNumber(result.durationMs), readNumber(positionals[2])],
+    [readRecordingNumber(result.durationMs), readRecordingNumber(positionals[2])],
     800,
   );
   return [makeLongPressEvent(tMs, x, y, durationMs, referenceFrame)];
@@ -297,22 +296,24 @@ function buildSwipeEvents(
   if (!coordinates) return [];
   const { x1, y1, x2, y2 } = coordinates;
 
-  const durationMs = resolveDurationMs(
+  const durationMs = resolveRecordingDurationMs(
     gestureDurationMs,
     [
-      readNumber(result.effectiveDurationMs),
-      readNumber(result.durationMs),
-      readNumber(positionals[4]),
+      readRecordingNumber(result.effectiveDurationMs),
+      readRecordingNumber(result.durationMs),
+      readRecordingNumber(positionals[4]),
     ],
     DEFAULT_SWIPE_DURATION_MS,
   );
-  const count = clampInt(readNumber(result.count), 1) ?? 1;
-  const pauseMs = clampInt(readNumber(result.pauseMs), 0) ?? 0;
+  const count = clampInt(readRecordingNumber(result.count), 1) ?? 1;
+  const pauseMs = clampInt(readRecordingNumber(result.pauseMs), 0) ?? 0;
   const pattern = result.pattern === 'ping-pong' ? 'ping-pong' : 'one-way';
   return Array.from({ length: count }, (_, index) => {
     const { startX, startY, endX, endY } = resolveSwipePathForIndex(index, pattern, x1, y1, x2, y2);
     const startTime = tMs + index * (durationMs + pauseMs);
-    return buildSwipeTravelEvent(startTime, startX, startY, endX, endY, durationMs, referenceFrame);
+    return buildSwipeTravelEvent(startTime, startX, startY, endX, endY, durationMs, {
+      referenceFrame,
+    });
   });
 }
 
@@ -330,32 +331,6 @@ function resolveSwipePathForIndex(
     : { startX: x1, startY: y1, endX: x2, endY: y2 };
 }
 
-function buildSwipeTravelEvent(
-  tMs: number,
-  x: number,
-  y: number,
-  x2: number,
-  y2: number,
-  durationMs: number,
-  referenceFrame?: ReferenceFrame,
-): RecordingGestureEvent {
-  const kind = classifySwipeKind(x, y, x2, y2, referenceFrame);
-  if (kind === 'back-swipe') {
-    return {
-      kind,
-      tMs,
-      x,
-      y,
-      x2,
-      y2,
-      ...referenceFrame,
-      durationMs,
-      edge: resolveBackSwipeEdge(x, x2, referenceFrame),
-    };
-  }
-  return { kind, tMs, x, y, x2, y2, ...referenceFrame, durationMs };
-}
-
 function buildScrollEvents(
   positionals: string[],
   result: Record<string, unknown>,
@@ -371,9 +346,9 @@ function buildScrollEvents(
   }
   const { x1, y1, x2, y2 } = coordinates;
 
-  const durationMs = resolveDurationMs(gestureDurationMs, [], DEFAULT_SWIPE_DURATION_MS);
-  const amount = readNumber(result.amount) ?? readNumber(positionals[1]);
-  const pixels = readNumber(result.pixels);
+  const durationMs = resolveRecordingDurationMs(gestureDurationMs, [], DEFAULT_SWIPE_DURATION_MS);
+  const amount = readRecordingNumber(result.amount) ?? readRecordingNumber(positionals[1]);
+  const pixels = readRecordingNumber(result.pixels);
   return [
     {
       kind: 'scroll',
@@ -391,30 +366,6 @@ function buildScrollEvents(
   ];
 }
 
-function buildPinchEvents(
-  positionals: string[],
-  result: Record<string, unknown>,
-  tMs: number,
-  gestureDurationMs: number,
-  referenceFrame?: ReferenceFrame,
-): RecordingGestureEvent[] {
-  const coordinates = readCoordinates(result, positionals, 1);
-  const scale = readNumber(result.scale) ?? readNumber(positionals[0]);
-  if (!coordinates || scale === undefined || scale <= 0) return [];
-  const { x, y } = coordinates;
-  return [
-    {
-      kind: 'pinch',
-      tMs,
-      x,
-      y,
-      ...referenceFrame,
-      scale,
-      durationMs: resolveDurationMs(gestureDurationMs, [], DEFAULT_PINCH_DURATION_MS),
-    },
-  ];
-}
-
 function makeTapEvent(
   tMs: number,
   x: number,
@@ -434,43 +385,12 @@ function makeLongPressEvent(
   return { kind: 'longpress', tMs, x, y, ...referenceFrame, durationMs };
 }
 
-function classifySwipeKind(
-  x1: number,
-  y1: number,
-  x2: number,
-  y2: number,
-  referenceFrame?: ReferenceFrame,
-): 'swipe' | 'back-swipe' {
-  if (!referenceFrame) return 'swipe';
-  const horizontalDistance = Math.abs(x2 - x1);
-  const verticalDistance = Math.abs(y2 - y1);
-  if (horizontalDistance <= verticalDistance * 1.25) return 'swipe';
-
-  const edgeInset = referenceFrame.referenceWidth * 0.08;
-  if (x1 <= edgeInset && x2 > x1) return 'back-swipe';
-  if (x1 >= referenceFrame.referenceWidth - edgeInset && x2 < x1) return 'back-swipe';
-  return 'swipe';
-}
-
-function resolveBackSwipeEdge(
-  startX: number,
-  endX: number,
-  referenceFrame?: ReferenceFrame,
-): 'left' | 'right' {
-  if (referenceFrame) {
-    const edgeInset = referenceFrame.referenceWidth * 0.08;
-    if (startX <= edgeInset) return 'left';
-    if (startX >= referenceFrame.referenceWidth - edgeInset) return 'right';
-  }
-  return endX >= startX ? 'left' : 'right';
-}
-
 function resolveEventReferenceFrame(
   snapshot: SnapshotState | undefined,
   result: Record<string, unknown>,
 ): ReferenceFrame | undefined {
-  const referenceWidth = readNumber(result.referenceWidth);
-  const referenceHeight = readNumber(result.referenceHeight);
+  const referenceWidth = readRecordingNumber(result.referenceWidth);
+  const referenceHeight = readRecordingNumber(result.referenceHeight);
   if (
     referenceWidth !== undefined &&
     referenceWidth > 0 &&
@@ -497,13 +417,6 @@ function readDirection(value: unknown): ScrollDirection | undefined {
   }
 }
 
-function readNumber(value: unknown): number | undefined {
-  if (typeof value === 'number' && Number.isFinite(value)) return value;
-  if (typeof value !== 'string' || value.trim().length === 0) return undefined;
-  const parsed = Number(value);
-  return Number.isFinite(parsed) ? parsed : undefined;
-}
-
 function clampInt(value: number | undefined, min: number): number | undefined {
   if (value === undefined) return undefined;
   const normalized = Math.floor(value);
@@ -515,8 +428,8 @@ function readCoordinates(
   positionals: string[],
   positionalOffset = 0,
 ): { x: number; y: number } | undefined {
-  const x = readNumber(result.x) ?? readNumber(positionals[positionalOffset]);
-  const y = readNumber(result.y) ?? readNumber(positionals[positionalOffset + 1]);
+  const x = readRecordingNumber(result.x) ?? readRecordingNumber(positionals[positionalOffset]);
+  const y = readRecordingNumber(result.y) ?? readRecordingNumber(positionals[positionalOffset + 1]);
   if (x === undefined || y === undefined) {
     return undefined;
   }
@@ -538,19 +451,5 @@ function readTravelCoordinates(
 }
 
 function readFirstNumber(...values: unknown[]): number | undefined {
-  return values.map(readNumber).find((value) => value !== undefined);
-}
-
-function resolveDurationMs(
-  gestureDurationMs: number,
-  candidates: Array<number | undefined>,
-  fallbackDurationMs: number,
-): number {
-  return (
-    clampInt(gestureDurationMs, 1) ??
-    candidates
-      .map((candidate) => clampInt(candidate, 1))
-      .find((candidate) => candidate !== undefined) ??
-    fallbackDurationMs
-  );
+  return values.map(readRecordingNumber).find((value) => value !== undefined);
 }
diff --git a/src/daemon/recording-values.ts b/src/daemon/recording-values.ts
new file mode 100644
index 000000000..9612e8d60
--- /dev/null
+++ b/src/daemon/recording-values.ts
@@ -0,0 +1,18 @@
+export function readRecordingNumber(value: unknown): number | undefined {
+  if (typeof value === 'number' && Number.isFinite(value)) return value;
+  if (typeof value !== 'string' || value.trim().length === 0) return undefined;
+  const parsed = Number(value);
+  return Number.isFinite(parsed) ? parsed : undefined;
+}
+
+export function resolveRecordingDurationMs(
+  gestureDurationMs: number,
+  candidates: readonly unknown[],
+  fallbackDurationMs: number,
+): number {
+  for (const value of [gestureDurationMs, ...candidates, fallbackDurationMs]) {
+    const durationMs = readRecordingNumber(value);
+    if (durationMs !== undefined && durationMs >= 1) return Math.floor(durationMs);
+  }
+  return fallbackDurationMs;
+}
diff --git a/src/daemon/request-generic-dispatch.ts b/src/daemon/request-generic-dispatch.ts
index 162d4fb58..d43ffcd93 100644
--- a/src/daemon/request-generic-dispatch.ts
+++ b/src/daemon/request-generic-dispatch.ts
@@ -1,5 +1,4 @@
 import { dispatchCommand, type CommandFlags } from '../core/dispatch.ts';
-import { GESTURE_SUBCOMMAND_ERROR } from '../command-catalog.ts';
 import { requireCommandSupported } from './handlers/response.ts';
 import { SessionStore } from './session-store.ts';
 import type { DaemonCommandContext } from './context.ts';
@@ -32,15 +31,6 @@ import {
   readScreenshotResultMetadata,
 } from '../utils/screenshot-density.ts';
 
-const GESTURE_PLATFORM_COMMANDS: Readonly<Record<string, string>> = {
-  pan: 'pan',
-  fling: 'fling',
-  swipe: 'swipe-preset',
-  pinch: 'pinch',
-  rotate: 'rotate-gesture',
-  transform: 'transform-gesture',
-};
-
 export async function dispatchGenericCommand(params: {
   req: DaemonRequest;
   session: SessionState;
@@ -54,17 +44,7 @@ export async function dispatchGenericCommand(params: {
   ) => DaemonCommandContext;
 }): Promise<DaemonResponse> {
   const { req, session, logPath, sessionStore, contextFromFlags } = params;
-  const commandResolution = resolveDispatchCommand(req);
-  if (!commandResolution.ok) {
-    return {
-      ok: false,
-      error: {
-        code: 'INVALID_ARGS',
-        message: commandResolution.message,
-      },
-    };
-  }
-  const { platformCommand, dispatchRequest, recordedCommand } = commandResolution;
+  const platformCommand = req.command;
 
   const readinessResponse = await ensureGenericCommandReady(session, platformCommand);
   if (readinessResponse) return readinessResponse;
@@ -72,7 +52,7 @@ export async function dispatchGenericCommand(params: {
   if ('response' in preflightReadiness) return preflightReadiness.response;
 
   const { resolvedPositionals, resolvedOut, recordedPositionals, recordedFlags } =
-    resolveCommandPositionals(dispatchRequest);
+    resolveCommandPositionals(req);
 
   const actionStartedAt = Date.now();
   const dispatchContext = {
@@ -84,7 +64,7 @@ export async function dispatchGenericCommand(params: {
     sessionName: params.sessionName,
     logPath,
     command: platformCommand,
-    request: dispatchRequest,
+    request: req,
     positionals: resolvedPositionals,
     out: resolvedOut,
     dispatchContext,
@@ -105,18 +85,13 @@ export async function dispatchGenericCommand(params: {
   }
 
   const actionFinishedAt = Date.now();
-  const actionRecordedPositionals =
-    recordedCommand === platformCommand ? recordedPositionals : (req.positionals ?? []);
-  const actionRecordedFlags =
-    recordedCommand === platformCommand ? recordedFlags : (req.flags ?? {});
   recordVisualizationAndAction({
     session,
     sessionStore,
     command: platformCommand,
-    recordedCommand,
     resolvedPositionals,
-    recordedPositionals: actionRecordedPositionals,
-    recordedFlags: actionRecordedFlags,
+    recordedPositionals,
+    recordedFlags,
     data,
     actionStartedAt,
     actionFinishedAt,
@@ -234,49 +209,6 @@ async function executeScreenshotPlatformCommand(params: {
   return data;
 }
 
-type DispatchCommandResolution =
-  | {
-      ok: true;
-      platformCommand: string;
-      dispatchRequest: DaemonRequest;
-      recordedCommand: string;
-    }
-  | { ok: false; message: string };
-
-function resolveDispatchCommand(req: DaemonRequest): DispatchCommandResolution {
-  if (
-    req.command === 'pan' ||
-    req.command === 'fling' ||
-    req.command === 'rotate-gesture' ||
-    req.command === 'transform-gesture'
-  ) {
-    return {
-      ok: false,
-      message:
-        'Use gesture pan, gesture fling, gesture swipe, gesture rotate, or gesture transform.',
-    };
-  }
-  if (req.command !== 'gesture') {
-    return {
-      ok: true,
-      platformCommand: req.command,
-      dispatchRequest: req,
-      recordedCommand: req.command,
-    };
-  }
-  const [subcommand, ...positionals] = req.positionals ?? [];
-  const platformCommand = subcommand ? GESTURE_PLATFORM_COMMANDS[subcommand] : undefined;
-  if (!platformCommand) {
-    return { ok: false, message: GESTURE_SUBCOMMAND_ERROR };
-  }
-  return {
-    ok: true,
-    platformCommand,
-    dispatchRequest: { ...req, command: platformCommand, positionals },
-    recordedCommand: req.command,
-  };
-}
-
 function resolveScreenshotOutputPlacement(req: DaemonRequest): ScreenshotOutputPlacement {
   if (req.command !== 'screenshot') return 'default';
   if ((req.positionals ?? [])[0]) return 'positional';
@@ -367,7 +299,6 @@ function recordVisualizationAndAction(params: {
   session: SessionState;
   sessionStore: SessionStore;
   command: string;
-  recordedCommand: string;
   resolvedPositionals: string[];
   recordedPositionals: string[];
   recordedFlags: Record<string, unknown>;
@@ -380,7 +311,6 @@ function recordVisualizationAndAction(params: {
     session,
     sessionStore,
     command,
-    recordedCommand,
     resolvedPositionals,
     recordedPositionals,
     recordedFlags,
@@ -405,7 +335,7 @@ function recordVisualizationAndAction(params: {
     actionFinishedAt,
   );
   sessionStore.recordAction(session, {
-    command: recordedCommand,
+    command,
     positionals: recordedPositionals,
     flags: recordedFlags,
     result: data ?? {},
diff --git a/src/daemon/server/http-server.ts b/src/daemon/server/http-server.ts
index ef3f61b73..feeeff020 100644
--- a/src/daemon/server/http-server.ts
+++ b/src/daemon/server/http-server.ts
@@ -168,6 +168,7 @@ function toDaemonRequest(params: CommandRpcParams, headers: IncomingHttpHeaders)
     session: params.session ?? 'default',
     command: params.command ?? '',
     positionals: params.positionals ?? [],
+    input: params.input,
     // flags/runtime/meta are validated as objects at the boundary; their full shape is
     // validated in the session open handler downstream.
     flags: params.flags as DaemonRequest['flags'],
diff --git a/src/daemon/session-action-recorder.ts b/src/daemon/session-action-recorder.ts
index a63c332cc..300c4e957 100644
--- a/src/daemon/session-action-recorder.ts
+++ b/src/daemon/session-action-recorder.ts
@@ -73,6 +73,7 @@ const SANITIZED_FLAG_KEYS = [
   'quality',
   'hideTouches',
   'count',
+  'pointerCount',
   'intervalMs',
   'delayMs',
   'holdMs',
diff --git a/src/kernel/contracts.ts b/src/kernel/contracts.ts
index 3b590b988..f0dc07f01 100644
--- a/src/kernel/contracts.ts
+++ b/src/kernel/contracts.ts
@@ -104,6 +104,7 @@ export type DaemonRequest = {
   session?: string;
   command: string;
   positionals: string[];
+  input?: Record<string, unknown>;
   flags?: Record<string, unknown>;
   runtime?: SessionRuntimeHints;
   meta?: DaemonRequestMeta;
@@ -377,6 +378,7 @@ export const commandRpcParamsSchema = schema<CommandRpcParams>((input, path) =>
     session: optionalString(record, 'session', path),
     command: optionalString(record, 'command', path),
     positionals: optionalStringArray(record, 'positionals', path),
+    input: optionalObject(record, 'input', path),
     flags: optionalObject(record, 'flags', path),
     runtime: optionalObject(record, 'runtime', path) as SessionRuntimeHints | undefined,
     meta: optionalObject(record, 'meta', path) as DaemonRequestMeta | undefined,
diff --git a/src/kernel/device.ts b/src/kernel/device.ts
index cb29835d3..782c62e8f 100644
--- a/src/kernel/device.ts
+++ b/src/kernel/device.ts
@@ -132,6 +132,16 @@ export function isTvOsDevice(device: Pick<DeviceInfo, 'platform' | 'target'>): b
   return isApplePlatform(device.platform) && device.target === 'tv';
 }
 
+/** Resolve the stored Apple OS, preserving legacy target/leaf inference for old device records. */
+export function resolveDeviceAppleOs(
+  device: Pick<DeviceInfo, 'platform' | 'target' | 'appleOs'>,
+): AppleOS {
+  if (device.appleOs) return device.appleOs;
+  if ((device.platform as string) === 'macos') return 'macos';
+  if (isTvOsDevice(device)) return 'tvos';
+  return 'ios';
+}
+
 export function isPlatform(value: unknown): value is Platform {
   // Internal device-platform membership derived from the canonical PLATFORMS tuple.
   return (PLATFORMS as readonly unknown[]).includes(value);
diff --git a/src/kernel/input-validation.ts b/src/kernel/input-validation.ts
new file mode 100644
index 000000000..5ded6f127
--- /dev/null
+++ b/src/kernel/input-validation.ts
@@ -0,0 +1,21 @@
+import { AppError } from './errors.ts';
+
+export function readOptionalInteger(
+  record: Record<string, unknown>,
+  key: string,
+  options: { min?: number; max?: number } = {},
+): number | undefined {
+  const value = record[key];
+  if (value === undefined) return undefined;
+  if (!Number.isInteger(value)) {
+    throw new AppError('INVALID_ARGS', `Expected ${key} to be an integer.`);
+  }
+  const numberValue = value as number;
+  if (options.min !== undefined && numberValue < options.min) {
+    throw new AppError('INVALID_ARGS', `Expected ${key} to be at least ${options.min}.`);
+  }
+  if (options.max !== undefined && numberValue > options.max) {
+    throw new AppError('INVALID_ARGS', `Expected ${key} to be at most ${options.max}.`);
+  }
+  return numberValue;
+}
diff --git a/src/mcp/__tests__/command-tools.test.ts b/src/mcp/__tests__/command-tools.test.ts
index e3a803bb8..ac5895679 100644
--- a/src/mcp/__tests__/command-tools.test.ts
+++ b/src/mcp/__tests__/command-tools.test.ts
@@ -131,6 +131,76 @@ test('MCP tool schemas add MCP client config fields at the MCP boundary', () =>
   );
 });
 
+test('MCP gesture tool exposes and forwards two-finger pan topology', async () => {
+  const gesture = listCommandTools().find((tool) => tool.name === 'gesture');
+  assert.ok(gesture);
+  assert.deepEqual(gesture.inputSchema.properties?.pointerCount, {
+    type: 'integer',
+    description: 'Pan touch pointer count (1 or 2).',
+    minimum: 1,
+    maximum: 2,
+  });
+
+  const calls: unknown[] = [];
+  const executor = createCommandToolExecutor({
+    createClient: () => ({}) as AgentDeviceClient,
+    runCommand: async (_client, name, input) => {
+      calls.push({ name, input });
+      return { message: 'Panned' };
+    },
+  });
+  await executor.execute('gesture', {
+    kind: 'pan',
+    origin: { x: 100, y: 200 },
+    delta: { x: 40, y: -20 },
+    pointerCount: 2,
+  });
+
+  assert.deepEqual(calls, [
+    {
+      name: 'gesture',
+      input: {
+        kind: 'pan',
+        origin: { x: 100, y: 200 },
+        delta: { x: 40, y: -20 },
+        pointerCount: 2,
+      },
+    },
+  ]);
+});
+
+test('MCP gesture compatibility metadata accepts numeric rotate velocity', () => {
+  const gesture = listCommandTools().find((tool) => tool.name === 'gesture');
+  assert.ok(gesture);
+  assert.deepEqual(gesture.inputSchema.properties?.velocity, {
+    type: 'number',
+    description: 'Deprecated: rotation pacing is derived from degrees; must be non-zero.',
+  });
+  assert.deepEqual(gesture.inputSchema.properties?.durationMs, {
+    type: 'integer',
+    description: 'Pan/transform duration. Deprecated on swipe/fling; timed movement is a pan.',
+    minimum: 16,
+    maximum: 10_000,
+  });
+});
+
+test('MCP swipe tool exposes bounded repetition inputs', () => {
+  const swipe = listCommandTools().find((tool) => tool.name === 'swipe');
+  assert.ok(swipe);
+  assert.deepEqual(swipe.inputSchema.properties?.count, {
+    type: 'integer',
+    description: 'Number of swipe repetitions.',
+    minimum: 1,
+    maximum: 200,
+  });
+  assert.deepEqual(swipe.inputSchema.properties?.pauseMs, {
+    type: 'integer',
+    description: 'Pause between repeated swipes.',
+    minimum: 0,
+    maximum: 10_000,
+  });
+});
+
 test('MCP includeCost:true opts into agent-cost: sets client.cost, strips the arg, surfaces cost', async () => {
   const createdConfigs: unknown[] = [];
   const calls: unknown[] = [];
diff --git a/src/platforms/android/__tests__/multitouch-helper-install.test.ts b/src/platforms/android/__tests__/multitouch-helper-install.test.ts
index 4d3e98327..5f270b1e3 100644
--- a/src/platforms/android/__tests__/multitouch-helper-install.test.ts
+++ b/src/platforms/android/__tests__/multitouch-helper-install.test.ts
@@ -15,6 +15,44 @@ beforeEach(() => {
   resetAndroidMultiTouchHelperInstallCache();
 });
 
+test('helper install uses replace and test-package semantics', async () => {
+  const fixture = await makeInstallFixture('helper-apk');
+  const installCalls: unknown[] = [];
+  const adb: AndroidAdbExecutor = async (args) => {
+    if (args.includes('--show-versioncode')) {
+      return { exitCode: 1, stdout: '', stderr: 'not found' };
+    }
+    throw new Error(`unexpected adb call: ${args.join(' ')}`);
+  };
+  const provider: AndroidAdbProvider = {
+    exec: adb,
+    install: async (installedPath, options) => {
+      installCalls.push({ installedPath, options });
+      return { exitCode: 0, stdout: '', stderr: '' };
+    },
+  };
+
+  const result = await ensureAndroidMultiTouchHelper({
+    adb,
+    adbProvider: provider,
+    artifact: fixture.artifact,
+    deviceKey: 'android:emulator-5554',
+  });
+
+  assert.equal(result.reason, 'missing');
+  assert.deepEqual(installCalls, [
+    {
+      installedPath: fixture.artifact.apkPath,
+      options: {
+        replace: true,
+        allowTestPackages: true,
+        allowFailure: true,
+        timeoutMs: 30_000,
+      },
+    },
+  ]);
+});
+
 test('same-version helper is current only when installed APK bytes match', async () => {
   const fixture = await makeInstallFixture('current-helper');
   const { adb, provider, pulls, installs } = makeInstalledHelperDevice({
diff --git a/src/platforms/android/__tests__/multitouch-helper-ownership.test.ts b/src/platforms/android/__tests__/multitouch-helper-ownership.test.ts
index ea550192e..1a08c77b8 100644
--- a/src/platforms/android/__tests__/multitouch-helper-ownership.test.ts
+++ b/src/platforms/android/__tests__/multitouch-helper-ownership.test.ts
@@ -1,10 +1,11 @@
 import assert from 'node:assert/strict';
 import { beforeEach, test, vi } from 'vitest';
 import { ANDROID_EMULATOR } from '../../../__tests__/test-utils/index.ts';
+import { buildGesturePlan } from '../../../contracts/gesture-plan.ts';
 import { withAndroidAdbProvider } from '../adb-executor.ts';
 import {
+  performGestureAndroid,
   resetAndroidMultiTouchHelperInstallCache,
-  swipeGestureAndroid,
 } from '../multitouch-helper.ts';
 import { stopAndroidSnapshotHelperSessionForDevice } from '../snapshot-helper.ts';
 import {
@@ -72,13 +73,20 @@ test('helper gesture releases persistent snapshot instrumentation before touch i
     },
     { serial: ANDROID_EMULATOR.id },
     async () =>
-      await swipeGestureAndroid(ANDROID_EMULATOR, {
-        x1: 340,
-        y1: 400,
-        x2: 60,
-        y2: 400,
-        durationMs: 300,
-      }),
+      await performGestureAndroid(
+        ANDROID_EMULATOR,
+        buildGesturePlan(
+          {
+            intent: 'pan',
+            pointerCount: 1,
+            origin: { x: 340, y: 400 },
+            delta: { x: -280, y: 0 },
+            durationMs: 300,
+          },
+          { x: 0, y: 0, width: 400, height: 800 },
+          'android',
+        ),
+      ),
   );
 
   assert.equal(result?.backend, 'android-multitouch-helper');
diff --git a/src/platforms/android/__tests__/multitouch-helper.test.ts b/src/platforms/android/__tests__/multitouch-helper.test.ts
index 0b7c3dfd1..2389a933c 100644
--- a/src/platforms/android/__tests__/multitouch-helper.test.ts
+++ b/src/platforms/android/__tests__/multitouch-helper.test.ts
@@ -1,134 +1,192 @@
 import assert from 'node:assert/strict';
-import crypto from 'node:crypto';
-import { promises as fs } from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
 import { beforeEach, test } from 'vitest';
 import { ANDROID_EMULATOR } from '../../../__tests__/test-utils/index.ts';
+import { buildGesturePlan } from '../../../contracts/gesture-plan.ts';
 import {
-  ensureAndroidMultiTouchHelper,
+  normalizeAndroidMultiTouchHelperGestureRequest,
   parseAndroidMultiTouchHelperOutput,
+  performGestureAndroid,
+  readAndroidGestureViewport,
   resetAndroidMultiTouchHelperInstallCache,
-  rotateGestureAndroid,
   runAndroidMultiTouchHelperGesture,
-  swipeGestureAndroid,
+  parseAndroidGestureViewportResult,
 } from '../multitouch-helper.ts';
-import {
-  withAndroidAdbProvider,
-  type AndroidAdbExecutor,
-  type AndroidAdbProvider,
-} from '../adb-executor.ts';
+import { createAndroidInteractor } from '../../../core/interactors/android.ts';
+import { withAndroidAdbProvider } from '../adb-executor.ts';
 import {
   ANDROID_MULTITOUCH_HELPER_MANIFEST as manifest,
   androidMultiTouchResultRecord as resultRecord,
 } from './multitouch-helper.fixtures.ts';
 
-beforeEach(() => {
-  resetAndroidMultiTouchHelperInstallCache();
+const viewport = { x: 0, y: 0, width: 400, height: 800 };
+
+beforeEach(resetAndroidMultiTouchHelperInstallCache);
+
+test('helper response parsing returns instrumentation evidence', () => {
+  assert.deepEqual(
+    parseAndroidMultiTouchHelperOutput(
+      [
+        resultRecord({
+          ok: 'true',
+          kind: 'transform',
+          helperApiVersion: '1',
+          injectedEvents: '24',
+          elapsedMs: '315',
+        }),
+        'INSTRUMENTATION_CODE: 0',
+      ].join('\n'),
+    ),
+    {
+      helperKind: 'transform',
+      helperApiVersion: '1',
+      injectedEvents: 24,
+      elapsedMs: 315,
+    },
+  );
 });
 
-test('parseAndroidMultiTouchHelperOutput returns final instrumentation gesture metadata', () => {
-  const parsed = parseAndroidMultiTouchHelperOutput(
-    [
-      resultRecord({
-        ok: 'true',
-        kind: 'pinch',
-        helperApiVersion: '1',
-        injectedEvents: '24',
-        elapsedMs: '315',
-      }),
-      'INSTRUMENTATION_CODE: 0',
-    ].join('\n'),
+test('canonical plans lower to exact helper samples without semantic geometry', () => {
+  const pan = buildGesturePlan(
+    {
+      intent: 'pan',
+      pointerCount: 2,
+      origin: { x: 200, y: 300 },
+      delta: { x: 20, y: 10 },
+      durationMs: 32,
+    },
+    viewport,
   );
+  const request = normalizeAndroidMultiTouchHelperGestureRequest(pan);
 
-  assert.deepEqual(parsed, {
-    kind: 'pinch',
-    helperApiVersion: '1',
-    injectedEvents: 24,
-    elapsedMs: 315,
-  });
+  assert.ok('pointers' in request);
+  assert.equal(request.kind, 'transform');
+  assert.equal(request.durationMs, 32);
+  assert.deepEqual(
+    request.pointers,
+    pan.pointers.map((pointer) => ({
+      pointerId: pointer.pointerId,
+      samples: pointer.samples.map(({ offsetMs, point }) => ({
+        offsetMs,
+        x: point.x,
+        y: point.y,
+      })),
+    })),
+  );
+  assert.equal('scale' in request, false);
+  assert.equal('degrees' in request, false);
+  assert.equal('dx' in request, false);
 });
 
-test('runAndroidMultiTouchHelperGesture encodes protocol payload for instrumentation', async () => {
-  let capturedArgs: string[] | undefined;
-  let capturedOptions: Parameters<AndroidAdbExecutor>[1];
-  const result = await runAndroidMultiTouchHelperGesture({
+test('single-pointer plans use the same exact helper protocol', () => {
+  const fling = buildGesturePlan(
+    { intent: 'fling', from: { x: 300, y: 400 }, to: { x: 100, y: 400 } },
+    viewport,
+  );
+  const request = normalizeAndroidMultiTouchHelperGestureRequest(fling);
+  assert.equal(request.kind, 'swipe');
+  assert.equal(request.pointers.length, 1);
+  assert.equal(request.durationMs, 100);
+});
+
+test('transform sends the planner-owned choreography without regenerating geometry', async () => {
+  const plan = buildGesturePlan(
+    {
+      intent: 'transform',
+      origin: { x: 200, y: 300 },
+      delta: { x: 20, y: 10 },
+      scale: 1.2,
+      degrees: 10,
+      durationMs: 32,
+    },
+    viewport,
+  );
+  const request = normalizeAndroidMultiTouchHelperGestureRequest(plan);
+  assert.equal(request.kind, 'transform');
+  assert.deepEqual(
+    request.pointers,
+    plan.pointers.map((pointer) => ({
+      pointerId: pointer.pointerId,
+      samples: pointer.samples.map(({ offsetMs, point }) => ({
+        offsetMs,
+        x: point.x,
+        y: point.y,
+      })),
+    })),
+  );
+  let payload: Record<string, unknown> | undefined;
+  await runAndroidMultiTouchHelperGesture({
     adb: async (args, options) => {
-      capturedArgs = args;
-      capturedOptions = options;
+      payload = JSON.parse(Buffer.from(args[6]!, 'base64').toString('utf8'));
+      assert.equal(options?.timeoutMs, 45_000);
       return {
         exitCode: 0,
-        stdout: [resultRecord({ ok: 'true', kind: 'rotate' }), 'INSTRUMENTATION_CODE: 0'].join(
+        stdout: [resultRecord({ ok: 'true', kind: 'transform' }), 'INSTRUMENTATION_CODE: 0'].join(
           '\n',
         ),
         stderr: '',
       };
     },
-    request: { kind: 'rotate', x: 100, y: 200, degrees: 145, radius: 120, durationMs: 250 },
+    request,
     packageName: manifest.packageName,
     instrumentationRunner: manifest.instrumentationRunner,
   });
-
-  assert.equal(result.kind, 'rotate');
-  assert.ok(capturedArgs);
-  assert.deepEqual(capturedArgs.slice(0, 7), [
-    'shell',
-    'am',
-    'instrument',
-    '-w',
-    '-e',
-    'payloadBase64',
-    capturedArgs[6],
-  ]);
-  assert.deepEqual(JSON.parse(Buffer.from(capturedArgs[6]!, 'base64').toString('utf8')), {
-    protocol: 'android-multitouch-helper-v1',
-    kind: 'rotate',
-    x: 100,
-    y: 200,
-    degrees: 145,
-    radius: 120,
-    durationMs: 250,
-  });
-  assert.equal(capturedArgs.at(-1), manifest.instrumentationRunner);
-  assert.equal(capturedOptions?.timeoutMs, 45_000);
+  assert.deepEqual(payload, { protocol: 'android-multitouch-helper-v1', ...request });
 });
 
-test('runAndroidMultiTouchHelperGesture encodes one-finger swipe payloads', async () => {
-  let capturedPayload: Record<string, unknown> | undefined;
-  const result = await runAndroidMultiTouchHelperGesture({
-    adb: async (args) => {
-      capturedPayload = JSON.parse(Buffer.from(args[6]!, 'base64').toString('utf8'));
-      return {
-        exitCode: 0,
-        stdout: [resultRecord({ ok: 'true', kind: 'swipe' }), 'INSTRUMENTATION_CODE: 0'].join('\n'),
-        stderr: '',
-      };
+test('provider-native touch receives the plan as its only source of truth', async () => {
+  const plan = buildGesturePlan(
+    { intent: 'pinch', origin: { x: 200, y: 300 }, scale: 1.5 },
+    viewport,
+  );
+  const calls: unknown[] = [];
+  const result = await withAndroidAdbProvider(
+    {
+      exec: async () => {
+        throw new Error('adb must not run');
+      },
+      touch: async (request) => {
+        calls.push(request);
+        return { injected: true };
+      },
     },
-    request: { kind: 'swipe', x1: 340, y1: 400, x2: 60, y2: 400, durationMs: 300 },
-    packageName: manifest.packageName,
-    instrumentationRunner: manifest.instrumentationRunner,
-  });
-
-  assert.equal(result.kind, 'swipe');
-  assert.deepEqual(capturedPayload, {
-    protocol: 'android-multitouch-helper-v1',
-    kind: 'swipe',
-    x1: 340,
-    y1: 400,
-    x2: 60,
-    y2: 400,
-    durationMs: 300,
-  });
+    { serial: ANDROID_EMULATOR.id },
+    async () => await performGestureAndroid(ANDROID_EMULATOR, plan),
+  );
+  assert.deepEqual(calls, [plan]);
+  assert.deepEqual(result, { backend: 'provider-native-touch', injected: true });
 });
 
-test('parseAndroidMultiTouchHelperOutput distinguishes missing final results', () => {
-  assert.throws(() => parseAndroidMultiTouchHelperOutput('INSTRUMENTATION_CODE: 0'), {
-    code: 'ANDROID_MULTITOUCH_HELPER_NO_FINAL_RESULT',
-    message: 'Android multi-touch helper did not return a final result',
-  });
+test('provider-native failures propagate without adb single-pointer fallback', async () => {
+  const plan = buildGesturePlan(
+    { intent: 'fling', from: { x: 300, y: 400 }, to: { x: 100, y: 400 } },
+    viewport,
+  );
+  const adbCalls: string[][] = [];
+  await withAndroidAdbProvider(
+    {
+      exec: async (args) => {
+        adbCalls.push(args);
+        return { exitCode: 0, stdout: '', stderr: '' };
+      },
+      touch: async () => {
+        throw new Error('native touch failed');
+      },
+    },
+    { serial: ANDROID_EMULATOR.id },
+    async () => {
+      await assert.rejects(
+        () => performGestureAndroid(ANDROID_EMULATOR, plan),
+        /native touch failed/,
+      );
+    },
+  );
+  assert.deepEqual(adbCalls, []);
 });
 
-test('runAndroidMultiTouchHelperGesture preserves helper failure messages', async () => {
+test('helper failures remain structured and actionable', async () => {
+  const request = normalizeAndroidMultiTouchHelperGestureRequest(
+    buildGesturePlan({ intent: 'pinch', scale: 1.5 }, viewport),
+  );
   await assert.rejects(
     () =>
       runAndroidMultiTouchHelperGesture({
@@ -144,155 +202,69 @@ test('runAndroidMultiTouchHelperGesture preserves helper failure messages', asyn
           ].join('\n'),
           stderr: '',
         }),
-        request: { kind: 'pinch', x: 100, y: 200, scale: 1.5, radius: 120, durationMs: 250 },
+        request,
         packageName: manifest.packageName,
         instrumentationRunner: manifest.instrumentationRunner,
       }),
-    {
-      code: 'COMMAND_FAILED',
-      message: 'injectInputEvent returned false',
-    },
+    { code: 'COMMAND_FAILED', message: 'injectInputEvent returned false' },
   );
 });
 
-test('swipeGestureAndroid falls back to adb input swipe when helper path is unavailable', async () => {
-  const adbCalls: string[][] = [];
-  const result = await withAndroidAdbProvider(
-    {
-      exec: async (args) => {
-        adbCalls.push(args);
-        if (args.includes('--show-versioncode')) {
-          return {
-            exitCode: 0,
-            stdout: `package:${manifest.packageName} versionCode:999999`,
-            stderr: '',
-          };
-        }
-        if (args.includes('instrument')) {
-          return {
-            exitCode: 1,
-            stdout: [
-              resultRecord({
-                ok: 'false',
-                errorType: 'java.lang.IllegalStateException',
-                message: 'injectInputEvent returned false',
-              }),
-              'INSTRUMENTATION_CODE: 1',
-            ].join('\n'),
-            stderr: '',
-          };
-        }
-        if (args.join(' ') === 'shell input swipe 340 400 60 400 300') {
-          return { exitCode: 0, stdout: '', stderr: '' };
-        }
-        throw new Error(`unexpected adb call: ${args.join(' ')}`);
+test('gesture viewport result is typed and rejects invalid bounds', () => {
+  assert.deepEqual(
+    parseAndroidGestureViewportResult([
+      {
+        agentDeviceProtocol: 'android-multitouch-helper-v1',
+        ok: 'true',
+        x: '10',
+        y: '20',
+        width: '300',
+        height: '500',
       },
-    },
-    { serial: ANDROID_EMULATOR.id },
-    async () =>
-      await swipeGestureAndroid(ANDROID_EMULATOR, {
-        x1: 340,
-        y1: 400,
-        x2: 60,
-        y2: 400,
-        durationMs: 300,
-      }),
+    ]),
+    { x: 10, y: 20, width: 300, height: 500 },
   );
-
-  assert.deepEqual(result, { backend: 'adb-input-swipe-fallback' });
-  assert.ok(adbCalls.some((args) => args.join(' ') === 'shell input swipe 340 400 60 400 300'));
-});
-
-test('swipeGestureAndroid propagates provider-native failures without adb fallback', async () => {
-  const adbCalls: string[][] = [];
-  await withAndroidAdbProvider(
-    {
-      exec: async (args) => {
-        adbCalls.push(args);
-        return { exitCode: 0, stdout: '', stderr: '' };
-      },
-      touch: async () => {
-        throw new Error('native touch failed');
-      },
-    },
-    { serial: ANDROID_EMULATOR.id },
-    async () => {
-      await assert.rejects(
-        () =>
-          swipeGestureAndroid(ANDROID_EMULATOR, {
-            x1: 340,
-            y1: 400,
-            x2: 60,
-            y2: 400,
-            durationMs: 300,
-          }),
-        /native touch failed/,
-      );
-    },
+  assert.throws(
+    () =>
+      parseAndroidGestureViewportResult([
+        {
+          agentDeviceProtocol: 'android-multitouch-helper-v1',
+          ok: 'true',
+          x: '0',
+          y: '0',
+          width: '0',
+          height: '500',
+        },
+      ]),
+    { code: 'COMMAND_FAILED' },
   );
-
-  assert.deepEqual(adbCalls, []);
+  assert.throws(() => parseAndroidGestureViewportResult([]), { code: 'COMMAND_FAILED' });
 });
 
-test('rotateGestureAndroid rejects zero velocity before provider dispatch', async () => {
+test('provider gesture viewport bypasses local helper transport and is validated', async () => {
+  let calls = 0;
   await withAndroidAdbProvider(
     {
       exec: async () => {
-        throw new Error('adb should not run for invalid input');
+        throw new Error('adb must not run');
       },
-      touch: async () => {
-        throw new Error('native touch should not run for invalid input');
+      gestureViewport: async () => {
+        calls += 1;
+        return calls === 1 ? viewport : { ...viewport, width: 0 };
       },
     },
     { serial: ANDROID_EMULATOR.id },
     async () => {
-      await assert.rejects(
-        () => rotateGestureAndroid(ANDROID_EMULATOR, { degrees: 90, velocity: 0 }),
-        { code: 'INVALID_ARGS' },
-      );
+      assert.deepEqual(await readAndroidGestureViewport(ANDROID_EMULATOR), viewport);
+      await assert.rejects(readAndroidGestureViewport(ANDROID_EMULATOR), {
+        code: 'COMMAND_FAILED',
+      });
     },
   );
+  assert.equal(calls, 2);
 });
 
-test('ensureAndroidMultiTouchHelper installs with semantic provider install options', async () => {
-  const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'multitouch-helper-install-'));
-  const apkPath = path.join(tmpDir, 'helper.apk');
-  await fs.writeFile(apkPath, 'helper-apk');
-  const installCalls: Array<{
-    apkPath: string;
-    replace?: boolean;
-    allowTestPackages?: boolean;
-  }> = [];
-  const adb: AndroidAdbExecutor = async (args) => {
-    if (args.includes('--show-versioncode')) {
-      return { exitCode: 1, stdout: '', stderr: 'not found' };
-    }
-    throw new Error(`unexpected adb call: ${args.join(' ')}`);
-  };
-  const adbProvider: AndroidAdbProvider = {
-    exec: adb,
-    install: async (path, options) => {
-      installCalls.push({
-        apkPath: path,
-        replace: options?.replace,
-        allowTestPackages: options?.allowTestPackages,
-      });
-      return { exitCode: 0, stdout: '', stderr: '' };
-    },
-  };
-
-  const result = await ensureAndroidMultiTouchHelper({
-    adb,
-    adbProvider,
-    artifact: { apkPath, manifest: { ...manifest, sha256: sha256Text('helper-apk') } },
-    deviceKey: 'android:emulator-5554',
-  });
-
-  assert.equal(result.installed, true);
-  assert.equal(result.reason, 'missing');
-  assert.deepEqual(installCalls, [{ apkPath, replace: true, allowTestPackages: true }]);
+test('production Android interactor exposes the native gesture viewport seam', () => {
+  const interactor = createAndroidInteractor(ANDROID_EMULATOR);
+  assert.equal(typeof interactor.gestureViewport, 'function');
 });
-
-function sha256Text(text: string): string {
-  return crypto.createHash('sha256').update(text).digest('hex');
-}
diff --git a/src/platforms/android/adb-executor.ts b/src/platforms/android/adb-executor.ts
index 6cfaa0f33..852a24586 100644
--- a/src/platforms/android/adb-executor.ts
+++ b/src/platforms/android/adb-executor.ts
@@ -1,6 +1,8 @@
 import { AsyncLocalStorage } from 'node:async_hooks';
 import type { Readable, Writable } from 'node:stream';
 import type { DeviceInfo } from '../../kernel/device.ts';
+import type { Rect } from '../../kernel/snapshot.ts';
+import type { GesturePlan } from '../../contracts/gesture-plan.ts';
 import {
   coerceExecResult,
   execFailureDetails,
@@ -123,44 +125,12 @@ export type AndroidTextInjectionRequest = {
 
 export type AndroidTextInjector = (request: AndroidTextInjectionRequest) => Promise<void>;
 
-export type AndroidTouchGestureRequest =
-  | {
-      kind: 'swipe';
-      x1: number;
-      y1: number;
-      x2: number;
-      y2: number;
-      durationMs?: number;
-    }
-  | {
-      kind: 'pinch';
-      x: number;
-      y: number;
-      scale: number;
-      durationMs?: number;
-    }
-  | {
-      kind: 'rotate';
-      x: number;
-      y: number;
-      degrees: number;
-      durationMs?: number;
-    }
-  | {
-      kind: 'transform';
-      x: number;
-      y: number;
-      dx: number;
-      dy: number;
-      scale: number;
-      degrees: number;
-      durationMs?: number;
-    };
-
 export type AndroidTouchInjector = (
-  request: AndroidTouchGestureRequest,
+  request: GesturePlan,
 ) => Promise<Record<string, unknown> | void>;
 
+export type AndroidGestureViewportProvider = () => Promise<Rect>;
+
 export type AndroidAdbProvider = {
   /**
    * Fallback executor for device-scoped adb arguments. Providers may omit explicit
@@ -174,6 +144,7 @@ export type AndroidAdbProvider = {
   installBundle?: AndroidBundleInstaller;
   text?: AndroidTextInjector;
   touch?: AndroidTouchInjector;
+  gestureViewport?: AndroidGestureViewportProvider;
 };
 
 export type AndroidAdbProviderScopeOptions = {
@@ -507,6 +478,13 @@ export function resolveAndroidTouchInjector(device: DeviceInfo): AndroidTouchInj
   return scoped?.serial === device.id ? scoped.provider.touch : undefined;
 }
 
+export function resolveAndroidGestureViewportProvider(
+  device: DeviceInfo,
+): AndroidGestureViewportProvider | undefined {
+  const scoped = androidAdbProviderScope.getStore();
+  return scoped?.serial === device.id ? scoped.provider.gestureViewport : undefined;
+}
+
 export function createAndroidPortReverseManager(
   provider: AndroidAdbProvider | AndroidAdbExecutor,
 ): AndroidPortReverseProvider {
diff --git a/src/platforms/android/multitouch-helper.ts b/src/platforms/android/multitouch-helper.ts
index 613e67cd0..4479a92c5 100644
--- a/src/platforms/android/multitouch-helper.ts
+++ b/src/platforms/android/multitouch-helper.ts
@@ -1,17 +1,20 @@
+import type { GesturePlan, PointerTrajectory } from '../../contracts/gesture-plan.ts';
+import type { DeviceInfo } from '../../kernel/device.ts';
+import type { Rect } from '../../kernel/snapshot.ts';
 import { AppError, normalizeError } from '../../kernel/errors.ts';
 import { execFailureDetails } from '../../utils/exec.ts';
 import { emitDiagnostic, withDiagnosticTimer } from '../../utils/diagnostics.ts';
-import type { DeviceInfo } from '../../kernel/device.ts';
-import type { TransformGestureParams } from '../../contracts/scroll-gesture.ts';
 import {
   resolveAndroidAdbExecutor,
   resolveAndroidAdbProvider,
+  resolveAndroidGestureViewportProvider,
   resolveAndroidTouchInjector,
   type AndroidAdbExecutor,
-  type AndroidTouchGestureRequest,
 } from './adb-executor.ts';
-import { getAndroidScreenSize, swipeAndroid } from './input-actions.ts';
-import { stopAndroidSnapshotHelperSessionForDevice } from './snapshot-helper.ts';
+import {
+  makeEnsureAndroidHelperInstalled,
+  resolveAndroidHelperArtifact,
+} from './helper-package-install.ts';
 import {
   parseInstrumentationRecords,
   readAndroidHelperManifestInteger,
@@ -20,27 +23,18 @@ import {
   readAndroidHelperManifestString,
   readInstrumentationResultNumber,
 } from './instrumentation-helper.ts';
-import {
-  makeEnsureAndroidHelperInstalled,
-  resolveAndroidHelperArtifact,
-} from './helper-package-install.ts';
+import { stopAndroidSnapshotHelperSessionForDevice } from './snapshot-helper.ts';
+import { swipeAndroid } from './input-actions.ts';
 
-const ANDROID_MULTITOUCH_HELPER_NAME = 'android-multitouch-helper';
-const ANDROID_MULTITOUCH_HELPER_PACKAGE = 'com.callstack.agentdevice.multitouchhelper';
-const ANDROID_MULTITOUCH_HELPER_RUNNER =
-  'com.callstack.agentdevice.multitouchhelper/.MultiTouchInstrumentation';
-const ANDROID_MULTITOUCH_HELPER_PROTOCOL = 'android-multitouch-helper-v1';
-const ANDROID_MULTITOUCH_HELPER_INSTALL_TIMEOUT_MS = 30_000;
-const ANDROID_MULTITOUCH_HELPER_GESTURE_TIMEOUT_MS = 45_000;
-const ANDROID_MULTITOUCH_HELPER_DEFAULT_DURATION_MS = 300;
-const ANDROID_MULTITOUCH_HELPER_DEFAULT_RADIUS = 160;
-const ANDROID_MULTITOUCH_HELPER_ROTATE_MAX_DEGREES_PER_FRAME = 3;
-const ANDROID_MULTITOUCH_HELPER_ROTATE_FRAME_INTERVAL_MS = 16;
-const ANDROID_MULTITOUCH_HELPER_ROTATE_MAX_DURATION_MS = 2_400;
-const ANDROID_MULTITOUCH_HELPER_NO_FINAL_RESULT = 'ANDROID_MULTITOUCH_HELPER_NO_FINAL_RESULT';
-const ANDROID_MULTITOUCH_HELPER_REPORTED_FAILURE = 'ANDROID_MULTITOUCH_HELPER_REPORTED_FAILURE';
+const HELPER_NAME = 'android-multitouch-helper';
+const HELPER_PACKAGE = 'com.callstack.agentdevice.multitouchhelper';
+const HELPER_RUNNER = 'com.callstack.agentdevice.multitouchhelper/.MultiTouchInstrumentation';
+const HELPER_PROTOCOL = 'android-multitouch-helper-v1';
+const HELPER_INSTALL_TIMEOUT_MS = 30_000;
+const HELPER_GESTURE_TIMEOUT_MS = 45_000;
+const HELPER_NO_FINAL_RESULT = 'ANDROID_MULTITOUCH_HELPER_NO_FINAL_RESULT';
+const HELPER_REPORTED_FAILURE = 'ANDROID_MULTITOUCH_HELPER_REPORTED_FAILURE';
 const HELPER_LABEL = 'Android multi-touch helper';
-// readAndroidHelperManifestXxx already prepend "Android " to this label.
 const MANIFEST_HELPER_LABEL = 'multi-touch helper';
 
 type AndroidMultiTouchHelperManifest = {
@@ -59,203 +53,78 @@ type AndroidMultiTouchHelperArtifact = {
   manifest: AndroidMultiTouchHelperManifest;
 };
 
-type AndroidMultiTouchHelperGestureRequest =
-  | {
-      kind: 'swipe';
-      x1: number;
-      y1: number;
-      x2: number;
-      y2: number;
-      durationMs: number;
-    }
-  | {
-      kind: 'pinch';
-      x: number;
-      y: number;
-      scale: number;
-      radius: number;
-      durationMs: number;
-    }
-  | {
-      kind: 'rotate';
-      x: number;
-      y: number;
-      degrees: number;
-      radius: number;
-      durationMs: number;
-    }
-  | {
-      kind: 'transform';
-      x: number;
-      y: number;
-      dx: number;
-      dy: number;
-      scale: number;
-      degrees: number;
-      durationMs: number;
-    };
-
-export type AndroidPinchGestureOptions = {
-  scale: number;
-  x?: number;
-  y?: number;
-  durationMs?: number;
+type AndroidPlannedPointerTrajectory = {
+  pointerId: 0 | 1;
+  samples: Array<{ offsetMs: number; x: number; y: number }>;
 };
 
-export type AndroidRotateGestureOptions = {
-  degrees: number;
-  x?: number;
-  y?: number;
-  velocity?: number;
-  durationMs?: number;
+type AndroidMultiTouchHelperGestureRequest = {
+  kind: 'swipe' | 'transform';
+  durationMs: number;
+  pointers: AndroidPlannedPointerTrajectory[];
 };
 
-export type AndroidTransformGestureOptions = TransformGestureParams;
-
-export type AndroidSwipeGestureOptions = {
-  x1: number;
-  y1: number;
-  x2: number;
-  y2: number;
-  durationMs?: number;
-};
-
-export async function swipeGestureAndroid(
+export async function performGestureAndroid(
   device: DeviceInfo,
-  options: AndroidSwipeGestureOptions,
-): Promise<Record<string, unknown> | void> {
-  const providerResult = await runAndroidTouchProviderGesture(device, {
-    kind: 'swipe',
-    ...options,
-  });
-  if (providerResult) return providerResult;
-
+  plan: GesturePlan,
+): Promise<Record<string, unknown>> {
+  const providerTouch = resolveAndroidTouchInjector(device);
+  if (providerTouch) {
+    const result = (await providerTouch(plan)) ?? {};
+    return { backend: 'provider-native-touch', ...result };
+  }
   try {
-    return await runAndroidMultiTouchHelperGestureForDevice(device, { kind: 'swipe', ...options });
+    return await runAndroidMultiTouchHelperGestureForDevice(device, plan);
   } catch (error) {
+    if (plan.topology === 'two') throw error;
     emitDiagnostic({
       level: 'warn',
       phase: 'android_swipe_helper_fallback',
-      data: {
-        error: normalizeError(error).message,
-      },
+      data: { error: normalizeError(error).message },
     });
-    await swipeAndroid(device, options.x1, options.y1, options.x2, options.y2, options.durationMs);
+    const first = plan.pointers[0].samples[0]?.point;
+    const last = plan.pointers[0].samples.at(-1)?.point;
+    if (!first || !last) throw error;
+    await swipeAndroid(device, first.x, first.y, last.x, last.y, plan.durationMs);
     return { backend: 'adb-input-swipe-fallback' };
   }
 }
 
-export async function pinchAndroid(
-  device: DeviceInfo,
-  options: AndroidPinchGestureOptions,
-): Promise<Record<string, unknown>> {
-  if (!Number.isFinite(options.scale) || options.scale <= 0) {
-    throw new AppError('INVALID_ARGS', 'gesture pinch requires scale > 0');
-  }
-  const center = await resolveGestureCenter(device, options.x, options.y);
-  return await performAndroidTouchGesture(device, {
-    kind: 'pinch',
-    x: center.x,
-    y: center.y,
-    scale: options.scale,
-    durationMs: options.durationMs,
-  });
-}
-
-export async function rotateGestureAndroid(
-  device: DeviceInfo,
-  options: AndroidRotateGestureOptions,
-): Promise<Record<string, unknown>> {
-  if (!Number.isFinite(options.degrees)) {
-    throw new AppError('INVALID_ARGS', 'gesture rotate requires finite degrees');
-  }
-  if (
-    options.velocity !== undefined &&
-    (!Number.isFinite(options.velocity) || options.velocity === 0)
-  ) {
-    throw new AppError('INVALID_ARGS', 'gesture rotate velocity must be a non-zero number');
-  }
-  const center = await resolveGestureCenter(device, options.x, options.y);
-  const degrees = options.degrees;
-  return await performAndroidTouchGesture(device, {
-    kind: 'rotate',
-    x: center.x,
-    y: center.y,
-    degrees,
-    durationMs: options.durationMs,
-  });
-}
-
-export async function transformGestureAndroid(
-  device: DeviceInfo,
-  options: AndroidTransformGestureOptions,
-): Promise<Record<string, unknown>> {
-  if (!Number.isFinite(options.scale) || options.scale <= 0) {
-    throw new AppError('INVALID_ARGS', 'gesture transform requires scale > 0');
-  }
-  if (!Number.isFinite(options.degrees)) {
-    throw new AppError('INVALID_ARGS', 'gesture transform requires finite degrees');
-  }
-  if (![options.x, options.y, options.dx, options.dy].every(Number.isFinite)) {
-    throw new AppError('INVALID_ARGS', 'gesture transform requires finite x y dx dy');
-  }
-  return await performAndroidTouchGesture(device, {
-    kind: 'transform',
-    x: options.x,
-    y: options.y,
-    dx: options.dx,
-    dy: options.dy,
-    scale: options.scale,
-    degrees: options.degrees,
-    durationMs: options.durationMs,
-  });
-}
-
-async function resolveGestureCenter(
-  device: DeviceInfo,
-  x: number | undefined,
-  y: number | undefined,
-): Promise<{ x: number; y: number }> {
-  if (x !== undefined && y !== undefined) return { x, y };
-  const size = await getAndroidScreenSize(device);
-  return { x: Math.round(size.width / 2), y: Math.round(size.height / 2) };
-}
-
-async function performAndroidTouchGesture(
+async function runAndroidMultiTouchHelperGestureForDevice(
   device: DeviceInfo,
-  request: AndroidTouchGestureRequest,
+  plan: GesturePlan,
 ): Promise<Record<string, unknown>> {
-  const providerResult = await runAndroidTouchProviderGesture(device, request);
-  if (providerResult) return providerResult;
-
-  return await runAndroidMultiTouchHelperGestureForDevice(device, request);
-}
-
-async function runAndroidTouchProviderGesture(
-  device: DeviceInfo,
-  request: AndroidTouchGestureRequest,
-): Promise<Record<string, unknown> | undefined> {
-  const providerTouch = resolveAndroidTouchInjector(device);
-  if (!providerTouch) return undefined;
-  const result = (await providerTouch(request)) ?? {};
-  return { backend: 'provider-native-touch', ...result };
+  const { adb, artifact, install } = await prepareAndroidMultiTouchHelper(device);
+  const output = await withDiagnosticTimer(
+    'android_multitouch_helper_gesture',
+    async () =>
+      await runAndroidMultiTouchHelperGesture({
+        adb,
+        request: normalizeAndroidMultiTouchHelperGestureRequest(plan),
+        packageName: artifact.manifest.packageName,
+        instrumentationRunner: artifact.manifest.instrumentationRunner,
+      }),
+    { packageName: artifact.manifest.packageName, version: artifact.manifest.version },
+  );
+  return {
+    backend: 'android-multitouch-helper',
+    helperVersion: artifact.manifest.version,
+    installReason: install.reason,
+    ...output,
+  };
 }
 
-async function runAndroidMultiTouchHelperGestureForDevice(
-  device: DeviceInfo,
-  request: AndroidTouchGestureRequest,
-): Promise<Record<string, unknown>> {
+async function prepareAndroidMultiTouchHelper(device: DeviceInfo) {
   const adb = resolveAndroidAdbExecutor(device);
   const artifact = await resolveAndroidMultiTouchHelperArtifact();
-  const adbProvider = resolveAndroidAdbProvider(device);
   const install = await withDiagnosticTimer(
     'android_multitouch_helper_install',
     async () =>
       await ensureAndroidMultiTouchHelper({
         adb,
-        adbProvider,
+        adbProvider: resolveAndroidAdbProvider(device),
         artifact,
-        deviceKey: getAndroidMultiTouchHelperDeviceKey(device),
+        deviceKey: `${device.platform}:${device.id}`,
       }),
     {
       packageName: artifact.manifest.packageName,
@@ -267,88 +136,83 @@ async function runAndroidMultiTouchHelperGestureForDevice(
     data: install,
   });
   await stopAndroidSnapshotHelperSessionForDevice(device);
-  const output = await withDiagnosticTimer(
-    'android_multitouch_helper_gesture',
-    async () =>
-      await runAndroidMultiTouchHelperGesture({
-        adb,
-        request: normalizeHelperGestureRequest(request),
-        packageName: artifact.manifest.packageName,
-        instrumentationRunner: artifact.manifest.instrumentationRunner,
-      }),
-    {
-      packageName: artifact.manifest.packageName,
-      version: artifact.manifest.version,
-    },
+  return { adb, artifact, install };
+}
+
+export async function readAndroidGestureViewport(device: DeviceInfo): Promise<Rect> {
+  const providerViewport = resolveAndroidGestureViewportProvider(device);
+  if (providerViewport) return validateAndroidGestureViewport(await providerViewport());
+  const { adb, artifact } = await prepareAndroidMultiTouchHelper(device);
+  const result = await adb(
+    [
+      'shell',
+      'am',
+      'instrument',
+      '-w',
+      '-e',
+      'mode',
+      'viewport',
+      artifact.manifest.instrumentationRunner,
+    ],
+    { allowFailure: true, timeoutMs: HELPER_GESTURE_TIMEOUT_MS },
   );
-  return {
-    backend: 'android-multitouch-helper',
-    helperVersion: artifact.manifest.version,
-    installReason: install.reason,
-    ...output,
-  };
+  const records = parseInstrumentationRecords(`${result.stdout}\n${result.stderr}`);
+  if (result.exitCode !== 0)
+    throw new AppError('COMMAND_FAILED', 'Android gesture viewport is unavailable');
+  return parseAndroidGestureViewportResult(records.results);
 }
 
-function normalizeHelperGestureRequest(
-  request: AndroidTouchGestureRequest,
-): AndroidMultiTouchHelperGestureRequest {
-  const durationMs = Math.round(resolveHelperGestureDurationMs(request));
-  switch (request.kind) {
-    case 'swipe':
-      return {
-        kind: 'swipe',
-        x1: Math.round(request.x1),
-        y1: Math.round(request.y1),
-        x2: Math.round(request.x2),
-        y2: Math.round(request.y2),
-        durationMs,
-      };
-    case 'pinch':
-      return {
-        kind: 'pinch',
-        x: Math.round(request.x),
-        y: Math.round(request.y),
-        scale: request.scale,
-        radius: ANDROID_MULTITOUCH_HELPER_DEFAULT_RADIUS,
-        durationMs,
-      };
-    case 'rotate':
-      return {
-        kind: 'rotate',
-        x: Math.round(request.x),
-        y: Math.round(request.y),
-        degrees: request.degrees,
-        radius: ANDROID_MULTITOUCH_HELPER_DEFAULT_RADIUS,
-        durationMs,
-      };
-    case 'transform':
-      return {
-        kind: 'transform',
-        x: Math.round(request.x),
-        y: Math.round(request.y),
-        dx: Math.round(request.dx),
-        dy: Math.round(request.dy),
-        scale: request.scale,
-        degrees: request.degrees,
-        durationMs,
-      };
+export function parseAndroidGestureViewportResult(results: Array<Record<string, string>>): Rect {
+  const output = results.find((record) => record.agentDeviceProtocol === HELPER_PROTOCOL);
+  if (output?.ok !== 'true')
+    throw new AppError(
+      'COMMAND_FAILED',
+      output?.message || 'Android gesture viewport is unavailable',
+    );
+  const x = readInstrumentationResultNumber(output.x);
+  const y = readInstrumentationResultNumber(output.y);
+  const width = readInstrumentationResultNumber(output.width);
+  const height = readInstrumentationResultNumber(output.height);
+  if (x === undefined || y === undefined || width === undefined || height === undefined) {
+    throw new AppError('COMMAND_FAILED', 'Android helper returned an invalid gesture viewport');
   }
+  return validateAndroidGestureViewport({ x, y, width, height });
 }
 
-function resolveHelperGestureDurationMs(request: AndroidTouchGestureRequest): number {
-  if (request.durationMs !== undefined) {
-    return request.durationMs;
-  }
-  if (request.kind === 'swipe' || request.kind === 'pinch') {
-    return ANDROID_MULTITOUCH_HELPER_DEFAULT_DURATION_MS;
-  }
-  const angleBasedDuration =
-    Math.ceil(Math.abs(request.degrees) / ANDROID_MULTITOUCH_HELPER_ROTATE_MAX_DEGREES_PER_FRAME) *
-    ANDROID_MULTITOUCH_HELPER_ROTATE_FRAME_INTERVAL_MS;
-  return Math.min(
-    Math.max(ANDROID_MULTITOUCH_HELPER_DEFAULT_DURATION_MS, angleBasedDuration),
-    ANDROID_MULTITOUCH_HELPER_ROTATE_MAX_DURATION_MS,
-  );
+function validateAndroidGestureViewport(viewport: Rect): Rect {
+  if (
+    !Number.isFinite(viewport.x) ||
+    !Number.isFinite(viewport.y) ||
+    !Number.isFinite(viewport.width) ||
+    !Number.isFinite(viewport.height) ||
+    viewport.width <= 0 ||
+    viewport.height <= 0
+  )
+    throw new AppError('COMMAND_FAILED', 'Android helper returned an invalid gesture viewport');
+  return viewport;
+}
+
+export function normalizeAndroidMultiTouchHelperGestureRequest(
+  plan: GesturePlan,
+): AndroidMultiTouchHelperGestureRequest {
+  return {
+    kind: plan.topology === 'single' ? 'swipe' : 'transform',
+    durationMs: plan.durationMs,
+    pointers: plan.pointers.map(toAndroidPlannedPointerTrajectory),
+  };
+}
+
+function toAndroidPlannedPointerTrajectory(
+  pointer: PointerTrajectory,
+): AndroidPlannedPointerTrajectory {
+  return {
+    pointerId: pointer.pointerId,
+    samples: pointer.samples.map(({ offsetMs, point }) => ({
+      offsetMs,
+      x: point.x,
+      y: point.y,
+    })),
+  };
 }
 
 export async function runAndroidMultiTouchHelperGesture(options: {
@@ -358,10 +222,7 @@ export async function runAndroidMultiTouchHelperGesture(options: {
   instrumentationRunner: string;
 }): Promise<Record<string, unknown>> {
   const payloadBase64 = Buffer.from(
-    JSON.stringify({
-      protocol: ANDROID_MULTITOUCH_HELPER_PROTOCOL,
-      ...options.request,
-    }),
+    JSON.stringify({ protocol: HELPER_PROTOCOL, ...options.request }),
   ).toString('base64');
   const result = await options.adb(
     [
@@ -374,32 +235,24 @@ export async function runAndroidMultiTouchHelperGesture(options: {
       payloadBase64,
       options.instrumentationRunner,
     ],
-    { allowFailure: true, timeoutMs: ANDROID_MULTITOUCH_HELPER_GESTURE_TIMEOUT_MS },
+    { allowFailure: true, timeoutMs: HELPER_GESTURE_TIMEOUT_MS },
   );
   let output: Record<string, unknown>;
   try {
     output = parseAndroidMultiTouchHelperOutput(`${result.stdout}\n${result.stderr}`);
   } catch (error) {
     if (error instanceof AppError) {
-      if (error.code === ANDROID_MULTITOUCH_HELPER_REPORTED_FAILURE) {
+      if (error.code === HELPER_REPORTED_FAILURE) {
         throw new AppError('COMMAND_FAILED', error.message, error.details, error);
       }
-      if (error.code !== ANDROID_MULTITOUCH_HELPER_NO_FINAL_RESULT) {
-        throw error;
-      }
+      if (error.code !== HELPER_NO_FINAL_RESULT) throw error;
     }
-    // exec-guard-allow: reachable at exit 0 (helper output unparseable); the
-    // message already branches on the exit code.
     throw new AppError(
       'COMMAND_FAILED',
       result.exitCode === 0
         ? 'Android multi-touch helper output could not be parsed'
         : 'Android multi-touch helper failed before returning parseable output',
-      {
-        stdout: result.stdout,
-        stderr: result.stderr,
-        exitCode: result.exitCode,
-      },
+      execFailureDetails(result),
       error,
     );
   }
@@ -415,38 +268,31 @@ export async function runAndroidMultiTouchHelperGesture(options: {
 
 export function parseAndroidMultiTouchHelperOutput(output: string): Record<string, unknown> {
   const finalResult = parseInstrumentationRecords(output).results.find(
-    (record) => record.agentDeviceProtocol === ANDROID_MULTITOUCH_HELPER_PROTOCOL,
+    (record) => record.agentDeviceProtocol === HELPER_PROTOCOL,
   );
   if (!finalResult) {
     throw new AppError(
-      ANDROID_MULTITOUCH_HELPER_NO_FINAL_RESULT,
+      HELPER_NO_FINAL_RESULT,
       'Android multi-touch helper did not return a final result',
     );
   }
   if (finalResult.ok !== 'true') {
     throw new AppError(
-      ANDROID_MULTITOUCH_HELPER_REPORTED_FAILURE,
-      readHelperErrorMessage(finalResult),
-      {
-        errorType: finalResult.errorType,
-        helper: finalResult,
-      },
+      HELPER_REPORTED_FAILURE,
+      finalResult.message && finalResult.message !== 'null'
+        ? finalResult.message
+        : finalResult.errorType || 'Android multi-touch helper returned an error',
+      { errorType: finalResult.errorType, helper: finalResult },
     );
   }
   return {
-    kind: finalResult.kind,
+    helperKind: finalResult.kind,
     helperApiVersion: finalResult.helperApiVersion,
     injectedEvents: readInstrumentationResultNumber(finalResult.injectedEvents),
     elapsedMs: readInstrumentationResultNumber(finalResult.elapsedMs),
   };
 }
 
-function readHelperErrorMessage(finalResult: Record<string, string>): string {
-  return finalResult.message && finalResult.message !== 'null'
-    ? finalResult.message
-    : finalResult.errorType || 'Android multi-touch helper returned an error';
-}
-
 async function resolveAndroidMultiTouchHelperArtifact(): Promise<AndroidMultiTouchHelperArtifact> {
   return await resolveAndroidHelperArtifact({
     helperDirName: 'android-multitouch-helper',
@@ -464,12 +310,7 @@ function parseAndroidMultiTouchHelperManifest(value: unknown): AndroidMultiTouch
   }
   const record = value as Record<string, unknown>;
   return {
-    name: readAndroidHelperManifestLiteral(
-      record.name,
-      'name',
-      ANDROID_MULTITOUCH_HELPER_NAME,
-      MANIFEST_HELPER_LABEL,
-    ),
+    name: readAndroidHelperManifestLiteral(record.name, 'name', HELPER_NAME, MANIFEST_HELPER_LABEL),
     version: readAndroidHelperManifestString(record.version, 'version', MANIFEST_HELPER_LABEL),
     assetName: readAndroidHelperManifestString(
       record.assetName,
@@ -480,7 +321,7 @@ function parseAndroidMultiTouchHelperManifest(value: unknown): AndroidMultiTouch
     packageName: readAndroidHelperManifestLiteral(
       record.packageName,
       'packageName',
-      ANDROID_MULTITOUCH_HELPER_PACKAGE,
+      HELPER_PACKAGE,
       MANIFEST_HELPER_LABEL,
     ),
     versionCode: readAndroidHelperManifestInteger(
@@ -491,13 +332,13 @@ function parseAndroidMultiTouchHelperManifest(value: unknown): AndroidMultiTouch
     instrumentationRunner: readAndroidHelperManifestLiteral(
       record.instrumentationRunner,
       'instrumentationRunner',
-      ANDROID_MULTITOUCH_HELPER_RUNNER,
+      HELPER_RUNNER,
       MANIFEST_HELPER_LABEL,
     ),
     statusProtocol: readAndroidHelperManifestLiteral(
       record.statusProtocol,
       'statusProtocol',
-      ANDROID_MULTITOUCH_HELPER_PROTOCOL,
+      HELPER_PROTOCOL,
       MANIFEST_HELPER_LABEL,
     ),
   };
@@ -508,15 +349,10 @@ const installedMultiTouchHelpers = new Set<string>();
 export const ensureAndroidMultiTouchHelper =
   makeEnsureAndroidHelperInstalled<AndroidMultiTouchHelperArtifact>({
     cache: installedMultiTouchHelpers,
-    installTimeoutMs: ANDROID_MULTITOUCH_HELPER_INSTALL_TIMEOUT_MS,
+    installTimeoutMs: HELPER_INSTALL_TIMEOUT_MS,
     helperLabel: HELPER_LABEL,
   });
 
-// Tests reset the process-global install memo so cases do not share helper state.
 export function resetAndroidMultiTouchHelperInstallCache(): void {
   installedMultiTouchHelpers.clear();
 }
-
-function getAndroidMultiTouchHelperDeviceKey(device: DeviceInfo): string {
-  return `${device.platform}:${device.id}`;
-}
diff --git a/src/platforms/apple/capabilities.ts b/src/platforms/apple/capabilities.ts
index 5365009d9..c1d79cfd5 100644
--- a/src/platforms/apple/capabilities.ts
+++ b/src/platforms/apple/capabilities.ts
@@ -1,6 +1,6 @@
 import {
   isApplePlatform,
-  isTvOsDevice,
+  resolveDeviceAppleOs,
   type AppleOS,
   type DeviceInfo,
 } from '../../kernel/device.ts';
@@ -9,16 +9,15 @@ import {
 // Per-`AppleOS` capability data table (ADR-0009 "per-AppleOS capability table").
 // This is the capability-axis sibling of the runner
 // table `RUNNER_PLATFORM_PROFILES` (src/platforms/apple/core/apple-runner-platform.ts)
-// and it encodes the SAME per-OS facts the Swift `#if os()` guards do: which Apple
-// OS has touch input, multi-touch synthesis, a keyboard, device orientation, an
-// app/device lifecycle, and a desktop host surface.
+// and it encodes the SAME per-OS facts the Swift `#if os()` guards do: keyboard,
+// device orientation, app/device lifecycle, and desktop host surfaces.
 //
 // DISCIPLINE (ADR-0009): the table holds ONLY the AppleOS-axis facts — it
 // collapses the scattered `target !== 'tv'` / `platform !== 'macos'` / `isTvOsDevice`
-// predicates into one lookup. The DEVICE-shaped nuance the closures still encode
-// (simulator vs physical device — e.g. two-finger synthesis is iOS-*simulator* only)
-// is NOT flattened into data; it stays in the reading closure. The predicate rewrite
-// is behaviorless: `apple-os-capability-table-parity.test.ts` pins the table-driven
+// predicates into one lookup. Gesture synthesis has its own shared policy in
+// `contracts/apple-multitouch-support.ts`; keeping it out of this table prevents a
+// second source of truth. The predicate rewrite is behaviorless:
+// `apple-os-capability-table-parity.test.ts` pins the table-driven
 // closures byte-for-byte against a verbatim copy of the original predicates across the
 // full {command x sample-device} matrix (iOS/iPadOS/tvOS/macOS/visionOS).
 // ---------------------------------------------------------------------------
@@ -41,63 +40,42 @@ export type AppleOsCapabilityProfile = {
    * still admits every Apple *simulator* via its own `kind === 'simulator'` check.
    */
   readonly physicalDeviceSurfaces: boolean;
-  /**
-   * `pinch` / `rotate-gesture` / `transform-gesture` — the two-finger multi-touch
-   * SYNTHESIS input model. `false` on tvOS (no touch) and macOS (no multi-touch). The
-   * reading closure further gates this to the simulator (physical iOS cannot synthesize),
-   * which is device-shaped nuance kept OUT of the table on purpose.
-   */
-  readonly multiTouchSynthesis: boolean;
-  /**
-   * The OS-level reason a multi-touch gesture is refused: macOS has no multi-touch
-   * input; tvOS has no touch input. `undefined` for the iOS family, whose only block
-   * is the kind-shaped physical-device case handled in the hint closure.
-   */
-  readonly multiTouchUnsupportedHint?: string;
 };
 
-// iOS / iPadOS / visionOS are capability-identical under today's behavior: all are
-// modeled as the touch iOS engine (`platform: 'ios'`, mobile target), so a stored
-// `appleOs: 'ipados' | 'visionos'` must read exactly what the legacy target-based
-// inference produced for an unlabeled iOS record. Sharing ONE frozen row keeps that
-// invariant a reference identity (asserted by the parity test) and mirrors the iOS
-// runner profile absorbing iPadOS.
+// iOS and iPadOS share this platform capability profile. Gesture synthesis support is
+// intentionally owned by the separate shared gesture policy.
 const IOS_FAMILY_CAPABILITIES: AppleOsCapabilityProfile = {
   appAndDeviceLifecycle: true,
   keyboard: true,
   orientation: true,
   physicalDeviceSurfaces: false,
-  multiTouchSynthesis: true,
 };
 
 export const APPLE_OS_CAPABILITIES: Record<AppleOS, AppleOsCapabilityProfile> = {
   ios: IOS_FAMILY_CAPABILITIES,
   ipados: IOS_FAMILY_CAPABILITIES,
-  visionos: IOS_FAMILY_CAPABILITIES,
-  // tvOS: focus-only (XCUIRemote), no touch — so no keyboard, orientation, or
-  // multi-touch synthesis; but the app + device lifecycle (boot/install/home/
-  // app-switcher) is supported like the rest of the mobile family.
+  visionos: {
+    appAndDeviceLifecycle: true,
+    keyboard: true,
+    orientation: true,
+    physicalDeviceSurfaces: false,
+  },
+  // tvOS: focus-only (XCUIRemote), so no keyboard or orientation; the app + device
+  // lifecycle (boot/install/home/app-switcher) is supported like the mobile family.
   tvos: {
     appAndDeviceLifecycle: true,
     keyboard: false,
     orientation: false,
     physicalDeviceSurfaces: false,
-    multiTouchSynthesis: false,
-    multiTouchUnsupportedHint:
-      'tvOS has no touch input — this gesture is supported on Android and the iOS simulator only.',
   },
   // macOS: an AppKit desktop host driving an already-running app. No app/device
-  // lifecycle (nothing to boot/install/push, no springboard), no touch keyboard /
-  // orientation, no multi-touch; but clipboard/alert/settings are reachable on the
-  // host directly (no simulator required).
+  // lifecycle (nothing to boot/install/push, no springboard), keyboard, or orientation;
+  // clipboard/alert/settings are reachable on the host directly (no simulator required).
   macos: {
     appAndDeviceLifecycle: false,
     keyboard: false,
     orientation: false,
     physicalDeviceSurfaces: true,
-    multiTouchSynthesis: false,
-    multiTouchUnsupportedHint:
-      'macOS automation has no multi-touch input — this gesture is supported on Android and the iOS simulator only.',
   },
   // watchOS is reserved in the `AppleOS` type but never produced by discovery or by
   // `resolveDeviceAppleOs` inference (XCUITest cannot drive watchOS UI — ADR-0009's
@@ -108,31 +86,9 @@ export const APPLE_OS_CAPABILITIES: Record<AppleOS, AppleOsCapabilityProfile> =
     keyboard: false,
     orientation: false,
     physicalDeviceSurfaces: false,
-    multiTouchSynthesis: false,
   },
 };
 
-/**
- * The stored `AppleOS` discriminant for `device`, with the SAME "prefer the explicit
- * field, else infer from target" precedence that `resolveApplePlatformName` uses for
- * the runner name. Only meaningful for Apple devices (callers guard via
- * {@link appleOsCapabilities}).
- */
-export function resolveDeviceAppleOs(
-  device: Pick<DeviceInfo, 'platform' | 'target' | 'appleOs'>,
-): AppleOS {
-  // Real discovery sets `appleOs`; legacy/synthetic records without it fall back to
-  // the target-based inference the capability predicates used before this table.
-  if (device.appleOs) return device.appleOs;
-  // Back-compat: a legacy persisted record may still carry the pre-collapse `macos`
-  // leaf platform string (the type no longer allows it, hence the cast).
-  if ((device.platform as string) === 'macos') return 'macos';
-  if (isTvOsDevice(device)) return 'tvos';
-  // iOS / iPadOS / visionOS are indistinguishable without discovery descriptors and
-  // are capability-identical, so an unlabeled mobile Apple record collapses to `ios`.
-  return 'ios';
-}
-
 /**
  * The {@link AppleOsCapabilityProfile} for `device`, or `undefined` for a non-Apple
  * platform (which has no AppleOS row). The capability closures fall back to their
diff --git a/src/platforms/apple/core/__tests__/index.test.ts b/src/platforms/apple/core/__tests__/index.test.ts
index 72183c278..fbfc315a2 100644
--- a/src/platforms/apple/core/__tests__/index.test.ts
+++ b/src/platforms/apple/core/__tests__/index.test.ts
@@ -75,7 +75,7 @@ import {
   prepareSimulatorStatusBarForScreenshot,
 } from '../screenshot-status-bar.ts';
 import { runAppleRunnerCommand } from '../runner/runner-client.ts';
-import { iosRunnerOverrides } from '../../interactions.ts';
+import { iosRunnerOverrides, performGestureApple } from '../../interactions.ts';
 import {
   IOS_DEVICE_INSTALL_TIMEOUT_MS,
   IOS_SIMULATOR_FOCUS_TIMEOUT_MS,
@@ -88,6 +88,8 @@ import { runCmd } from '../../../../utils/exec.ts';
 import { retryWithPolicy } from '../../../../utils/retry.ts';
 import { parseIosDeviceAppsPayload, parseIosDeviceProcessesPayload } from '../devicectl.ts';
 import { PNG } from '../../../../utils/png.ts';
+import type { GesturePlan } from '../../../../contracts/gesture-plan.ts';
+import { requireGestureSupported } from '../../../../core/capabilities.ts';
 
 const IOS_TEST_DEVICE: DeviceInfo = {
   platform: 'apple',
@@ -196,28 +198,6 @@ test('resolveMacOsHelperPackageRootFrom finds helper package from source and dis
   }
 });
 
-test('iosRunnerOverrides maps iOS fling duration to synthesized drag', async () => {
-  mockRunAppleRunnerCommand.mockResolvedValue({});
-
-  const { overrides } = iosRunnerOverrides(IOS_TEST_SIMULATOR, {
-    appBundleId: 'com.example.App',
-  });
-
-  await overrides.fling(100, 200, 180, 200, undefined);
-
-  assert.deepEqual(mockRunAppleRunnerCommand.mock.calls[0]?.[1], {
-    command: 'drag',
-    x: 100,
-    y: 200,
-    x2: 180,
-    y2: 200,
-    durationMs: 16,
-    synthesized: true,
-    dragSemantics: 'fling',
-    appBundleId: 'com.example.App',
-  });
-});
-
 test('iosRunnerOverrides uses synthesized iOS coordinate taps', async () => {
   mockRunAppleRunnerCommand.mockResolvedValue({});
 
@@ -244,6 +224,21 @@ test('iosRunnerOverrides uses synthesized iOS coordinate taps', async () => {
   });
 });
 
+test('iosRunnerOverrides reads and validates the fresh gesture viewport', async () => {
+  mockRunAppleRunnerCommand.mockResolvedValue({ x: 10, y: 20, x2: 300, y2: 500 });
+  const { overrides } = iosRunnerOverrides(IOS_TEST_SIMULATOR, {
+    appBundleId: 'com.example.App',
+  });
+  assert.ok(overrides.gestureViewport);
+  assert.deepEqual(await overrides.gestureViewport(), { x: 10, y: 20, width: 300, height: 500 });
+  assert.deepEqual(mockRunAppleRunnerCommand.mock.calls[0]?.[1], {
+    command: 'gestureViewport',
+    appBundleId: 'com.example.App',
+  });
+  mockRunAppleRunnerCommand.mockResolvedValue({ x: 0, y: 0, x2: 0, y2: 500 });
+  await assert.rejects(() => overrides.gestureViewport!(), { code: 'COMMAND_FAILED' });
+});
+
 for (const [name, device] of [
   ['macOS', MACOS_TEST_DEVICE],
   ['tvOS', TVOS_TEST_SIMULATOR],
@@ -266,96 +261,81 @@ for (const [name, device] of [
   });
 }
 
-test('iosRunnerOverrides maps iOS swipe and pan durations to synthesized drag', async () => {
-  mockRunAppleRunnerCommand.mockResolvedValue({});
+test('performGestureApple sends exact two-pointer pan samples through gesture', async () => {
+  mockRunAppleRunnerCommand.mockResolvedValue({ transformed: true });
+  const plan = twoFingerPanPlan();
 
-  const { overrides } = iosRunnerOverrides(IOS_TEST_SIMULATOR, {
+  const result = await performGestureApple(
+    IOS_TEST_SIMULATOR,
+    { appBundleId: 'com.example.App' },
+    {},
+    plan,
+  );
+
+  assert.deepEqual(result, { transformed: true });
+  assert.deepEqual(mockRunAppleRunnerCommand.mock.calls[0]?.[1], {
+    command: 'gesture',
+    gesturePlan: plan,
     appBundleId: 'com.example.App',
   });
+});
 
-  await overrides.swipe(100, 200, 180, 200, 300);
-  await overrides.swipe(100, 200, 180, 200, undefined);
-  await overrides.pan(100, 200, 180, 200, 300);
+test('Apple admission and execution share the same multi-touch refusal', async () => {
+  let admissionError: AppError | undefined;
+  try {
+    requireGestureSupported(
+      {
+        intent: 'pan',
+        origin: { x: 100, y: 200 },
+        delta: { x: 80, y: -40 },
+        pointerCount: 2,
+      },
+      IOS_TEST_DEVICE,
+    );
+  } catch (error) {
+    if (error instanceof AppError) admissionError = error;
+  }
+  assert.ok(admissionError);
+
+  await assert.rejects(
+    () => performGestureApple(IOS_TEST_DEVICE, {}, {}, twoFingerPanPlan()),
+    (error: unknown) =>
+      error instanceof AppError &&
+      error.code === 'UNSUPPORTED_OPERATION' &&
+      error.message === admissionError.message &&
+      error.details?.hint === admissionError.details?.hint,
+  );
+  assert.equal(mockRunAppleRunnerCommand.mock.calls.length, 0);
+});
+
+test('performGestureApple composes macOS one-contact plans with the drag executor', async () => {
+  mockRunAppleRunnerCommand.mockResolvedValue({ dragged: true });
+  const plan = singlePanPlan();
+
+  await performGestureApple(MACOS_TEST_DEVICE, { appBundleId: 'com.example.App' }, {}, plan);
 
   assert.deepEqual(mockRunAppleRunnerCommand.mock.calls[0]?.[1], {
     command: 'drag',
     x: 100,
     y: 200,
     x2: 180,
-    y2: 200,
-    durationMs: 300,
-    synthesized: true,
-    dragSemantics: 'swipe',
-    appBundleId: 'com.example.App',
-  });
-  assert.deepEqual(mockRunAppleRunnerCommand.mock.calls[1]?.[1], {
-    command: 'drag',
-    x: 100,
-    y: 200,
-    x2: 180,
-    y2: 200,
-    durationMs: 250,
-    synthesized: true,
-    dragSemantics: 'swipe',
-    appBundleId: 'com.example.App',
-  });
-  assert.deepEqual(mockRunAppleRunnerCommand.mock.calls[2]?.[1], {
-    command: 'drag',
-    x: 100,
-    y: 200,
-    x2: 180,
-    y2: 200,
-    durationMs: 300,
-    synthesized: true,
-    dragSemantics: 'pan',
+    y2: 160,
+    durationMs: 500,
     appBundleId: 'com.example.App',
   });
 });
 
-for (const [name, device] of [
-  ['macOS', MACOS_TEST_DEVICE],
-  ['tvOS', TVOS_TEST_SIMULATOR],
-] as const) {
-  test(`iosRunnerOverrides keeps ${name} drag gestures on the standard path`, async () => {
-    mockRunAppleRunnerCommand.mockResolvedValue({});
-
-    const { overrides } = iosRunnerOverrides(device, {
-      appBundleId: 'com.example.App',
-    });
+test('performGestureApple composes tvOS one-contact plans with remote direction', async () => {
+  mockRunAppleRunnerCommand.mockResolvedValue({ swiped: true });
 
-    await overrides.swipe(100, 200, 180, 200, 300);
-    await overrides.pan(100, 200, 180, 200, 300);
-    await overrides.fling(100, 200, 180, 200, 300);
+  await performGestureApple(TVOS_TEST_SIMULATOR, {}, {}, singlePanPlan());
 
-    assert.deepEqual(mockRunAppleRunnerCommand.mock.calls[0]?.[1], {
-      command: 'drag',
-      x: 100,
-      y: 200,
-      x2: 180,
-      y2: 200,
-      durationMs: 300,
-      appBundleId: 'com.example.App',
-    });
-    assert.deepEqual(mockRunAppleRunnerCommand.mock.calls[1]?.[1], {
-      command: 'drag',
-      x: 100,
-      y: 200,
-      x2: 180,
-      y2: 200,
-      durationMs: 300,
-      appBundleId: 'com.example.App',
-    });
-    assert.deepEqual(mockRunAppleRunnerCommand.mock.calls[2]?.[1], {
-      command: 'drag',
-      x: 100,
-      y: 200,
-      x2: 180,
-      y2: 200,
-      durationMs: 300,
-      appBundleId: 'com.example.App',
-    });
+  assert.deepEqual(mockRunAppleRunnerCommand.mock.calls[0]?.[1], {
+    command: 'swipe',
+    direction: 'right',
+    appBundleId: undefined,
   });
-}
+});
 
 test('iosRunnerOverrides maps iOS scroll to a single fused scroll command', async () => {
   // The fused scroll resolves the frame and performs the duration-aware drag in one runner
@@ -3409,3 +3389,48 @@ exit 1
     },
   );
 });
+
+function twoFingerPanPlan(): Extract<GesturePlan, { topology: 'two' }> {
+  return {
+    topology: 'two',
+    intent: 'pan',
+    durationMs: 32,
+    viewport: { x: 0, y: 0, width: 400, height: 800 },
+    pointers: [
+      {
+        pointerId: 0,
+        samples: [
+          { offsetMs: 0, point: { x: 100, y: 80 } },
+          { offsetMs: 16, point: { x: 110, y: 85 } },
+          { offsetMs: 32, point: { x: 120, y: 90 } },
+        ],
+      },
+      {
+        pointerId: 1,
+        samples: [
+          { offsetMs: 0, point: { x: 100, y: 120 } },
+          { offsetMs: 16, point: { x: 110, y: 125 } },
+          { offsetMs: 32, point: { x: 120, y: 130 } },
+        ],
+      },
+    ],
+  };
+}
+
+function singlePanPlan(): Extract<GesturePlan, { topology: 'single' }> {
+  return {
+    topology: 'single',
+    intent: 'pan',
+    durationMs: 500,
+    viewport: { x: 0, y: 0, width: 400, height: 800 },
+    pointers: [
+      {
+        pointerId: 0,
+        samples: [
+          { offsetMs: 0, point: { x: 100, y: 200 } },
+          { offsetMs: 500, point: { x: 180, y: 160 } },
+        ],
+      },
+    ],
+  };
+}
diff --git a/src/platforms/apple/core/__tests__/runner-client.test.ts b/src/platforms/apple/core/__tests__/runner-client.test.ts
index d05b07bbb..ac1125af4 100644
--- a/src/platforms/apple/core/__tests__/runner-client.test.ts
+++ b/src/platforms/apple/core/__tests__/runner-client.test.ts
@@ -158,26 +158,16 @@ const runnerProtocolCommandFixtures: Record<RunnerCommand['command'], RunnerComm
   keyboardDismiss: { command: 'keyboardDismiss' },
   keyboardReturn: { command: 'keyboardReturn' },
   alert: { command: 'alert', action: 'accept' },
-  pinch: { command: 'pinch', scale: 0.5 },
   sequence: {
     command: 'sequence',
     steps: [
       { kind: 'tap', x: 120, y: 240 },
       { kind: 'longPress', x: 120, y: 240, durationMs: 300 },
-      { kind: 'drag', x: 10, y: 600, x2: 10, y2: 200, durationMs: 250, pauseMs: 50 },
+      { kind: 'doubleTap', x: 10, y: 600, pauseMs: 50 },
     ],
   },
-  rotateGesture: { command: 'rotateGesture', degrees: 35, x: 200, y: 420, velocity: 1 },
-  transformGesture: {
-    command: 'transformGesture',
-    x: 200,
-    y: 420,
-    dx: 80,
-    dy: -40,
-    scale: 2,
-    degrees: 35,
-    durationMs: 700,
-  },
+  gesture: { command: 'gesture' },
+  gestureViewport: { command: 'gestureViewport' },
   recordStart: {
     command: 'recordStart',
     outPath: '/tmp/runner-recording.mp4',
@@ -335,19 +325,19 @@ test('runner protocol fixtures cover every runner command with JSON-safe samples
     'desktopScroll',
     'drag',
     'findText',
+    'gesture',
+    'gestureViewport',
     'home',
     'keyboardDismiss',
     'keyboardReturn',
     'longPress',
     'mouseClick',
-    'pinch',
     'querySelector',
     'readText',
     'recordStart',
     'recordStop',
     'remotePress',
     'rotate',
-    'rotateGesture',
     'screenshot',
     'scroll',
     'sequence',
@@ -356,7 +346,6 @@ test('runner protocol fixtures cover every runner command with JSON-safe samples
     'status',
     'swipe',
     'tap',
-    'transformGesture',
     'type',
     'uptime',
   ]);
diff --git a/src/platforms/apple/core/__tests__/runner-command-retry.test.ts b/src/platforms/apple/core/__tests__/runner-command-retry.test.ts
index 02042c711..6a22bdd5f 100644
--- a/src/platforms/apple/core/__tests__/runner-command-retry.test.ts
+++ b/src/platforms/apple/core/__tests__/runner-command-retry.test.ts
@@ -945,7 +945,7 @@ test('sequence surfaces a lifecycle failure without replaying', async () => {
     .mockResolvedValueOnce({
       lifecycleState: 'failed',
       lifecycleErrorCode: 'UNSUPPORTED_OPERATION',
-      lifecycleErrorMessage: 'sequence step 1 (drag) failed',
+      lifecycleErrorMessage: 'sequence step 1 (longPress) failed',
     });
 
   await assert.rejects(
@@ -954,13 +954,13 @@ test('sequence surfaces a lifecycle failure without replaying', async () => {
         command: 'sequence',
         steps: [
           { kind: 'tap', x: 1, y: 2 },
-          { kind: 'drag', x: 3, y: 4, x2: 5, y2: 6 },
+          { kind: 'longPress', x: 3, y: 4 },
         ],
       }),
     (error: unknown) => {
       assert.ok(error instanceof AppError);
       assert.equal(error.code, 'UNSUPPORTED_OPERATION');
-      assert.equal(error.message, 'sequence step 1 (drag) failed');
+      assert.equal(error.message, 'sequence step 1 (longPress) failed');
       return true;
     },
   );
diff --git a/src/platforms/apple/core/__tests__/runner-command-traits.test.ts b/src/platforms/apple/core/__tests__/runner-command-traits.test.ts
index 101bd05a8..c9d34804b 100644
--- a/src/platforms/apple/core/__tests__/runner-command-traits.test.ts
+++ b/src/platforms/apple/core/__tests__/runner-command-traits.test.ts
@@ -29,6 +29,7 @@ test('runner command manifest pins lifecycle-sensitive command groups', () => {
   assert.deepEqual(commandsForClass('preflightSkippableTouchMutation'), [
     'desktopScroll',
     'drag',
+    'gesture',
     'longPress',
     'scroll',
     'sequence',
@@ -38,6 +39,7 @@ test('runner command manifest pins lifecycle-sensitive command groups', () => {
   assert.deepEqual(commandsForClass('readOnly'), [
     'alert',
     'findText',
+    'gestureViewport',
     'querySelector',
     'readText',
     'screenshot',
diff --git a/src/platforms/apple/core/__tests__/runner-sequence.test.ts b/src/platforms/apple/core/__tests__/runner-sequence.test.ts
index c005d75bd..031b06c0b 100644
--- a/src/platforms/apple/core/__tests__/runner-sequence.test.ts
+++ b/src/platforms/apple/core/__tests__/runner-sequence.test.ts
@@ -15,7 +15,7 @@ function tap(x: number, y: number): RunnerSequenceStep {
 }
 
 test('SEQUENCEABLE_RUNNER_STEP_KINDS is the documented allowlist', () => {
-  assert.deepEqual([...SEQUENCEABLE_RUNNER_STEP_KINDS], ['tap', 'doubleTap', 'longPress', 'drag']);
+  assert.deepEqual([...SEQUENCEABLE_RUNNER_STEP_KINDS], ['tap', 'doubleTap', 'longPress']);
 });
 
 test('validateRunnerSequenceSteps accepts doubleTap steps with finite coords', () => {
@@ -82,19 +82,6 @@ test('validateRunnerSequenceSteps requires finite x/y on every step', () => {
   );
 });
 
-test('validateRunnerSequenceSteps requires x2/y2 for drag steps', () => {
-  assert.throws(
-    () => validateRunnerSequenceSteps([tap(1, 2), { kind: 'drag', x: 3, y: 4 }]),
-    (error: unknown) => {
-      assert.ok(error instanceof AppError);
-      assert.equal(error.code, 'INVALID_ARGS');
-      assert.match(error.message, /step 1/);
-      assert.match(error.message, /drag/);
-      return true;
-    },
-  );
-});
-
 test('validateRunnerSequenceSteps accepts a low durationMs (runner clamps the floor)', () => {
   // `press --hold-ms 5` is legal CLI input (holdMs min 0); the runner clamps durationMs up to 16,
   // so the validator must not reject a below-floor duration here.
@@ -150,18 +137,18 @@ test('parseRunnerSequenceResult maps failedStepIndex to a deterministic AppError
           { ok: true, kind: 'tap' },
           {
             ok: false,
-            kind: 'drag',
+            kind: 'longPress',
             errorCode: 'UNSUPPORTED_OPERATION',
-            errorMessage: 'drag unsupported here',
+            errorMessage: 'long press unsupported here',
           },
         ],
       }),
     (error: unknown) => {
       assert.ok(error instanceof AppError);
       assert.equal(error.code, 'UNSUPPORTED_OPERATION');
-      assert.equal(error.message, 'drag unsupported here');
+      assert.equal(error.message, 'long press unsupported here');
       assert.equal(error.details?.failedStepIndex, 2);
-      assert.equal(error.details?.failedStepKind, 'drag');
+      assert.equal(error.details?.failedStepKind, 'longPress');
       assert.equal(error.details?.completedSteps, 2);
       assert.ok(Array.isArray(error.details?.sequenceResults));
       return true;
diff --git a/src/platforms/apple/core/runner/runner-command-manifest.ts b/src/platforms/apple/core/runner/runner-command-manifest.ts
index 1b7a49aae..0b23cb722 100644
--- a/src/platforms/apple/core/runner/runner-command-manifest.ts
+++ b/src/platforms/apple/core/runner/runner-command-manifest.ts
@@ -26,13 +26,12 @@ export const RUNNER_COMMAND_TRAIT_MANIFEST = {
   backSystem: 'default',
   home: 'default',
   rotate: 'default',
-  rotateGesture: 'default',
-  transformGesture: 'default',
+  gesture: 'preflightSkippableTouchMutation',
+  gestureViewport: 'readOnly',
   appSwitcher: 'default',
   keyboardDismiss: 'default',
   keyboardReturn: 'default',
   alert: 'readOnly',
-  pinch: 'default',
   sequence: 'preflightSkippableTouchMutation',
   recordStart: 'default',
   recordStop: 'default',
diff --git a/src/platforms/apple/core/runner/runner-contract.ts b/src/platforms/apple/core/runner/runner-contract.ts
index a838b24be..098e66c38 100644
--- a/src/platforms/apple/core/runner/runner-contract.ts
+++ b/src/platforms/apple/core/runner/runner-contract.ts
@@ -3,13 +3,12 @@ import { AppError } from '../../../../kernel/errors.ts';
 import type { ClickButton } from '../../../../core/click-button.ts';
 import type { DeviceRotation } from '../../../../contracts/device-rotation.ts';
 import type { ScrollDirection } from '../../../../contracts/scroll-gesture.ts';
+import type { GesturePlan } from '../../../../contracts/gesture-plan.ts';
 import type { ElementSelectorKey } from '../../../../core/interactor-types.ts';
 import { createRequestCanceledError, isRequestCanceled } from '../../../../request/cancel.ts';
 import { bootFailureHint, classifyBootFailure } from '../../../boot-diagnostics.ts';
 import type { RunnerSession } from './runner-session-types.ts';
 
-export type SynthesizedDragSemantics = 'swipe' | 'pan' | 'fling';
-
 const RUNNER_CACHE_RECOVERY_HINT =
   'If runner build products look stale or corrupted, run `pnpm clean:xcuitest` in a local checkout, or remove ~/.agent-device/apple-runner/derived, then retry.';
 
@@ -39,13 +38,12 @@ export type RunnerCommand = {
     | 'backSystem'
     | 'home'
     | 'rotate'
-    | 'rotateGesture'
-    | 'transformGesture'
+    | 'gesture'
+    | 'gestureViewport'
     | 'appSwitcher'
     | 'keyboardDismiss'
     | 'keyboardReturn'
     | 'alert'
-    | 'pinch'
     | 'sequence'
     | 'recordStart'
     | 'recordStop'
@@ -68,16 +66,13 @@ export type RunnerCommand = {
   remoteButton?: 'select' | 'menu' | 'home' | 'up' | 'down' | 'left' | 'right';
   x2?: number;
   y2?: number;
-  dx?: number;
-  dy?: number;
   durationMs?: number;
   direction?: ScrollDirection;
   amount?: number;
   pixels?: number;
   orientation?: DeviceRotation;
-  scale?: number;
-  degrees?: number;
-  velocity?: number;
+  /** Canonical pointer samples planned by the portable gesture runtime. */
+  gesturePlan?: GesturePlan;
   outPath?: string;
   fps?: number;
   maxSize?: number;
@@ -87,8 +82,6 @@ export type RunnerCommand = {
   raw?: boolean;
   fullscreen?: boolean;
   synthesized?: boolean;
-  /** Preserves the public gesture's timing semantics after it is lowered to runner `drag`. */
-  dragSemantics?: SynthesizedDragSemantics;
   steps?: RunnerSequenceStep[];
   /**
    * @deprecated Use textEntryMode: 'replace'. Kept for compatibility with older local runner clients.
@@ -98,15 +91,13 @@ export type RunnerCommand = {
 
 /**
  * One allowlisted coordinate gesture step inside a fused `sequence` runner command.
- * The kind set is intentionally narrow (tap/longPress/drag) and validated on both the
+ * The kind set is intentionally narrow (tap/doubleTap/longPress) and validated on both the
  * daemon and runner sides — see runner-sequence.ts (the single interpretation point).
  */
 export type RunnerSequenceStep = {
-  kind: 'tap' | 'doubleTap' | 'longPress' | 'drag';
+  kind: 'tap' | 'doubleTap' | 'longPress';
   x: number;
   y: number;
-  x2?: number;
-  y2?: number;
   durationMs?: number;
   pauseMs?: number;
   /**
@@ -114,8 +105,6 @@ export type RunnerSequenceStep = {
    * instead of the drag-based XCUICoordinate tapAt, matching the individual `tap` command.
    */
   synthesized?: boolean;
-  /** Preserves one-shot swipe timing when repeated swipes are fused into a sequence. */
-  dragSemantics?: SynthesizedDragSemantics;
 };
 
 export function isRetryableRunnerError(err: unknown): boolean {
diff --git a/src/platforms/apple/core/runner/runner-sequence.ts b/src/platforms/apple/core/runner/runner-sequence.ts
index c2692abd3..2d5311c52 100644
--- a/src/platforms/apple/core/runner/runner-sequence.ts
+++ b/src/platforms/apple/core/runner/runner-sequence.ts
@@ -1,7 +1,7 @@
 import { AppError, toAppErrorCode } from '../../../../kernel/errors.ts';
 import type { RunnerCommand, RunnerSequenceStep } from './runner-contract.ts';
 
-export const SEQUENCEABLE_RUNNER_STEP_KINDS = ['tap', 'doubleTap', 'longPress', 'drag'] as const;
+export const SEQUENCEABLE_RUNNER_STEP_KINDS = ['tap', 'doubleTap', 'longPress'] as const;
 export type SequenceableRunnerStepKind = (typeof SEQUENCEABLE_RUNNER_STEP_KINDS)[number];
 
 /**
@@ -88,9 +88,6 @@ function validateRunnerSequenceStep(step: RunnerSequenceStep, index: number): vo
       `sequence step ${index} (${step.kind}) requires finite x and y`,
     );
   }
-  if (step.kind === 'drag' && (!Number.isFinite(step.x2) || !Number.isFinite(step.y2))) {
-    throw invalidStep(index, step.kind, `sequence step ${index} (drag) requires finite x2 and y2`);
-  }
   if (step.durationMs !== undefined) {
     assertInRange(
       step.durationMs,
diff --git a/src/platforms/apple/interactions.ts b/src/platforms/apple/interactions.ts
index 4b34ad89c..95d502e67 100644
--- a/src/platforms/apple/interactions.ts
+++ b/src/platforms/apple/interactions.ts
@@ -4,12 +4,15 @@ import {
   normalizeScrollDurationMs,
   SCROLL_DURATION_MAX_MS,
 } from '../../contracts/scroll-command.ts';
+import { AppError } from '../../kernel/errors.ts';
+import { singlePointerPlanEndpoints, type GesturePlan } from '../../contracts/gesture-plan.ts';
+import { assertAppleMultiTouchSupported } from '../../contracts/apple-multitouch-support.ts';
 import { runAppleRunnerCommand } from './core/runner/runner-client.ts';
 import {
   buildRunnerSequenceCommand,
   parseRunnerSequenceResult,
 } from './core/runner/runner-sequence.ts';
-import type { RunnerCommand, SynthesizedDragSemantics } from './core/runner/runner-contract.ts';
+import type { RunnerCommand } from './core/runner/runner-contract.ts';
 import { appleRemotePressCommand } from './os/tvos/remote.ts';
 import { runMacosDesktopScroll } from './os/macos/desktop-scroll.ts';
 import {
@@ -29,34 +32,19 @@ export type AppleBackRunnerCommand = 'backInApp' | 'backSystem';
 type RunAppleRunnerCommand = typeof runAppleRunnerCommand;
 type RunnerOpts = RunnerCallOptions;
 
-const IOS_SWIPE_DEFAULT_DURATION_MS = 250;
-const IOS_SWIPE_MIN_DURATION_MS = 16;
-const IOS_SWIPE_MAX_DURATION_MS = 10_000;
-
-type IosDragCommandOptions = {
-  defaultDurationMs: number;
-  legacyDefaultDurationMs?: number;
-  synthesized?: boolean;
-  dragSemantics: SynthesizedDragSemantics;
-};
-
 type IosRunnerOverrides = Pick<
   Interactor,
   | 'tap'
   | 'tapElementSelector'
   | 'doubleTap'
-  | 'swipe'
-  | 'pan'
-  | 'fling'
   | 'longPress'
   | 'focus'
   | 'type'
   | 'fillElementSelector'
   | 'fill'
   | 'scroll'
-  | 'pinch'
-  | 'rotateGesture'
-  | 'transformGesture'
+  | 'performGesture'
+  | 'gestureViewport'
 >;
 
 export function resolveAppleBackRunnerCommand(mode?: BackMode): AppleBackRunnerCommand {
@@ -111,41 +99,6 @@ export function iosRunnerOverrides(
         parseRunnerSequenceResult(runnerResult);
         return runnerResult;
       },
-      swipe: async (x1, y1, x2, y2, durationMs) => {
-        return await runAppleRunnerCommand(
-          device,
-          iosDragCommand(device, ctx, x1, y1, x2, y2, durationMs, {
-            defaultDurationMs: IOS_SWIPE_DEFAULT_DURATION_MS,
-            synthesized: shouldUseSynthesizedIosGesture(device),
-            dragSemantics: 'swipe',
-          }),
-          runnerOpts,
-        );
-      },
-      pan: async (x1, y1, x2, y2, durationMs) => {
-        return await runAppleRunnerCommand(
-          device,
-          iosDragCommand(device, ctx, x1, y1, x2, y2, durationMs, {
-            defaultDurationMs: 500,
-            legacyDefaultDurationMs: 500,
-            synthesized: shouldUseSynthesizedIosGesture(device),
-            dragSemantics: 'pan',
-          }),
-          runnerOpts,
-        );
-      },
-      fling: async (x1, y1, x2, y2, durationMs) => {
-        return await runAppleRunnerCommand(
-          device,
-          iosDragCommand(device, ctx, x1, y1, x2, y2, durationMs, {
-            defaultDurationMs: 16,
-            legacyDefaultDurationMs: 16,
-            synthesized: shouldUseSynthesizedIosGesture(device),
-            dragSemantics: 'fling',
-          }),
-          runnerOpts,
-        );
-      },
       longPress: async (x, y, durationMs) => {
         return await runAppleRunnerCommand(
           device,
@@ -210,109 +163,105 @@ export function iosRunnerOverrides(
           options,
         );
       },
-      pinch: async (scale, x, y) => {
-        await runAppleRunnerCommand(
+      performGesture: async (plan) => await performGestureApple(device, ctx, runnerOpts, plan),
+      gestureViewport: async () => {
+        const result = await runAppleRunnerCommand(
           device,
-          {
-            command: 'pinch',
-            scale,
-            x,
-            y,
-            appBundleId: ctx.appBundleId,
-          },
-          runnerOpts,
-        );
-      },
-      rotateGesture: async (degrees, x, y, velocity) => {
-        await runAppleRunnerCommand(
-          device,
-          {
-            command: 'rotateGesture',
-            degrees,
-            x,
-            y,
-            velocity,
-            appBundleId: ctx.appBundleId,
-          },
-          runnerOpts,
-        );
-      },
-      transformGesture: async (options) => {
-        return await runAppleRunnerCommand(
-          device,
-          {
-            command: 'transformGesture',
-            x: options.x,
-            y: options.y,
-            dx: options.dx,
-            dy: options.dy,
-            scale: options.scale,
-            degrees: options.degrees,
-            durationMs: options.durationMs,
-            appBundleId: ctx.appBundleId,
-          },
+          { command: 'gestureViewport', appBundleId: ctx.appBundleId },
           runnerOpts,
         );
+        return readGestureViewport(result);
       },
     },
   };
 }
 
-function iosTapCommand(
+function readGestureViewport(result: Record<string, unknown>) {
+  const x = finiteNumber(result.x);
+  const y = finiteNumber(result.y);
+  const width = finiteNumber(result.x2);
+  const height = finiteNumber(result.y2);
+  if (
+    x === undefined ||
+    y === undefined ||
+    width === undefined ||
+    height === undefined ||
+    width <= 0 ||
+    height <= 0
+  ) {
+    throw new AppError('COMMAND_FAILED', 'Apple runner returned an invalid gesture viewport');
+  }
+  return { x, y, width, height };
+}
+
+function finiteNumber(value: unknown): number | undefined {
+  return typeof value === 'number' && Number.isFinite(value) ? value : undefined;
+}
+
+/** Executes the portable pointer plan without regenerating platform geometry. */
+export async function performGestureApple(
   device: DeviceInfo,
   ctx: RunnerContext,
-  x: number,
-  y: number,
-): RunnerCommand {
-  return {
-    command: 'tap',
-    x,
-    y,
-    ...(shouldUseSynthesizedIosGesture(device) ? { synthesized: true } : {}),
-    appBundleId: ctx.appBundleId,
-  };
+  runnerOpts: RunnerOpts,
+  plan: GesturePlan,
+): Promise<Record<string, unknown>> {
+  if (plan.topology === 'two') assertAppleMultiTouchSupported(device, plan.intent);
+  if (plan.topology === 'single' && isMacOs(device)) {
+    const { start: first, end: last } = singlePointerPlanEndpoints(plan);
+    return await runAppleRunnerCommand(
+      device,
+      {
+        command: 'drag',
+        x: first.x,
+        y: first.y,
+        x2: last.x,
+        y2: last.y,
+        durationMs: plan.durationMs,
+        appBundleId: ctx.appBundleId,
+      },
+      runnerOpts,
+    );
+  }
+  if (plan.topology === 'single' && isTvOsDevice(device)) {
+    const { start: first, end: last } = singlePointerPlanEndpoints(plan);
+    return await runAppleRunnerCommand(
+      device,
+      { command: 'swipe', direction: dominantDirection(first, last), appBundleId: ctx.appBundleId },
+      runnerOpts,
+    );
+  }
+  return await runAppleRunnerCommand(
+    device,
+    { command: 'gesture', gesturePlan: plan, appBundleId: ctx.appBundleId },
+    runnerOpts,
+  );
 }
 
-function shouldUseSynthesizedIosGesture(device: DeviceInfo): boolean {
-  // Two-finger HID synthesis is for touch-input iOS only; the tvOS leaf has no touch.
-  return isIosFamily(device) && !isTvOsDevice(device);
+function dominantDirection(from: { x: number; y: number }, to: { x: number; y: number }) {
+  const dx = to.x - from.x;
+  const dy = to.y - from.y;
+  if (Math.abs(dx) >= Math.abs(dy)) return dx >= 0 ? ('right' as const) : ('left' as const);
+  return dy >= 0 ? ('down' as const) : ('up' as const);
 }
 
-function iosDragCommand(
+function iosTapCommand(
   device: DeviceInfo,
   ctx: RunnerContext,
   x: number,
   y: number,
-  x2: number,
-  y2: number,
-  durationMs: number | undefined,
-  options: IosDragCommandOptions,
 ): RunnerCommand {
-  const normalizedDurationMs =
-    isIosFamily(device) && !isTvOsDevice(device)
-      ? iosGestureDurationMs(durationMs, options.defaultDurationMs)
-      : (durationMs ?? options.legacyDefaultDurationMs);
   return {
-    command: 'drag',
+    command: 'tap',
     x,
     y,
-    x2,
-    y2,
-    ...(normalizedDurationMs !== undefined ? { durationMs: normalizedDurationMs } : {}),
-    ...(options.synthesized === true
-      ? { synthesized: true, dragSemantics: options.dragSemantics }
-      : {}),
+    ...(shouldUseSynthesizedIosGesture(device) ? { synthesized: true } : {}),
     appBundleId: ctx.appBundleId,
   };
 }
 
-function iosGestureDurationMs(durationMs: number | undefined, defaultDurationMs: number): number {
-  if (durationMs === undefined) return defaultDurationMs;
-
-  return Math.min(
-    IOS_SWIPE_MAX_DURATION_MS,
-    Math.max(IOS_SWIPE_MIN_DURATION_MS, Math.round(durationMs)),
-  );
+function shouldUseSynthesizedIosGesture(device: DeviceInfo): boolean {
+  // Two-finger HID synthesis is for touch-input iOS only; the tvOS leaf has no touch.
+  return isIosFamily(device) && !isTvOsDevice(device);
 }
 
 async function runAppleScroll(
diff --git a/src/platforms/apple/plugin.ts b/src/platforms/apple/plugin.ts
index 0924eb9fd..73cf7f26e 100644
--- a/src/platforms/apple/plugin.ts
+++ b/src/platforms/apple/plugin.ts
@@ -54,16 +54,6 @@ const supportsHostOrSimulatorSurface = (device: DeviceInfo): boolean => {
     : device.kind === 'simulator';
 };
 
-// `pinch`/`rotate-gesture`/`transform-gesture` (was `android || (ios && simulator &&
-// target !== 'tv')`). Apple: the OS multi-touch model AND a simulator (physical iOS
-// cannot synthesize). Off Apple: only `android`.
-const supportsSynthesisGesture = (device: DeviceInfo): boolean => {
-  const caps = appleOsCapabilities(device);
-  return caps
-    ? caps.multiTouchSynthesis && device.kind === 'simulator'
-    : device.platform === 'android';
-};
-
 // `tv-remote` is Android-TV or tvOS only. Off Apple this preserves the Android-TV
 // branch so the relocated Apple closure stays equivalent to the full original
 // supports predicate under the parity guard; the closure is only consulted for Apple
@@ -73,19 +63,6 @@ const supportsTvRemote = (device: DeviceInfo): boolean => {
   return isTvOsDevice(device);
 };
 
-const synthesisGestureUnsupportedHint = (device: DeviceInfo): string | undefined => {
-  const caps = appleOsCapabilities(device);
-  if (!caps) return undefined; // non-Apple: no multi-touch gate, no hint
-  // OS-level block (macOS: no multi-touch; tvOS: no touch) comes from the table.
-  if (caps.multiTouchUnsupportedHint) return caps.multiTouchUnsupportedHint;
-  // iOS family: multi-touch exists but synthesis is simulator-only — the remaining
-  // block is the kind-shaped physical-device case, kept device-shaped in the leaf
-  // rather than flattened into the table (do-not-flatten; see docs/adr/0009).
-  if (device.kind === 'device')
-    return 'Two-finger gesture synthesis is iOS-simulator only — not available on physical iOS devices.';
-  return undefined;
-};
-
 // Per-command support gates the Apple family applies by default, keyed exactly as in
 // the command-descriptor registry (a command absent here has no Apple gate).
 const APPLE_SUPPORTS_BY_DEFAULT: Record<string, (device: DeviceInfo) => boolean> = {
@@ -108,9 +85,6 @@ const APPLE_SUPPORTS_BY_DEFAULT: Record<string, (device: DeviceInfo) => boolean>
   [PUBLIC_COMMANDS.settings]: (device) =>
     device.platform === 'android' || supportsHostOrSimulatorSurface(device),
   [PUBLIC_COMMANDS.audio]: isAudioProbeSupportedDevice,
-  pinch: supportsSynthesisGesture,
-  'rotate-gesture': supportsSynthesisGesture,
-  'transform-gesture': supportsSynthesisGesture,
 };
 
 const APPLE_UNSUPPORTED_HINT_BY_DEFAULT: Record<
@@ -127,9 +101,6 @@ const APPLE_UNSUPPORTED_HINT_BY_DEFAULT: Record<
         : isTvOsDevice(device)
           ? undefined
           : 'tv-remote is supported only on tvOS devices.',
-  pinch: synthesisGestureUnsupportedHint,
-  'rotate-gesture': synthesisGestureUnsupportedHint,
-  'transform-gesture': synthesisGestureUnsupportedHint,
 };
 
 // The Apple plugin WRAPS today's existing factories (its `createInteractor` in
diff --git a/src/replay/__tests__/script.test.ts b/src/replay/__tests__/script.test.ts
index 6f4ed1830..8e5788b0a 100644
--- a/src/replay/__tests__/script.test.ts
+++ b/src/replay/__tests__/script.test.ts
@@ -136,7 +136,7 @@ test('snapshot replay script writes interactive refresh flags', () => {
 test('gesture replay script parses pan, fling, swipe, pinch, and rotate gesture commands', () => {
   const parsed = parseReplayScriptDetailed(
     [
-      'gesture pan 195 443 80 0',
+      'gesture pan 195 443 80 0 --pointer-count 2',
       'wait "pan changed yes" 5000',
       'gesture fling right 195 443 180',
       'gesture swipe right-edge 300',
@@ -151,6 +151,7 @@ test('gesture replay script parses pan, fling, swipe, pinch, and rotate gesture
     ['gesture', 'wait', 'gesture', 'gesture', 'gesture', 'gesture'],
   );
   assert.deepEqual(parsed[0]?.positionals, ['pan', '195', '443', '80', '0']);
+  assert.equal(parsed[0]?.flags.pointerCount, 2);
   assert.deepEqual(parsed[2]?.positionals, ['fling', 'right', '195', '443', '180']);
   assert.deepEqual(parsed[3]?.positionals, ['swipe', 'right-edge', '300']);
   assert.deepEqual(parsed[4]?.positionals, ['pinch', '1.25', '195', '443']);
diff --git a/src/replay/script-utils.ts b/src/replay/script-utils.ts
index 28a6875e8..b486b42a6 100644
--- a/src/replay/script-utils.ts
+++ b/src/replay/script-utils.ts
@@ -34,6 +34,9 @@ const SWIPE_NUMERIC_FLAG_MAP = new Map<string, 'count' | 'pauseMs'>([
   ['--count', 'count'],
   ['--pause-ms', 'pauseMs'],
 ]);
+const GESTURE_NUMERIC_FLAG_MAP = new Map<string, 'pointerCount'>([
+  ['--pointer-count', 'pointerCount'],
+]);
 
 const TYPING_NUMERIC_FLAG_MAP = new Map<string, 'delayMs'>([['--delay-ms', 'delayMs']]);
 
@@ -141,6 +144,12 @@ export function appendScriptSeriesFlags(
     }
     return;
   }
+  if (action.command === 'gesture') {
+    if (typeof flags.pointerCount === 'number') {
+      parts.push('--pointer-count', String(flags.pointerCount));
+    }
+    return;
+  }
   if (isTypingCommand(action.command) && typeof flags.delayMs === 'number') {
     parts.push('--delay-ms', String(flags.delayMs));
   }
@@ -255,9 +264,11 @@ export function parseReplaySeriesFlags(
     ? CLICK_LIKE_NUMERIC_FLAG_MAP
     : command === 'swipe'
       ? SWIPE_NUMERIC_FLAG_MAP
-      : isTypingCommand(command)
-        ? TYPING_NUMERIC_FLAG_MAP
-        : undefined;
+      : command === 'gesture'
+        ? GESTURE_NUMERIC_FLAG_MAP
+        : isTypingCommand(command)
+          ? TYPING_NUMERIC_FLAG_MAP
+          : undefined;
 
   for (let index = 0; index < args.length; index += 1) {
     const token = args[index]!;
diff --git a/src/replay/script.ts b/src/replay/script.ts
index 1c0ee7db6..8378e6104 100644
--- a/src/replay/script.ts
+++ b/src/replay/script.ts
@@ -369,7 +369,7 @@ function parseReplayScriptLine(line: string): SessionAction | null {
     return action;
   }
 
-  if (command === 'swipe' || command === 'type') {
+  if (command === 'swipe' || command === 'type' || command === 'gesture') {
     const parsed = parseReplaySeriesFlags(command, args);
     Object.assign(action.flags, parsed.flags);
     action.positionals = parsed.positionals;
diff --git a/test/integration/provider-scenarios/android-lifecycle.test.ts b/test/integration/provider-scenarios/android-lifecycle.test.ts
index 4625f952d..63202ac17 100644
--- a/test/integration/provider-scenarios/android-lifecycle.test.ts
+++ b/test/integration/provider-scenarios/android-lifecycle.test.ts
@@ -92,13 +92,38 @@ test('Provider-backed integration Android touch provider handles multi-touch ges
         ...world.selection,
       });
 
+      const oneFingerPan = await client.interactions.pan({
+        x: 195,
+        y: 320,
+        dx: 20,
+        dy: 0,
+        durationMs: 500,
+        ...world.selection,
+      });
+      assert.equal(oneFingerPan.pointerCount, 1);
+      assert.equal(world.daemon.session()?.actions.at(-1)?.flags.pointerCount, undefined);
+
+      const twoFingerPan = await client.interactions.pan({
+        x: 195,
+        y: 320,
+        dx: 40,
+        dy: -20,
+        pointerCount: 2,
+        durationMs: 500,
+        ...world.selection,
+      });
+      assert.equal(twoFingerPan.pointerCount, 2);
+      assert.equal(twoFingerPan.backend, 'provider-native-touch');
+      assert.equal(world.daemon.session()?.actions.at(-1)?.flags.pointerCount, 2);
+
       const pinch = await client.interactions.pinch({
         scale: 2,
         x: 195,
         y: 320,
         ...world.selection,
       });
-      assert.equal(pinch.scale, 2);
+      assert.equal(pinch.kind, 'pinch');
+      assert.equal(pinch.pointerCount, 2);
       assert.equal(pinch.backend, 'provider-native-touch');
 
       const rotate = await client.interactions.rotateGesture({
@@ -107,7 +132,8 @@ test('Provider-backed integration Android touch provider handles multi-touch ges
         y: 320,
         ...world.selection,
       });
-      assert.equal(rotate.degrees, 145);
+      assert.equal(rotate.kind, 'rotate');
+      assert.equal(rotate.pointerCount, 2);
       assert.equal(rotate.backend, 'provider-native-touch');
 
       const transform = await client.interactions.transformGesture({
@@ -120,28 +146,32 @@ test('Provider-backed integration Android touch provider handles multi-touch ges
         durationMs: 700,
         ...world.selection,
       });
-      assert.equal(transform.scale, 1.5);
-      assert.equal(transform.degrees, 35);
+      assert.equal(transform.kind, 'transform');
+      assert.equal(transform.pointerCount, 2);
       assert.equal(transform.backend, 'provider-native-touch');
 
-      assert.deepEqual(world.touchInjectionCalls, [
-        { kind: 'swipe', x1: 340, y1: 400, x2: 60, y2: 400, durationMs: 300 },
-        { kind: 'pinch', x: 195, y: 320, scale: 2, durationMs: undefined },
-        { kind: 'rotate', x: 195, y: 320, degrees: 145, durationMs: undefined },
-        {
-          kind: 'transform',
-          x: 195,
-          y: 320,
-          dx: 40,
-          dy: -20,
-          scale: 1.5,
-          degrees: 35,
-          durationMs: 700,
-        },
+      const touchCalls = world.touchInjectionCalls.map((plan) => ({
+        topology: plan.topology,
+        intent: plan.intent,
+        pointerCount: plan.pointers.length,
+        durationMs: plan.durationMs,
+      }));
+      assert.deepEqual(touchCalls, [
+        { topology: 'single', intent: 'pan', pointerCount: 1, durationMs: 300 },
+        { topology: 'single', intent: 'pan', pointerCount: 1, durationMs: 500 },
+        { topology: 'two', intent: 'pan', pointerCount: 2, durationMs: 500 },
+        { topology: 'two', intent: 'pinch', pointerCount: 2, durationMs: 300 },
+        { topology: 'two', intent: 'rotate', pointerCount: 2, durationMs: 784 },
+        { topology: 'two', intent: 'transform', pointerCount: 2, durationMs: 700 },
       ]);
+      assert.equal(world.gestureViewportCalls, 6);
       assert.equal(
         world.adbCalls.some(
-          (call) => call[0] === 'shell' && call[1] === 'am' && call[2] === 'instrument',
+          (call) =>
+            call[0] === 'shell' &&
+            call[1] === 'am' &&
+            call[2] === 'instrument' &&
+            call.includes('com.callstack.agentdevice.multitouchhelper/.MultiTouchInstrumentation'),
         ),
         false,
         JSON.stringify(world.adbCalls),
@@ -1067,6 +1097,15 @@ async function runAndroidCaptureInteractionAndReplayWorkflow(
     pattern: 'ping-pong',
     ...selection,
   });
+  assert.deepEqual(swipe.from, { x: 20, y: 200 });
+  assert.deepEqual(swipe.to, { x: 20, y: 100 });
+  assert.equal(swipe.x1, 20);
+  assert.equal(swipe.y1, 200);
+  assert.equal(swipe.x2, 20);
+  assert.equal(swipe.y2, 100);
+  assert.equal(swipe.durationMs, 100);
+  assert.equal(swipe.effectiveDurationMs, 100);
+  assert.equal(swipe.timingMode, 'direct');
   assert.equal(swipe.count, 2);
   assert.equal(swipe.pauseMs, 1);
   assert.equal(swipe.pattern, 'ping-pong');
@@ -1079,10 +1118,10 @@ async function runAndroidCaptureInteractionAndReplayWorkflow(
     durationMs: 400,
     ...selection,
   });
-  assert.equal(pan.x, 100);
-  assert.equal(pan.y, 200);
-  assert.equal(pan.x2, 150);
-  assert.equal(pan.y2, 180);
+  assert.equal(pan.kind, 'pan');
+  assert.equal(pan.pointerCount, 1);
+  assert.deepEqual(pan.from, { x: 100, y: 200 });
+  assert.deepEqual(pan.to, { x: 150, y: 180 });
   assert.equal(pan.durationMs, 400);
 
   const fling = await client.interactions.fling({
@@ -1092,12 +1131,11 @@ async function runAndroidCaptureInteractionAndReplayWorkflow(
     distance: 180,
     ...selection,
   });
-  assert.equal(fling.direction, 'right');
-  assert.equal(fling.x, 100);
-  assert.equal(fling.y, 200);
-  assert.equal(fling.x2, 280);
-  assert.equal(fling.y2, 200);
-  assert.equal(fling.distance, 180);
+  assert.equal(fling.kind, 'fling');
+  assert.equal(fling.pointerCount, 1);
+  assert.deepEqual(fling.from, { x: 100, y: 200 });
+  assert.deepEqual(fling.to, { x: 280, y: 200 });
+  assert.equal(fling.durationMs, 100);
 
   const batch = await client.batch.run({
     steps: [
@@ -1440,10 +1478,10 @@ function assertAndroidInteractionContract(world: AndroidSettingsWorld): void {
   assertCommandCall(adbCalls, ['shell', 'input', 'tap', '50', '60']);
   assertCommandCall(adbCalls, ['shell', 'input', 'swipe', '30', '40', '30', '40', '5']);
   assertCommandCall(adbCalls, ['shell', 'input', 'swipe', '31', '40', '31', '40', '5']);
-  assertCommandCall(adbCalls, ['shell', 'input', 'swipe', '20', '200', '20', '100', '250']);
-  assertCommandCall(adbCalls, ['shell', 'input', 'swipe', '20', '100', '20', '200', '250']);
+  assertCommandCall(adbCalls, ['shell', 'input', 'swipe', '20', '200', '20', '100', '100']);
+  assertCommandCall(adbCalls, ['shell', 'input', 'swipe', '20', '100', '20', '200', '100']);
   assertCommandCall(adbCalls, ['shell', 'input', 'swipe', '100', '200', '150', '180', '400']);
-  assertCommandCall(adbCalls, ['shell', 'input', 'swipe', '100', '200', '280', '200', '50']);
+  assertCommandCall(adbCalls, ['shell', 'input', 'swipe', '100', '200', '280', '200', '100']);
   assert.equal(
     adbCalls.filter((call) => arrayEqual(call, ['shell', 'input', 'tap', '88', '151'])).length,
     5,
diff --git a/test/integration/provider-scenarios/android-test-suite.test.ts b/test/integration/provider-scenarios/android-test-suite.test.ts
index e71ab7826..02e38f0de 100644
--- a/test/integration/provider-scenarios/android-test-suite.test.ts
+++ b/test/integration/provider-scenarios/android-test-suite.test.ts
@@ -122,7 +122,8 @@ test('Provider-backed integration Android Maestro replay uses fresh snapshots an
         world.adbCalls.find((call) => call.slice(0, 3).join(' ') === 'shell input swipe'),
         ['shell', 'input', 'swipe', '351', '300', '39', '300', '300'],
       );
-      assertSnapshotCountInRange(snapshots, 2, 3);
+      // Percentage resolution snapshots remain fresh; gesture planning uses the provider viewport.
+      assertSnapshotCountInRange(snapshots, 3, 5);
     },
   );
 });
diff --git a/test/integration/provider-scenarios/android-world.ts b/test/integration/provider-scenarios/android-world.ts
index ecd3d52c3..31cde866e 100644
--- a/test/integration/provider-scenarios/android-world.ts
+++ b/test/integration/provider-scenarios/android-world.ts
@@ -32,6 +32,7 @@ type AndroidSettingsWorld = {
   ) => unknown
     ? TRequest[]
     : never;
+  gestureViewportCalls: number;
   inventoryRequests: DeviceInventoryRequest[];
   apkInstallCalls: Array<{ apkPath: string; replace?: boolean }>;
   bundleInstallCalls: Array<{ bundlePath: string; mode: string }>;
@@ -56,6 +57,7 @@ export async function createAndroidSettingsWorld(options?: {
   const adbCalls: string[][] = [];
   const textInjectionCalls: AndroidSettingsWorld['textInjectionCalls'] = [];
   const touchInjectionCalls: AndroidSettingsWorld['touchInjectionCalls'] = [];
+  let gestureViewportCalls = 0;
   const inventoryRequests: DeviceInventoryRequest[] = [];
   const apkInstallCalls: Array<{ apkPath: string; replace?: boolean }> = [];
   const bundleInstallCalls: Array<{ bundlePath: string; mode: string }> = [];
@@ -77,6 +79,10 @@ export async function createAndroidSettingsWorld(options?: {
     packageName: 'io.example.demo_manifest',
   });
   const adbProvider: AndroidAdbProvider = {
+    gestureViewport: async () => {
+      gestureViewportCalls += 1;
+      return { x: 0, y: 0, width: 390, height: 600 };
+    },
     exec: async (args) => {
       adbCalls.push([...args]);
       options?.onAdbExec?.([...args]);
@@ -156,6 +162,9 @@ export async function createAndroidSettingsWorld(options?: {
     adbCalls,
     textInjectionCalls,
     touchInjectionCalls,
+    get gestureViewportCalls() {
+      return gestureViewportCalls;
+    },
     inventoryRequests,
     apkInstallCalls,
     bundleInstallCalls,
@@ -350,6 +359,9 @@ function androidForegroundWindowDump(foreground: string | null): string {
 }
 
 function androidMetricsAdbResult(key: string): AndroidAdbResult | undefined {
+  if (key === 'shell wm size') {
+    return { stdout: 'Physical size: 1080x1920\n', stderr: '', exitCode: 0 };
+  }
   if (key === 'shell dumpsys cpuinfo') {
     return {
       stdout: [
diff --git a/test/integration/provider-scenarios/harness.ts b/test/integration/provider-scenarios/harness.ts
index 71a5fb5b0..196b73a05 100644
--- a/test/integration/provider-scenarios/harness.ts
+++ b/test/integration/provider-scenarios/harness.ts
@@ -31,6 +31,7 @@ export type ProviderScenarioHarness = {
     positionals?: string[],
     flags?: DaemonRequest['flags'],
     options?: {
+      input?: DaemonRequest['input'];
       meta?: DaemonRequest['meta'];
       runtime?: DaemonRequest['runtime'];
       session?: string;
@@ -68,6 +69,7 @@ export async function createProviderScenarioHarness(
       session: req.session ?? 'default',
       command: req.command,
       positionals: req.positionals,
+      input: req.input,
       flags: req.flags,
       runtime: req.runtime,
       meta: req.meta as DaemonRequest['meta'],
@@ -146,6 +148,7 @@ function commandRequest(
   positionals: string[] = [],
   flags: DaemonRequest['flags'] = {},
   options: {
+    input?: DaemonRequest['input'];
     meta?: DaemonRequest['meta'];
     runtime?: DaemonRequest['runtime'];
     session?: string;
@@ -156,6 +159,7 @@ function commandRequest(
     session: options.session ?? 'default',
     command,
     positionals,
+    input: options.input,
     flags,
     runtime: options.runtime,
     meta: options.meta,
diff --git a/test/integration/provider-scenarios/ios-lifecycle.test.ts b/test/integration/provider-scenarios/ios-lifecycle.test.ts
index 490f013fd..71d90a417 100644
--- a/test/integration/provider-scenarios/ios-lifecycle.test.ts
+++ b/test/integration/provider-scenarios/ios-lifecycle.test.ts
@@ -128,48 +128,79 @@ test('Provider-backed integration iOS Settings flow uses scripted simctl and run
         {
           name: 'pinch current app',
           command: 'gesture',
-          positionals: ['pinch', '0.8', '196', '122'],
-          expectData: { scale: 0.8, x: 196, y: 122 },
+          input: { kind: 'pinch', scale: 0.8, origin: { x: 196, y: 122 } },
+          expectData: {
+            kind: 'pinch',
+            durationMs: 300,
+            pointerCount: 2,
+            from: { x: 196, y: 122 },
+            to: { x: 196, y: 122 },
+          },
         },
         {
           name: 'pan current app',
           command: 'gesture',
-          positionals: ['pan', '196', '122', '80', '0', '500'],
-          expectData: { x: 196, y: 122, dx: 80, dy: 0, x2: 276, y2: 122, durationMs: 500 },
+          input: {
+            kind: 'pan',
+            origin: { x: 196, y: 122 },
+            delta: { x: 80, y: 0 },
+            durationMs: 500,
+          },
+          expectData: {
+            kind: 'pan',
+            durationMs: 500,
+            pointerCount: 1,
+            from: { x: 196, y: 122 },
+            to: { x: 276, y: 122 },
+          },
         },
         {
           name: 'fling current app',
           command: 'gesture',
-          positionals: ['fling', 'right', '196', '122', '180'],
-          expectData: {
+          input: {
+            kind: 'fling',
             direction: 'right',
-            x: 196,
-            y: 122,
-            x2: 376,
-            y2: 122,
+            origin: { x: 196, y: 122 },
             distance: 180,
-            durationMs: 50,
+          },
+          expectData: {
+            kind: 'fling',
+            durationMs: 100,
+            pointerCount: 1,
+            from: { x: 196, y: 122 },
+            to: { x: 376, y: 122 },
           },
         },
         {
           name: 'rotate current app content',
           command: 'gesture',
-          positionals: ['rotate', '35', '196', '122'],
-          expectData: { degrees: 35, x: 196, y: 122, velocity: 1 },
+          input: { kind: 'rotate', degrees: 35, origin: { x: 196, y: 122 } },
+          expectData: {
+            kind: 'rotate',
+            durationMs: 300,
+            pointerCount: 2,
+            from: { x: 196, y: 122 },
+            to: { x: 196, y: 122 },
+          },
         },
         {
           name: 'transform current app content',
           command: 'gesture',
-          positionals: ['transform', '196', '122', '40', '-20', '1.5', '35', '700'],
-          expectData: {
-            x: 196,
-            y: 122,
-            dx: 40,
-            dy: -20,
+          input: {
+            kind: 'transform',
+            origin: { x: 196, y: 122 },
+            delta: { x: 40, y: -20 },
             scale: 1.5,
             degrees: 35,
             durationMs: 700,
           },
+          expectData: {
+            kind: 'transform',
+            durationMs: 700,
+            pointerCount: 2,
+            from: { x: 196, y: 122 },
+            to: { x: 236, y: 102 },
+          },
         },
         {
           name: 'get ref attrs',
diff --git a/test/integration/provider-scenarios/ios-world.ts b/test/integration/provider-scenarios/ios-world.ts
index f666f5d3a..c630fc3ae 100644
--- a/test/integration/provider-scenarios/ios-world.ts
+++ b/test/integration/provider-scenarios/ios-world.ts
@@ -1,6 +1,7 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import type { DeviceInventoryRequest } from '../../../src/core/dispatch-resolve.ts';
+import { buildGesturePlan } from '../../../src/contracts/gesture-plan.ts';
 import type { RawSnapshotNode } from '../../../src/kernel/snapshot.ts';
 import type { ProviderScenarioTranscript } from './transcript.ts';
 import {
@@ -26,6 +27,8 @@ type IosSettingsWorld = {
   close: () => Promise<void>;
 };
 
+const IOS_SETTINGS_VIEWPORT = { x: 0, y: 0, width: 393, height: 852 } as const;
+
 export async function createIosSettingsWorld(): Promise<IosSettingsWorld> {
   const { tempRoot, appPath } = createDemoIosApp('agent-device-provider-scenario-ios-deploy-');
   const inventoryRequests: DeviceInventoryRequest[] = [];
@@ -38,7 +41,6 @@ export async function createIosSettingsWorld(): Promise<IosSettingsWorld> {
       result: { uptimeMs: 42 },
     },
     runnerSnapshot(),
-    runnerSnapshot(),
     {
       command: 'ios.runner.tap',
       deviceId: PROVIDER_SCENARIO_IOS_SIMULATOR.id,
@@ -52,85 +54,94 @@ export async function createIosSettingsWorld(): Promise<IosSettingsWorld> {
       },
       result: { tapped: true },
     },
+    runnerSnapshot(),
+    runnerGestureViewport(),
     {
-      command: 'ios.runner.pinch',
+      command: 'ios.runner.gesture',
       deviceId: PROVIDER_SCENARIO_IOS_SIMULATOR.id,
       platform: 'apple',
       request: {
-        command: 'pinch',
-        scale: 0.8,
-        x: 196,
-        y: 122,
+        command: 'gesture',
+        gesturePlan: buildGesturePlan(
+          { intent: 'pinch', origin: { x: 196, y: 122 }, scale: 0.8 },
+          IOS_SETTINGS_VIEWPORT,
+        ),
         appBundleId: 'com.apple.Preferences',
       },
       result: { pinched: true },
     },
+    runnerGestureViewport(),
     {
-      command: 'ios.runner.drag',
+      command: 'ios.runner.gesture',
       deviceId: PROVIDER_SCENARIO_IOS_SIMULATOR.id,
       platform: 'apple',
       request: {
-        command: 'drag',
-        x: 196,
-        y: 122,
-        x2: 276,
-        y2: 122,
-        durationMs: 500,
-        synthesized: true,
-        dragSemantics: 'pan',
+        command: 'gesture',
+        gesturePlan: buildGesturePlan(
+          {
+            intent: 'pan',
+            origin: { x: 196, y: 122 },
+            delta: { x: 80, y: 0 },
+            durationMs: 500,
+          },
+          IOS_SETTINGS_VIEWPORT,
+        ),
         appBundleId: 'com.apple.Preferences',
       },
       result: { dragged: true },
     },
+    runnerGestureViewport(),
     {
-      command: 'ios.runner.drag',
+      command: 'ios.runner.gesture',
       deviceId: PROVIDER_SCENARIO_IOS_SIMULATOR.id,
       platform: 'apple',
       request: {
-        command: 'drag',
-        x: 196,
-        y: 122,
-        x2: 376,
-        y2: 122,
-        durationMs: 50,
-        synthesized: true,
-        dragSemantics: 'fling',
+        command: 'gesture',
+        gesturePlan: buildGesturePlan(
+          { intent: 'fling', direction: 'right', origin: { x: 196, y: 122 }, distance: 180 },
+          IOS_SETTINGS_VIEWPORT,
+        ),
         appBundleId: 'com.apple.Preferences',
       },
       result: { flung: true },
     },
+    runnerGestureViewport(),
     {
-      command: 'ios.runner.rotateGesture',
+      command: 'ios.runner.gesture',
       deviceId: PROVIDER_SCENARIO_IOS_SIMULATOR.id,
       platform: 'apple',
       request: {
-        command: 'rotateGesture',
-        degrees: 35,
-        x: 196,
-        y: 122,
-        velocity: 1,
+        command: 'gesture',
+        gesturePlan: buildGesturePlan(
+          { intent: 'rotate', origin: { x: 196, y: 122 }, degrees: 35 },
+          IOS_SETTINGS_VIEWPORT,
+        ),
         appBundleId: 'com.apple.Preferences',
       },
       result: { rotated: true },
     },
+    runnerGestureViewport(),
     {
-      command: 'ios.runner.transformGesture',
+      command: 'ios.runner.gesture',
       deviceId: PROVIDER_SCENARIO_IOS_SIMULATOR.id,
       platform: 'apple',
       request: {
-        command: 'transformGesture',
-        x: 196,
-        y: 122,
-        dx: 40,
-        dy: -20,
-        scale: 1.5,
-        degrees: 35,
-        durationMs: 700,
+        command: 'gesture',
+        gesturePlan: buildGesturePlan(
+          {
+            intent: 'transform',
+            origin: { x: 196, y: 122 },
+            delta: { x: 40, y: -20 },
+            scale: 1.5,
+            degrees: 35,
+            durationMs: 700,
+          },
+          IOS_SETTINGS_VIEWPORT,
+        ),
         appBundleId: 'com.apple.Preferences',
       },
       result: { transformed: true },
     },
-    runnerSnapshot(),
     {
       command: 'ios.runner.querySelector',
       deviceId: PROVIDER_SCENARIO_IOS_SIMULATOR.id,
@@ -156,6 +167,7 @@ export async function createIosSettingsWorld(): Promise<IosSettingsWorld> {
         ],
       },
     },
+    runnerSnapshot(),
     {
       command: 'ios.runner.findText',
       deviceId: PROVIDER_SCENARIO_IOS_SIMULATOR.id,
@@ -369,12 +381,39 @@ function runnerSnapshot() {
           enabled: true,
           hittable: true,
         },
+        {
+          index: 1,
+          type: 'XCUIElementTypeApplication',
+          label: 'Settings',
+          identifier: 'com.apple.Preferences',
+          rect: IOS_SETTINGS_VIEWPORT,
+          enabled: true,
+          hittable: true,
+        },
       ],
       truncated: false,
     },
   };
 }
 
+function runnerGestureViewport() {
+  return {
+    command: 'ios.runner.gestureViewport',
+    deviceId: PROVIDER_SCENARIO_IOS_SIMULATOR.id,
+    platform: 'apple' as const,
+    request: {
+      command: 'gestureViewport',
+      appBundleId: 'com.apple.Preferences',
+    },
+    result: {
+      x: IOS_SETTINGS_VIEWPORT.x,
+      y: IOS_SETTINGS_VIEWPORT.y,
+      x2: IOS_SETTINGS_VIEWPORT.width,
+      y2: IOS_SETTINGS_VIEWPORT.height,
+    },
+  };
+}
+
 function bottomTabsContactSnapshotNodes(): RawSnapshotNode[] {
   return [
     {
diff --git a/test/integration/provider-scenarios/linux-desktop.test.ts b/test/integration/provider-scenarios/linux-desktop.test.ts
index 77b09b6e7..0e882586c 100644
--- a/test/integration/provider-scenarios/linux-desktop.test.ts
+++ b/test/integration/provider-scenarios/linux-desktop.test.ts
@@ -123,8 +123,18 @@ test('Provider-backed integration Linux desktop flow uses semantic desktop and i
           {
             name: 'swipe coordinates',
             command: 'swipe',
-            positionals: ['10', '20', '30', '40', '16'],
-            expectData: { timingMode: 'direct' },
+            input: {
+              from: { x: 10, y: 20 },
+              to: { x: 30, y: 40 },
+              durationMs: 16,
+            },
+            expectData: {
+              kind: 'pan',
+              durationMs: 16,
+              pointerCount: 1,
+              from: { x: 10, y: 20 },
+              to: { x: 30, y: 40 },
+            },
           },
           {
             name: 'fill snapshot ref',
diff --git a/test/integration/provider-scenarios/scenario.ts b/test/integration/provider-scenarios/scenario.ts
index 6ec04f832..0d67f9931 100644
--- a/test/integration/provider-scenarios/scenario.ts
+++ b/test/integration/provider-scenarios/scenario.ts
@@ -15,6 +15,7 @@ export type ProviderScenarioDefaults = {
 export type ProviderScenarioStep = {
   name: string;
   command: string;
+  input?: DaemonRequest['input'];
   positionals?: string[];
   flags?: DaemonRequest['flags'];
   meta?: DaemonRequest['meta'];
@@ -53,6 +54,7 @@ export async function runProviderScenario(
         ...step.flags,
       },
       {
+        input: step.input,
         meta: mergeRequestObject(defaults.meta, step.meta),
       },
     );
diff --git a/test/skillgym/suites/agent-device-smoke-suite.ts b/test/skillgym/suites/agent-device-smoke-suite.ts
index e7d94d066..b571c1a36 100644
--- a/test/skillgym/suites/agent-device-smoke-suite.ts
+++ b/test/skillgym/suites/agent-device-smoke-suite.ts
@@ -2113,6 +2113,7 @@ Treat the recovery message as a warning, not a fatal error. Use the exposed Sear
       'Need to advance and return across pages repeatedly',
       'Gesture should use a swipe series, not scroll',
       'Use one direct swipe command with --count and --pattern; do not use batch',
+      'Swipe series are bounded to 200 repetitions, 10000ms pauses, and 60000ms scheduled time',
     ],
     task: 'Plan one direct gesture command to swipe horizontally across the carousel eight times with a 30ms pause and ping-pong pattern.',
     outputs: [
@@ -2199,6 +2200,26 @@ Treat the recovery message as a warning, not a fatal error. Use the exposed Sear
       topLevelPlannedCommand('rotate'),
       topLevelPlannedCommand('rotate-gesture'),
       /--duration-ms/i,
+      /--pointer-count/i,
+    ],
+  }),
+  makeCase({
+    id: 'gesture-two-finger-pan',
+    contract: [
+      'Platform: Android',
+      'Current screen: map tilt canary',
+      'Target center is x=200 y=420',
+      'The recognizer requires exactly two fingers moving in parallel',
+      'Pan delta is dx=80 dy=-40 over 700ms',
+      'Do not add scale or rotation',
+    ],
+    task: 'Plan the direct agent-device gesture command for the two-finger pan.',
+    outputs: [plannedCommand('gesture pan'), /200\s+420\s+80\s+-40\s+700/i, /--pointer-count\s+2/i],
+    forbiddenOutputs: [
+      plannedCommand('gesture transform'),
+      plannedCommand('gesture pinch'),
+      plannedCommand('gesture rotate'),
+      /(?:^|\s)--count(?:\s|=)/i,
     ],
   }),
   makeCase({
diff --git a/website/docs/docs/commands.md b/website/docs/docs/commands.md
index e2d0df9f8..af8dc5bcd 100644
--- a/website/docs/docs/commands.md
+++ b/website/docs/docs/commands.md
@@ -336,9 +336,10 @@ agent-device type "query" --delay-ms 80
 agent-device press 300 500
 agent-device press 300 500 --count 12 --interval-ms 45
 agent-device press 300 500 --count 6 --hold-ms 120 --interval-ms 30 --jitter-px 2
-agent-device swipe 540 1500 540 500 120
-agent-device swipe 540 1500 540 500 120 --count 8 --pause-ms 30 --pattern ping-pong
+agent-device swipe 540 1500 540 500
+agent-device swipe 540 1500 540 500 --count 8 --pause-ms 30 --pattern ping-pong
 agent-device gesture pan 200 420 0 -80 500
+agent-device gesture pan 200 420 80 -40 700 --pointer-count 2
 agent-device gesture fling right 200 420 180
 agent-device longpress 300 500 800
 agent-device scroll down 0.5
@@ -357,12 +358,17 @@ On Android, `fill` also verifies text and treats IME-owned capture as a terminal
 Android text entry is owned by `agent-device`: provider-native injection when available, then chunk-safe ASCII shell input. Do not switch to raw `adb`, clipboard, or paste as an agent fallback. If non-ASCII is unsupported in the current backend, report the tool/device gap.
 `click --button secondary` is the desktop context-menu flow on macOS.
 `click --button middle` is reserved for future runner support and currently returns an explicit unsupported-operation error on macOS.
-`swipe` accepts an optional `durationMs` argument (default `250ms`, range `16..10000`).
-On iOS, swipe duration is clamped to a safe range (`16..60ms`) to avoid longpress side effects.
-`gesture pan` accepts `x y dx dy [durationMs]` for deliberate drags. Android preserves the requested travel duration; iOS uses XCTest drag primitives where this value is the pre-drag hold duration.
-`gesture fling` accepts `up|down|left|right x y [distance] [durationMs]` for fast directional throws.
-`gesture rotate` accepts `degrees [x] [y] [velocity]`; the degree sign controls direction and velocity controls speed.
-`gesture transform` accepts `x y dx dy scale degrees [durationMs]` for one combined pan/zoom/rotate gesture on Android and iOS simulators.
+`swipe` is a quick, fixed-duration directional throw. Its historical optional `durationMs` remains
+accepted for compatibility but normalizes to a pan and reports a deprecation; use `gesture pan` for
+deliberate timed movement.
+Repeated coordinate swipes accept at most 200 repetitions and 10000ms pauses, and their combined
+gesture/pause schedule must fit within 60000ms.
+`gesture pan` accepts `x y dx dy [durationMs]` for deliberate drags. It uses one pointer by default. Add `--pointer-count 2` for a parallel two-finger pan with constant contact span and angle; this shares the bounded two-contact synthesizer used by transform while retaining pan intent. Android preserves the requested travel duration; iOS uses XCTest drag primitives for one-pointer pan and private XCTest synthesis for two-pointer pan.
+`gesture fling` accepts `up|down|left|right x y [distance]` for fast directional throws. Its
+historical duration is accepted as a deprecated alias to pan.
+`gesture rotate` accepts `degrees [x] [y]`; the degree sign controls direction. Its historical
+velocity is accepted but deprecated because pacing is derived from the requested rotation.
+`gesture transform` accepts `x y dx dy scale degrees [durationMs]` for one combined two-finger pan/zoom/rotate gesture on Android and iOS simulators. Pinch, rotate, two-finger pan, and transform use the same viewport-aware pointer planning; impossible paths fail before injection instead of clamping or distorting the requested motion.
 On iOS simulators it uses private XCTest synthesis for a continuous two-finger pan/scale/rotation path, so verify app-level metrics instead of assuming the requested values map exactly to recognizer output.
 On Android, `gesture transform` injects a geometric two-finger path. App recognizers may report non-exact pan, scale, and rotation values, so verify qualitative state such as `pan changed yes`, `pinch changed yes`, and `rotate changed yes` unless the app explicitly promises exact centroid metrics. If exact app-state values matter, prefer isolated `gesture pan`, `gesture pinch`, or `gesture rotate` commands.
 `scroll` accepts either a relative amount (`0.5` means roughly half of the viewport on that axis) or `--pixels <n>` for a fixed-distance gesture. Large distances are clamped to the usable drag band so the gesture stays reliable across Android, iOS, and macOS.
@@ -383,8 +389,8 @@ done
 
 `longpress` is supported on iOS and Android.
 `gesture pinch` is supported on Android and iOS simulator app sessions.
-`gesture rotate` is supported on Android and iOS simulator app sessions. Use `rotate` for device orientation. On iOS the optional `velocity` argument is ignored — rotation is synthesized over a fixed duration and direction is taken from the sign of `degrees`.
-`gesture transform` is supported on Android and iOS simulator app sessions.
+`gesture rotate` is supported on Android and iOS simulator app sessions. Use `rotate` for device orientation.
+Two-finger `gesture pan` and `gesture transform` are supported on Android and iOS simulator app sessions. One-finger `gesture pan` keeps the broader platform support of ordinary coordinate drags.
 
 ## Find (semantic)