@@ -75,10 +75,10 @@ The `gesture` payload is a base64-encoded JSON object using protocol `android-to
 ## Persistent Session
 
 Passing `-e sessionPort <port>` keeps the instrumentation alive after startup and serves repeated
-commands over a local TCP socket on `127.0.0.1:<port>`, instead of exiting after one snapshot. This
-avoids paying UiAutomation connect/teardown cost per call. Each line sent to the socket is one
-command; the instrumentation replies once per command and keeps the connection open for the next
-one:
+commands over a local TCP server on `127.0.0.1:<port>`, instead of exiting after one snapshot. This
+avoids paying UiAutomation connect/teardown cost per call. Each command uses one short-lived
+connection: the client connects, sends a single command line, reads the response, and the server
+closes that connection; the process stays alive for the next connection:
 
 - `snapshot <requestId>` — capture and return an XML snapshot, same semantics as the default mode
 - `viewport <requestId>` — return interactive-window viewport bounds
 
@@ -59,8 +59,11 @@ automation helper: a live persistent helper session executes touch commands dire
 session socket, and without one the same helper runs one-shot (amended 2026-07, issue #1275,
 consistent with ADR 0013; previously touch synthesis shipped as a separate instrumentation helper,
 so the daemon had to stop the persistent snapshot session before every gesture and let the next
-snapshot restart it lazily). Helper reuse must never turn process ownership into cross-command
-interference.
+snapshot restart it lazily). One-shot retry after a failed session command applies only to
+idempotent reads such as viewport resolution, and only after the failed session has been stopped.
+Gesture injection is not idempotent — events may already be partially injected — so a session
+gesture failure surfaces directly instead of retrying one-shot. Helper reuse must never turn
+process ownership into cross-command interference.
 
 For iOS, keep the XCTest runner session as the reference implementation for lifecycle and
 invalidation behavior. Android does not need to copy iOS internals, but it should reuse the same
 
@@ -11,6 +11,7 @@ import {
   readAndroidTouchHelperFinalRecord,
   readAndroidTouchHelperViewport,
 } from '../touch-helper.ts';
+import { resolveAndroidHelperArtifact } from '../helper-package-install.ts';
 import { ANDROID_SNAPSHOT_HELPER_FIXTURE_ARTIFACT } from '../../../__tests__/test-utils/android-snapshot-helper.ts';
 import {
   ANDROID_TOUCH_HELPER_MANIFEST as manifest,
@@ -189,6 +190,64 @@ test('one-shot gesture instruments the snapshot-helper runner with the touch-pla
   assert.equal(result.elapsedMs, 12);
 });
 
+test('a provider-supplied snapshotHelperArtifact overrides the bundled artifact for touch', async () => {
+  const device = makeIsolatedDevice();
+  const providerArtifact = {
+    ...ANDROID_SNAPSHOT_HELPER_FIXTURE_ARTIFACT,
+    manifest: {
+      ...ANDROID_SNAPSHOT_HELPER_FIXTURE_ARTIFACT.manifest,
+      packageName: 'com.example.provider.snapshothelper',
+      instrumentationRunner: 'com.example.provider.snapshothelper/.SnapshotInstrumentation',
+    },
+  };
+  vi.mocked(resolveAndroidHelperArtifact).mockClear();
+
+  let probeArgs: string[] | undefined;
+  let installArgs: string[] | undefined;
+  let instrumentArgs: string[] | undefined;
+  const result = await withAndroidAdbProvider(
+    {
+      // ADB-backed provider carrying a helper artifact but no native touch implementation:
+      // gestures must install and run the provider's helper, same as snapshots do, never the
+      // bundled artifact resolver.
+      exec: async (args) => {
+        if (args.includes('--show-versioncode')) {
+          probeArgs = [...args];
+          return {
+            exitCode: 0,
+            stdout: `package:${providerArtifact.manifest.packageName} versionCode:1`,
+            stderr: '',
+          };
+        }
+        if (args[0] === 'install') {
+          installArgs = [...args];
+          return { exitCode: 0, stdout: 'Success', stderr: '' };
+        }
+        instrumentArgs = [...args];
+        return {
+          exitCode: 0,
+          stdout: [
+            resultRecord({ ok: 'true', kind: 'swipe', injectedEvents: '4', elapsedMs: '12' }),
+            'INSTRUMENTATION_CODE: 0',
+          ].join('\n'),
+          stderr: '',
+        };
+      },
+      snapshotHelperArtifact: providerArtifact,
+    },
+    { serial: device.id },
+    async () => await executeAndroidTouchHelperPlan(device, flingPlan()),
+  );
+
+  assert.equal(vi.mocked(resolveAndroidHelperArtifact).mock.calls.length, 0);
+  assert.ok(probeArgs?.includes(providerArtifact.manifest.packageName));
+  assert.equal(installArgs?.at(-1), providerArtifact.apkPath);
+  assert.equal(instrumentArgs?.at(-1), providerArtifact.manifest.instrumentationRunner);
+  assert.equal(result.installReason, 'outdated');
+  assert.equal(result.helperVersion, providerArtifact.manifest.version);
+  assert.equal(result.helperTransport, 'instrumentation');
+});
+
 test('one-shot gesture timeout extends beyond the plan duration for long-running gestures', async () => {
   const device = makeIsolatedDevice();
   let capturedTimeoutMs: number | undefined;
 
@@ -134,7 +134,10 @@ export async function readAndroidTouchHelperViewport(device: DeviceInfo): Promis
 
 async function prepareAndroidTouchHelper(device: DeviceInfo): Promise<PreparedAndroidTouchHelper> {
   const adbProvider = resolveAndroidAdbProvider(device);
-  const artifact = await resolveAndroidTouchHelperArtifact();
+  // Same artifact precedence as snapshot capture: a provider-supplied helper artifact overrides
+  // the bundled one so both transports install and run the single shared helper (issue #1275).
+  const artifact =
+    adbProvider.snapshotHelperArtifact ?? (await resolveAndroidTouchHelperArtifact());
   const deviceKey = getAndroidSnapshotHelperSessionDeviceKey(device);
   const install = await withDiagnosticTimer(
     'android_touch_helper_install',