@@ -40,12 +40,13 @@
   React Native app can still show a splash or an empty root at that time, so the first `snapshot`,
   `wait` or replay step after a cold `open --relaunch` captured an app without content. Its content
   re-capture usually recovered, but inside that command's own budget. The open now captures the
-  launched app once, with the same content check and up to 3 re-captures, in a fixed 6 s window.
-  This capture never installs the snapshot helper, does not reset it after a content verdict, and
+  launched app once, with the same content check and up to 3 re-captures, and starts no re-capture
+  after 6 s. The 6 s never cancels work: the helper start and each capture keep their own
+  timeouts, and only cancelling the open stops them. This capture never installs the snapshot helper, does not reset it after a content verdict, and
   stops a helper session only if it started that session. So an open-only session does not keep
   UiAutomation, and the first read after the open starts the helper as before. `open_timing` reports
   `postOpenObservation` (see `PostOpenObservation`): `observable`; `unobservable` for a content
-  verdict, a system surface over the app, or the window running out; `probe-failed` with a typed
+  verdict or a system surface over the app; `probe-failed` with a typed
   `postOpenObservationFailure` when the capture could not run, for example before the helper is
   installed on a new device; and `app-unidentified` when the launched package could not be read. A
   URL or deep-link open reports none. The open succeeds in all of these cases, and a cancelled open
 
@@ -177,9 +177,10 @@ export type SnapshotOptions = BaseSnapshotOptions & {
   acquisitionIntent?: 'full' | 'surface-observation';
   /**
    * A one-off read, such as an open's launch observation. It may use a capture host the session
-   * already keeps warm, but it never installs one or leaves running one that it started.
+   * already keeps warm, but it never installs one or leaves running one that it started. It starts
+   * no re-capture after `settleBy` (epoch ms); only `signal` cancels work already started.
    */
-  transient?: boolean;
+  transient?: Readonly<{ settleBy: number }>;
 };
 
 /**
 
@@ -62,6 +62,10 @@ export type PersistentSnapshotHelperProviderOptions = {
   oneShotXml?: string;
   /** Make the device-side stop fail the way an unhealthy transport answers. */
   runtimeStopFailure?: boolean;
+  /** How long a started session takes to report ready. */
+  sessionReadyDelayMs?: number;
+  /** How long a session takes to answer its `snapshotCount`th capture. */
+  captureResponseDelayMs?: (snapshotCount: number) => number;
 };
 
 export function createPersistentSnapshotHelperProvider(
@@ -104,36 +108,40 @@ export function createPersistentSnapshotHelperProvider(
           const body = options.sessionXml
             ? options.sessionXml(sessionIndex, snapshotCount)
             : `<hierarchy><node text="persistent helper snapshot ${snapshotCount}" bounds="[0,0][10,10]" /></hierarchy>`;
-          socket.end(
-            sessionResponse({
-              requestId,
-              body,
-              metadata: {
-                waitForIdleTimeoutMs: '500',
-                waitForIdleQuietMs: '100',
-                timeoutMs: '5000',
-                maxDepth: '128',
-                maxNodes: '5000',
-                rootPresent: 'true',
-                captureMode: 'interactive-windows',
-                windowCount: '1',
-                nodeCount: '1',
-                truncated: 'false',
-                elapsedMs: '8',
-              },
-            }),
-          );
+          const answer = () =>
+            socket.end(
+              sessionResponse({
+                requestId,
+                body,
+                metadata: {
+                  waitForIdleTimeoutMs: '500',
+                  waitForIdleQuietMs: '100',
+                  timeoutMs: '5000',
+                  maxDepth: '128',
+                  maxNodes: '5000',
+                  rootPresent: 'true',
+                  captureMode: 'interactive-windows',
+                  windowCount: '1',
+                  nodeCount: '1',
+                  truncated: 'false',
+                  elapsedMs: '8',
+                },
+              }),
+            );
+          setTimeout(answer, options.captureResponseDelayMs?.(snapshotCount) ?? 0);
         });
       });
       server.listen(port, '127.0.0.1', () => {
-        process.stdout.write(
-          [
-            'INSTRUMENTATION_STATUS: agentDeviceProtocol=android-snapshot-helper-v1',
-            'INSTRUMENTATION_STATUS: sessionReady=true',
-            'INSTRUMENTATION_STATUS_CODE: 2',
-            '',
-          ].join('\n'),
-        );
+        setTimeout(() => {
+          process.stdout.write(
+            [
+              'INSTRUMENTATION_STATUS: agentDeviceProtocol=android-snapshot-helper-v1',
+              'INSTRUMENTATION_STATUS: sessionReady=true',
+              'INSTRUMENTATION_STATUS_CODE: 2',
+              '',
+            ].join('\n'),
+          );
+        }, options.sessionReadyDelayMs ?? 0);
       });
       process.onKill = () => {
         server.close(() => process.emitExit(0, null));
 
@@ -538,7 +538,7 @@ test('snapshotAndroid keeps daemon-session helper alive for reuse until session
   );
 });
 
