fixup! preserve Maestro swipe endpoint-hold execution profile via internal seam

Co-Authored-By: Devin AI <158243242+devin-ai-integration[bot]@users.noreply.github.com>

Author: thymikee

CHANGELOG.md

@@ -2,8 +2,9 @@
 
 ## Unreleased
 
-- Breaking: removed deprecated gesture duration and rotate velocity inputs (#1218, #1216).
+- Breaking: removed deprecated gesture duration and rotate velocity inputs (#1218).
   - `swipe x1 y1 x2 y2` no longer accepts a trailing `durationMs` positional; use `gesture pan x1 y1 (x2-x1) (y2-y1) durationMs` for deliberate timed drags.
+  - Maestro `swipe` operations with a duration continue to normalize to `gesture pan` with the `endpoint-hold` execution profile, preserving the Maestro-compatible fast-swipe-then-hold behavior on iOS.
   - `gesture fling direction x y` no longer accepts a trailing `durationMs` positional; use `gesture pan` for timed movement.
   - `gesture swipe preset` no longer accepts a trailing `durationMs` positional; use `gesture pan` for timed movement.
   - `gesture rotate degrees [x] [y]` no longer accepts a trailing `velocity` positional; rotation pacing is derived from `degrees`.

src/compat/maestro/__tests__/daemon-runtime-port.test.ts

@@ -125,7 +125,10 @@ test('uses the direct viewport without snapshot and pairs it with the nested ges
       delta: { x: -320, y: 0 },
       durationMs: 300,
     },
-    internal: { gestureViewport: viewport },
+    internal: {
+      gestureExecutionProfile: 'endpoint-hold',
+      gestureViewport: viewport,
+    },
   });
   expect(resolveGestureViewport).toHaveBeenCalledOnce();
   expect(requests.map(({ command }) => command)).toEqual(['gesture']);

src/compat/maestro/__tests__/daemon-runtime-public-operation.test.ts

@@ -1,4 +1,8 @@
+import assert from 'node:assert/strict';
 import { describe, expect, test } from 'vitest';
+import { buildGesturePlan } from '../../../contracts/gesture-plan.ts';
+import { readGesturePayload } from '../../../contracts/gesture-input.ts';
+import { normalizePublicGesture } from '../../../contracts/gesture-normalization.ts';
 import {
   projectMaestroPublicOperation,
   type MaestroPublicOperation,
@@ -104,7 +108,10 @@ describe('Maestro public operation projection', () => {
           durationMs: 400,
         },
         flags: { postGestureStabilization: false },
-        internal: { gestureViewport: { x: 0, y: 0, width: 100, height: 200 } },
+        internal: {
+          gestureExecutionProfile: 'endpoint-hold',
+          gestureViewport: { x: 0, y: 0, width: 100, height: 200 },
+        },
       },
     },
     {
@@ -168,15 +175,40 @@ describe('Maestro public operation projection', () => {
     expect(projectMaestroPublicOperation(operation)).toEqual(expected);
   });
 
-  test('omits optional swipe and scroll fields', () => {
+  test('preserves endpoint-hold for swipes without a viewport and omits scroll duration', () => {
     expect(
       projectMaestroPublicOperation({
         kind: 'swipe',
         gesture: { from: { x: 1, y: 2 }, to: { x: 3, y: 4 }, durationMs: 5 },
       }),
-    ).not.toHaveProperty('internal');
+    ).toMatchObject({
+      command: 'gesture',
+      internal: { gestureExecutionProfile: 'endpoint-hold' },
+    });
     expect(projectMaestroPublicOperation({ kind: 'scroll', direction: 'up' })).not.toHaveProperty(
       'input',
     );
   });
+
+  test('a 400 ms Maestro swipe reaches plan execution with endpoint-hold profile', () => {
+    const viewport = { x: 0, y: 0, width: 400, height: 800 };
+    const projected = projectMaestroPublicOperation({
+      kind: 'swipe',
+      gesture: { from: { x: 360, y: 430 }, to: { x: 40, y: 430 }, durationMs: 400 },
+      viewport,
+    });
+    const input = readGesturePayload(projected.input);
+    const normalized = normalizePublicGesture(input);
+    if (normalized.gesture.intent === 'pan' && projected.internal?.gestureExecutionProfile) {
+      normalized.gesture.executionProfile = projected.internal.gestureExecutionProfile;
+    }
+    const plan = buildGesturePlan(
+      normalized.gesture,
+      projected.internal?.gestureViewport ?? viewport,
+    );
+    assert.equal(plan.topology, 'single');
+    assert.equal(plan.intent, 'pan');
+    assert.equal(plan.executionProfile, 'endpoint-hold');
+    assert.equal(plan.durationMs, 400);
+  });
 });

src/compat/maestro/daemon-runtime-public-operation.ts

@@ -169,7 +169,10 @@ function projectSwipe(
       durationMs,
     },
     flags: { postGestureStabilization: false },
-    ...(operation.viewport ? { internal: { gestureViewport: operation.viewport } } : {}),
+    internal: {
+      gestureExecutionProfile: 'endpoint-hold',
+      ...(operation.viewport ? { gestureViewport: operation.viewport } : {}),
+    },
   };
 }
 

src/daemon/handlers/interaction-gesture.ts

@@ -45,6 +45,9 @@ export async function dispatchGestureViaRuntime(
   return await dispatchGestureInteraction(params, 'gesture', async (session) => {
     const input = readGesturePayload(params.req.input);
     const normalized = normalizePublicGesture(input);
+    if (normalized.gesture.intent === 'pan' && params.req.internal?.gestureExecutionProfile) {
+      normalized.gesture.executionProfile = params.req.internal.gestureExecutionProfile;
+    }
     requireGestureSupported(normalized.gesture, session.device);
     const result = await createGestureRuntime(params).interactions.gesture({
       session: params.sessionName,

src/daemon/types.ts

@@ -18,6 +18,7 @@ import type { RecordingScope } from '../contracts/recording-scope.ts';
 import type { DeviceInfo, Platform, PlatformSelector } from '../kernel/device.ts';
 import type { ExecBackgroundResult, ExecResult } from '../utils/exec.ts';
 import type { Rect, SnapshotState } from '../kernel/snapshot.ts';
+import type { GestureExecutionProfile } from '../contracts/gesture-plan-types.ts';
 // Type-only import; erased at runtime. ref-frame.ts imports SessionState from
 // here, so this back-edge must stay type-only to avoid a runtime cycle.
 import type { RefFrameScope, RefFrameState } from './ref-frame.ts';
@@ -65,6 +66,8 @@ type DaemonRequestInternal = {
   closeAppOnly?: boolean;
   /** Provider-owned viewport already resolved while normalizing a nested gesture command. */
   gestureViewport?: Rect;
+  /** Maestro-compat execution profile for timed coordinate swipes projected to `gesture pan`. */
+  gestureExecutionProfile?: GestureExecutionProfile;
   /**
    * ADR 0012 step 4 post-resolution guard: the verified target member's
    * normalized local identity AND structural denotation (document order +