-test('a borrowed capture releases a helper session it had to start', async () => {
+test('a transient capture releases a helper session it had to start', async () => {
   const adbCalls: (readonly string[])[] = [];
   const spawnArgs: (readonly string[])[] = [];
   const processes: FakeAndroidProcess[] = [];
@@ -551,7 +551,7 @@ test('a borrowed capture releases a helper session it had to start', async () =>
   await snapshotAndroid(device, {
     helperAdb: provider,
     helperArtifact,
-    helperSessionScope: 'borrow',
+    transient: openSettleWindow(),
   });
 
   assert.equal(spawnArgs.length, 1);
@@ -562,7 +562,7 @@ test('a borrowed capture releases a helper session it had to start', async () =>
   );
 });
 
-test('a borrowed capture leaves a warm daemon-session helper running', async () => {
+test('a transient capture leaves a warm daemon-session helper running', async () => {
   const adbCalls: (readonly string[])[] = [];
   const spawnArgs: (readonly string[])[] = [];
   const processes: FakeAndroidProcess[] = [];
@@ -580,7 +580,7 @@ test('a borrowed capture leaves a warm daemon-session helper running', async ()
   const borrowed = await snapshotAndroid(device, {
     helperAdb: provider,
     helperArtifact,
-    helperSessionScope: 'borrow',
+    transient: openSettleWindow(),
   });
 
   assert.equal(borrowed.androidSnapshot.helperSessionReused, true);
@@ -662,7 +662,7 @@ test('snapshotAndroid retires content-invalid daemon helper before the next requ
   );
 });
 
-test('a borrowed capture reports its content verdict without retiring the warm helper', async () => {
+test('a transient capture reports its content verdict without retiring the warm helper', async () => {
   const adbCalls: (readonly string[])[] = [];
   const spawnArgs: (readonly string[])[] = [];
   const processes: FakeAndroidProcess[] = [];
@@ -682,7 +682,7 @@ test('a borrowed capture reports its content verdict without retiring the warm h
   });
 
   await assert.rejects(
-    snapshotAndroid(device, { helperAdb: provider, helperArtifact, helperSessionScope: 'borrow' }),
+    snapshotAndroid(device, { helperAdb: provider, helperArtifact, transient: openSettleWindow() }),
     (error: unknown) => isUnreadableCaptureContentError(error),
   );
 
@@ -691,6 +691,90 @@ test('a borrowed capture reports its content verdict without retiring the warm h
   assert.equal(spawnArgs.length, 1);
 });
 
+test('a settle window that passes during the helper start never cancels the start', async () => {
+  const adbCalls: (readonly string[])[] = [];
+  const spawnArgs: (readonly string[])[] = [];
+  const processes: FakeAndroidProcess[] = [];
+  const provider = createPersistentSnapshotHelperProvider({
+    calls: adbCalls,
+    spawnArgs,
+    processes,
+    sessionXml: () => androidSystemWindowOnlyXml(),
+    sessionReadyDelayMs: 150,
+  });
+
+  await assert.rejects(
+    snapshotAndroid(device, {
+      helperAdb: provider,
+      helperArtifact,
+      transient: { settleBy: Date.now() + 30 },
+    }),
+    (error: unknown) =>
+      isUnreadableCaptureContentError(error) && (error as AppError).details?.attempts === 1,
+  );
+
+  assert.equal(spawnArgs.length, 1);
+  assert.equal(processes[0]?.killed, false, 'the started helper was not signalled');
+  assert.equal(processes[0]?.exitCode, 0, 'the started helper quit on its own');
+  assert.equal(adbCalls.some(isHelperRuntimeReset), false);
+});
+
+test('a settle window that passes during a warm session capture leaves the session running', async () => {
+  const adbCalls: (readonly string[])[] = [];
+  const spawnArgs: (readonly string[])[] = [];
+  const processes: FakeAndroidProcess[] = [];
+  const provider = createPersistentSnapshotHelperProvider({
+    calls: adbCalls,
+    spawnArgs,
+    processes,
+    sessionXml: (_sessionIndex, snapshotCount) =>
+      snapshotCount === 1
+        ? '<hierarchy><node text="warm helper" bounds="[0,0][10,10]" /></hierarchy>'
+        : androidSystemWindowOnlyXml(),
+    captureResponseDelayMs: (snapshotCount) => (snapshotCount === 1 ? 0 : 150),
+  });
+  await snapshotAndroid(device, {
+    helperAdb: provider,
+    helperArtifact,
+    helperSessionScope: 'daemon-session',
+  });
+
+  await assert.rejects(
+    snapshotAndroid(device, {
+      helperAdb: provider,
+      helperArtifact,
+      transient: { settleBy: Date.now() + 30 },
+    }),
+    (error: unknown) =>
+      isUnreadableCaptureContentError(error) && (error as AppError).details?.attempts === 1,
+  );
+
+  assert.equal(spawnArgs.length, 1);
+  assert.equal(processes[0]?.killed, false);
+  assert.equal(processes[0]?.exitCode, null, 'the session helper is still running');
+  assert.equal(adbCalls.some(isHelperRuntimeReset), false);
+});
+
+test('a transient capture on a device without the current helper installs nothing', async () => {
+  const adbCalls: (readonly string[])[] = [];
+  const helperAdb: AndroidAdbExecutor = async (args) => {
+    adbCalls.push(args);
+    if (isHelperVersionProbe(args)) return { exitCode: 1, stdout: '', stderr: 'not found' };
+    return { exitCode: 0, stdout: '', stderr: '' };
+  };
+
+  await assert.rejects(
+    snapshotAndroid(device, { helperAdb, helperArtifact, transient: openSettleWindow() }),
+    (error: unknown) =>
+      (error as AppError).details?.reason === 'android-snapshot-helper-not-current',
+  );
+
+  assert.equal(
+    adbCalls.some((args) => args.includes('install') || args.includes('instrument')),
+    false,
+  );
+});
+
 test('content-invalid daemon helper retirement force-stops the helper runtime', async () => {
   // Retirement after a content failure is a recovery path, not a release: the helper answered with
   // output we could not trust, so the next capture must meet a runtime that was reset. A clean quit
@@ -1514,3 +1598,7 @@ test('buildUiHierarchySnapshot derives hidden content hints from can-scroll-* on
   assert.equal(scrollArea.hiddenContentAbove, true);
   assert.equal(scrollArea.hiddenContentBelow, true);
 });
+
+function openSettleWindow(): { settleBy: number } {
+  return { settleBy: Date.now() + 60_000 };
+}