agent-device 0.20.5 → 0.20.7

package/dist/apple/runner/AgentDeviceRunner/AgentDeviceRunnerUITests/RunnerTests+CommandExecution.swift

@@ -152,6 +152,17 @@ extension RunnerTests {
     )
   }
 
+  private func plannedGestureResponse(
+    plan: RunnerGesturePlan,
+    timing: (gestureStartUptimeMs: Double, gestureEndUptimeMs: Double),
+    outcome: RunnerInteractionOutcome
+  ) -> Response {
+    if let response = unsupportedResponse(for: outcome) {
+      return response
+    }
+    return gestureResponse(message: plan.intent, timing: timing)
+  }
+
 
   func execute(command: Command) throws -> Response {
     if command.command == .status {
@@ -572,13 +583,26 @@ extension RunnerTests {
     }
   }
 
-  private func executeSnapshotPrepared(command: Command, activeApp: XCUIApplication) throws -> Response {
-    let options = SnapshotOptions(
+  /// Pure command→options projection, extracted so the runner unit bundle can
+  /// prove the decoded wire field actually reaches capture options (#1634 P2).
+  static func snapshotOptions(from command: Command) -> SnapshotOptions {
+    let customActions = command.customActions ?? false
+    return SnapshotOptions(
       interactiveOnly: command.interactiveOnly ?? false,
       depth: command.depth,
       scope: command.scope,
-      raw: command.raw ?? false
+      raw: command.raw ?? false,
+      // Custom actions are only readable through the private AX client, so
+      // asking for them pins that backend rather than silently returning a
+      // capture that structurally cannot carry them. An explicit pin wins.
+      preferredBackend: command.preferredBackend
+        ?? (customActions ? SnapshotBackendKind.privateAX.rawValue : nil),
+      customActions: customActions
     )
+  }
+
+  private func executeSnapshotPrepared(command: Command, activeApp: XCUIApplication) throws -> Response {
+    let options = Self.snapshotOptions(from: command)
     do {
       let payload: DataPayload
       if options.raw {
@@ -713,24 +737,18 @@ extension RunnerTests {
       if let requestedFps = command.fps, (requestedFps < minRecordingFps || requestedFps > maxRecordingFps) {
         return Response(ok: false, error: ErrorPayload(message: "recordStart fps must be between \(minRecordingFps) and \(maxRecordingFps)"))
       }
-      if let requestedMaxSize = command.maxSize, requestedMaxSize < 1 {
-        return Response(ok: false, error: ErrorPayload(message: "recordStart maxSize must be a positive integer"))
-      }
       do {
         let resolvedOutPath = resolveRecordingOutPath(requestedOutPath)
         let fpsLabel = command.fps.map(String.init) ?? String(RunnerTests.defaultRecordingFps)
-        let maxSizeLabel = command.maxSize.map(String.init) ?? "native"
         NSLog(
-          "AGENT_DEVICE_RUNNER_RECORD_START requestedOutPath=%@ resolvedOutPath=%@ fps=%@ maxSize=%@",
+          "AGENT_DEVICE_RUNNER_RECORD_START requestedOutPath=%@ resolvedOutPath=%@ fps=%@",
           requestedOutPath,
           resolvedOutPath,
-          fpsLabel,
-          maxSizeLabel
+          fpsLabel
         )
         let recorder = ScreenRecorder(
           outputPath: resolvedOutPath,
-          fps: command.fps.map { Int32($0) },
-          maxSize: command.maxSize
+          fps: command.fps.map { Int32($0) }
         )
         try recorder.start { [weak self] in
           return self?.captureRunnerFrame()
@@ -859,12 +877,15 @@ extension RunnerTests {
     return .context(ActiveCommandContext(app: activeApp))
   }
 
-  private func executeOnMainPrepared(
+  func executeOnMainPrepared(
     command: Command,
     activeApp: XCUIApplication,
     alertDeadline: Date? = nil
   ) throws -> Response {
     var activeApp = activeApp
+    if command.command != .tap && command.command != .type && !isReadOnlyCommand(command) {
+      clearRememberedTextEntryTap()
+    }
     switch command.command {
     case .status, .activate, .terminate, .targetReset, .shutdown, .recordStart, .recordStop, .uptime:
       return Response(
@@ -893,6 +914,7 @@ extension RunnerTests {
           expectedPoint: expectedPoint
         )
         if match.isAmbiguous {
+          clearRememberedTextEntryTap()
           return Response(ok: false, error: ErrorPayload(code: "AMBIGUOUS_MATCH", message: "selector matched multiple elements"))
         }
         if let element = match.element {
@@ -911,6 +933,7 @@ extension RunnerTests {
               elementFrame: frame,
               windowFrame: onScreenWindowFrame(app: activeApp)
             ) {
+            clearRememberedTextEntryTap()
             return Response(ok: false, error: ErrorPayload(
               code: "ELEMENT_OFFSCREEN",
               message: "element resolved off-screen at (\(Int(frame.midX)), \(Int(frame.midY)))"))
@@ -946,6 +969,7 @@ extension RunnerTests {
               if isTextEntry {
                 waitForTextEntryReadinessAfterTap(app: activeApp, element: element)
               }
+              rememberTextEntryTap(isTextEntry ? element : nil)
               return gestureResponse(
                 message: match.usedNonHittableFallback
                   ? "tapped via non-hittable coordinate fallback"
@@ -976,11 +1000,13 @@ extension RunnerTests {
             return activateElement(app: activeApp, element: element, action: "tap by selector")
           }
           if let response = unsupportedResponse(for: outcome) {
+            clearRememberedTextEntryTap()
             return response
           }
           if isTextEntry {
             waitForTextEntryReadinessAfterTap(app: activeApp, element: element)
           }
+          rememberTextEntryTap(isTextEntry ? element : nil)
           return gestureResponse(
             message: match.usedNonHittableFallback ? "tapped via non-hittable coordinate fallback" : "tapped",
             timing: timing,
@@ -992,9 +1018,27 @@ extension RunnerTests {
               : nil
           )
         }
+        clearRememberedTextEntryTap()
         return Response(ok: false, error: ErrorPayload(code: "ELEMENT_NOT_FOUND", message: "element not found"))
       }
       if let x = command.x, let y = command.y {
+        let xCTestChannelPenalized = isSnapshotXCTestChannelPenalized(
+          bundleId: currentBundleId
+        )
+        let xCTestTextInputProbeSkipped = !shouldProbeCoordinateTapTextInput(
+          xCTestChannelPenalized: xCTestChannelPenalized
+        )
+        let textInput: XCUIElement?
+        if !xCTestTextInputProbeSkipped {
+          textInput = textInputAt(app: activeApp, x: x, y: y)
+        } else {
+          // A process-scoped tap cannot authorize later typing without concrete element identity.
+          textInput = nil
+          NSLog(
+            "AGENT_DEVICE_RUNNER_COORDINATE_TAP_TEXT_INPUT_PROBE_SKIPPED bundle=%@",
+            currentBundleId ?? ""
+          )
+        }
         var fallback: GestureFallback?
         if command.synthesized == true {
           let policyKind = SynthesizedGesturePolicyKind.coordinateTap
@@ -1007,6 +1051,7 @@ extension RunnerTests {
           }
           if case .performed = outcome {
             logSynthesizedGesturePolicyDecision(kind: policyKind, context: context, fallbackAttempted: false)
+            rememberTextEntryTap(textInput)
             return gestureResponse(message: "tapped", timing: timing)
           }
           logSynthesizedGesturePolicyDecision(kind: policyKind, context: context, fallbackAttempted: true)
@@ -1015,8 +1060,10 @@ extension RunnerTests {
         let touchFrame = resolvedTouchVisualizationFrame(app: activeApp, x: x, y: y)
         let (timing, outcome) = performGesture(activeApp) { tapAt(app: activeApp, x: x, y: y) }
         if let response = unsupportedResponse(for: outcome) {
+          clearRememberedTextEntryTap()
           return response
         }
+        rememberTextEntryTap(textInput)
         return gestureResponse(
           message: "tapped",
           timing: timing,
@@ -1024,6 +1071,7 @@ extension RunnerTests {
           fallback: fallback
         )
       }
+      clearRememberedTextEntryTap()
       return Response(ok: false, error: ErrorPayload(message: "tap requires a selector or x/y"))
     case .mouseClick:
       guard let x = command.x, let y = command.y else {
@@ -1348,7 +1396,7 @@ extension RunnerTests {
           ok: false,
           error: ErrorPayload(
             code: "UNSUPPORTED_OPERATION",
-            message: "Unable to dismiss the iOS keyboard without a safe native dismiss control",
+            message: "Unable to dismiss the iOS keyboard: the keyboard exposes no dismiss key, and background taps are never attempted (no tap outside the keyboard can be proven side-effect-free)",
             hint:
               "The on-screen keyboard usually does not block agent-device interactions: press the next target directly instead of retrying dismiss. If that press fails or reports no visible effect, scroll the target into view, or use keyboard enter to press the return key when submission is wanted."
           )
@@ -1360,7 +1408,8 @@ extension RunnerTests {
           message: "keyboardDismiss",
           visible: result.visible,
           wasVisible: result.wasVisible,
-          dismissed: result.dismissed
+          dismissed: result.dismissed,
+          keyboardDismissMechanism: result.mechanism?.rawValue
         )
       )
     case .keyboardReturn:
@@ -1404,7 +1453,8 @@ extension RunnerTests {
           error: ErrorPayload(code: "INVALID_ARGS", message: validationError)
         )
       }
-      if plannedGestureExecution(for: plan) == .fastSwipe {
+      switch plannedGestureExecution(for: plan) {
+      case .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
@@ -1422,14 +1472,12 @@ extension RunnerTests {
             synthesizedProfile: .fastSwipe
           )
         )
+      case .sampled:
+        let (timing, outcome) = performGesture(activeApp, idleTimeout: false) {
+          sampledPlannedGesture(app: activeApp, plan: plan)
+        }
+        return plannedGestureResponse(plan: plan, timing: timing, outcome: outcome)
       }
-      let (timing, outcome) = performGesture(activeApp, idleTimeout: false) {
-        sampledPlannedGesture(app: activeApp, plan: plan)
-      }
-      if let response = unsupportedResponse(for: outcome) {
-        return response
-      }
-      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 {
@@ -1684,11 +1732,11 @@ extension RunnerTests {
     return message == "scrolled" ? "scroll" : "drag"
   }
 
-  private func currentXCTestFailureCount() -> Int {
+  func currentXCTestFailureCount() -> Int {
     return testRun?.failureCount ?? 0
   }
 
-  private func didRecordXCTestFailure(since failureCountBefore: Int) -> Bool {
+  func didRecordXCTestFailure(since failureCountBefore: Int) -> Bool {
     return currentXCTestFailureCount() > failureCountBefore
   }
 
@@ -1705,12 +1753,12 @@ extension RunnerTests {
       error: ErrorPayload(
         code: "XCTEST_RECORDED_FAILURE",
         message: "XCTest recorded a failure while executing \(command.command.rawValue); the action may not have been performed.",
-        hint: "The iOS runner session will be restarted. Retry after a fresh snapshot, or use screenshot plus coordinate commands when the accessibility tree is unavailable."
+        hint: "The iOS runner session was invalidated. Re-observe with a fresh snapshot before retrying; if the accessibility tree is unavailable, use screenshot plus coordinate commands instead of retrying the tap blindly."
       )
     )
   }
 
-  private func runnerCommandFixture(_ json: String) throws -> Command {
+  func runnerCommandFixture(_ json: String) throws -> Command {
     try JSONDecoder().decode(Command.self, from: Data(json.utf8))
   }
 
@@ -1789,16 +1837,70 @@ extension RunnerTests {
     return XCUIApplication(bundleIdentifier: bundleId)
   }
 
-  private func executeTypeCommand(activeApp: XCUIApplication, command: Command) -> Response {
+  func executeTypeCommand(activeApp: XCUIApplication, command: Command) -> Response {
     guard let text = command.text else {
       return Response(ok: false, error: ErrorPayload(message: "type requires text"))
     }
     let delaySeconds = Double(max(command.delayMs ?? 0, 0)) / 1000.0
     let textEntryMode = resolveTextEntryMode(command)
     let target: TextEntryTarget
+    var resolvedCoordinateContext: SynthesizedCoordinateContext?
     var maestroNonHittableCoordinateFallbackUsed: Bool?
+    if command.allowNonHittableCoordinateFallback == true,
+      command.x != nil,
+      command.y != nil
+    {
+      // The shared runtime has already resolved this node as non-hittable and
+      // deliberately selected Maestro's coordinate compatibility route.
+      maestroNonHittableCoordinateFallbackUsed = true
+    }
     let focusStartedAt = Date()
-    if let selectorKey = command.selectorKey, let selectorValue = command.selectorValue {
+#if os(iOS)
+    let xCTestChannelPenalized = isSnapshotXCTestChannelPenalized(bundleId: currentBundleId)
+    var resolvedCoordinateTarget: TextEntryTarget?
+    if Self.shouldUseResolvedCoordinateTextEntryRoute(
+      repairMode: textEntryMode,
+      hasX: command.x != nil,
+      hasY: command.y != nil,
+      xCTestChannelPenalized: xCTestChannelPenalized
+    ), let x = command.x, let y = command.y {
+      let policyKind = SynthesizedGesturePolicyKind.coordinateTap
+      let context = synthesizedCoordinateContext(
+        app: activeApp,
+        policy: synthesizedGesturePolicy(policyKind)
+      )
+      let (_, outcome) = performGesture(activeApp, idleTimeout: false) {
+        synthesizedTapAt(app: activeApp, x: x, y: y, context: context)
+      }
+      if Self.shouldFallbackFromSynthesizedTextEntryFocus(outcome) {
+        logSynthesizedGesturePolicyDecision(
+          kind: policyKind,
+          context: context,
+          fallbackAttempted: true
+        )
+      } else {
+        logSynthesizedGesturePolicyDecision(
+          kind: policyKind,
+          context: context,
+          fallbackAttempted: false
+        )
+        resolvedCoordinateContext = context
+        resolvedCoordinateTarget = TextEntryTarget(
+          element: nil,
+          refreshPoint: CGPoint(x: x, y: y),
+          prefersFocusedElement: false
+        )
+      }
+    }
+#else
+    let xCTestChannelPenalized = false
+    let resolvedCoordinateTarget: TextEntryTarget? = nil
+#endif
+    if let resolvedCoordinateTarget {
+      target = resolvedCoordinateTarget
+    } else if let selectorKey = command.selectorKey, let selectorValue = command.selectorValue {
+      // Released daemons may still send selector-keyed type commands even though current
+      // daemons resolve fill selectors through the runtime tree before reaching the runner.
       let match = findElement(
         app: activeApp,
         selectorKey: selectorKey,
@@ -1829,7 +1931,16 @@ extension RunnerTests {
       textEntryModeName(textEntryMode)
     )
     if textEntryMode == .replacement {
-      guard target.element != nil else {
+#if os(iOS)
+      let canReplaceResolvedFirstResponder = Self.shouldUseSynthesizedFirstResponderReplacement(
+        hasResolvedElement: target.element != nil,
+        hasRefreshPoint: target.refreshPoint != nil,
+        xCTestChannelPenalized: xCTestChannelPenalized
+      )
+#else
+      let canReplaceResolvedFirstResponder = false
+#endif
+      guard target.element != nil || canReplaceResolvedFirstResponder else {
         let message =
           (command.x != nil && command.y != nil)
           ? "no text input found at the provided coordinates to clear"
@@ -1843,8 +1954,16 @@ extension RunnerTests {
       text: text,
       delaySeconds: delaySeconds,
       repairMode: textEntryMode,
+      xCTestChannelPenalized: xCTestChannelPenalized,
+      synthesizer: PrivateXCTestTextEntrySynthesizer(),
       commandId: command.commandId
     )
+    if let failure = textResult.failure {
+      return Response(
+        ok: false,
+        error: ErrorPayload(code: failure.rawValue, message: failure.message, hint: failure.hint)
+      )
+    }
     if textResult.verified == false {
       let expected = textResult.expectedText ?? ""
       let observed = textResult.observedText ?? ""
@@ -1857,7 +1976,16 @@ extension RunnerTests {
       )
     }
     let point = target.refreshPoint
-    let frame = activeApp.frame
+    let frame: CGRect
+    if let resolvedCoordinateContext {
+      frame = resolvedCoordinateContext.referenceFrame
+    } else if point != nil {
+      frame = activeApp.frame
+    } else {
+      // Bare `type` has no coordinate response to normalize. Avoid serializing the
+      // application AX tree only to emit unused reference dimensions.
+      frame = .zero
+    }
     return Response(
       ok: true,
       data: DataPayload(
@@ -1866,7 +1994,8 @@ extension RunnerTests {
         y: point.map { Double($0.y) },
         referenceWidth: frame.isEmpty ? nil : Double(frame.width),
         referenceHeight: frame.isEmpty ? nil : Double(frame.height),
-        maestroNonHittableCoordinateFallbackUsed: maestroNonHittableCoordinateFallbackUsed
+        maestroNonHittableCoordinateFallbackUsed: maestroNonHittableCoordinateFallbackUsed,
+        textEntryRoute: textResult.textEntryRoute
       )
     )
   }

package/dist/apple/runner/AgentDeviceRunner/AgentDeviceRunnerUITests/RunnerTests+CoordinateTextEntryTests.swift

@@ -0,0 +1,4 @@
+import XCTest
+
+extension RunnerTests {
+}

package/dist/apple/runner/AgentDeviceRunner/AgentDeviceRunnerUITests/RunnerTests+Interaction.swift

@@ -129,7 +129,8 @@ extension RunnerTests {
     selectorKey: String,
     selectorValue: String,
     allowNonHittableFallback: Bool = false,
-    expectedPoint: CGPoint? = nil
+    expectedPoint: CGPoint? = nil,
+    rawMatchPolicy: DirectSelectorRawMatchPolicy = .rejectDistinctMatches
   ) -> SelectorElementMatch {
     let value = selectorValue.trimmingCharacters(in: .whitespacesAndNewlines)
     guard !value.isEmpty else {
@@ -149,35 +150,32 @@ extension RunnerTests {
       return SelectorElementMatch(element: nil, isAmbiguous: false, usedNonHittableFallback: false)
     }
 
-    var matchedElement: XCUIElement?
-    var nonHittableElement: XCUIElement?
     let matches = app.descendants(matching: .any).matching(predicate).allElementsBoundByIndex
-    for element in matches where element.exists {
-      if let expectedPoint, !element.frame.contains(expectedPoint) {
-        continue
-      }
-      if !element.isHittable {
-        if allowNonHittableFallback && hasTappableFrame(app: app, element: element) {
-          guard nonHittableElement == nil else {
-            return SelectorElementMatch(element: nil, isAmbiguous: true, usedNonHittableFallback: false)
-          }
-          nonHittableElement = element
-        }
-        continue
-      }
-      guard matchedElement == nil else {
-        return SelectorElementMatch(element: nil, isAmbiguous: true, usedNonHittableFallback: false)
-      }
-      matchedElement = element
+      .filter(\.exists)
+    let facts = matches.map { element in
+      SelectorCandidateFacts(
+        isHittable: element.isHittable,
+        hasTappableFrame: hasTappableFrame(app: app, element: element),
+        containsExpectedPoint: expectedPoint.map(element.frame.contains) ?? true
+      )
     }
-    if let matchedElement {
-      return SelectorElementMatch(element: matchedElement, isAmbiguous: false, usedNonHittableFallback: false)
+    switch classifyDirectSelectorCandidates(
+      facts,
+      allowNonHittableFallback: allowNonHittableFallback,
+      filtersByExpectedPoint: expectedPoint != nil,
+      rawMatchPolicy: rawMatchPolicy
+    ) {
+    case .noMatch:
+      return SelectorElementMatch(element: nil, isAmbiguous: false, usedNonHittableFallback: false)
+    case .ambiguous:
+      return SelectorElementMatch(element: nil, isAmbiguous: true, usedNonHittableFallback: false)
+    case let .selected(index, usedNonHittableFallback):
+      return SelectorElementMatch(
+        element: matches[index],
+        isAmbiguous: false,
+        usedNonHittableFallback: usedNonHittableFallback
+      )
     }
-    return SelectorElementMatch(
-      element: nonHittableElement,
-      isAmbiguous: false,
-      usedNonHittableFallback: nonHittableElement != nil
-    )
   }
 
   // Maestro-compat gate for the non-hittable coordinate fallback: an element
@@ -209,7 +207,17 @@ extension RunnerTests {
   }
 
   func queryElement(app: XCUIApplication, selectorKey: String, selectorValue: String) -> Response {
-    let match = findElement(app: app, selectorKey: selectorKey, selectorValue: selectorValue)
+    // querySelector is a read — it backs get/is/wait and the offscreen-refusal
+    // double-check, none of which mutate. The fail-closed raw-match rule exists
+    // to stop a mutation acting on an unseen duplicate; applying it here would
+    // instead turn a decorative non-hittable duplicate into an AMBIGUOUS_MATCH
+    // for readers that previously resolved the hittable element.
+    let match = findElement(
+      app: app,
+      selectorKey: selectorKey,
+      selectorValue: selectorValue,
+      rawMatchPolicy: .preferHittableMatch
+    )
     if match.isAmbiguous {
       return Response(ok: false, error: ErrorPayload(code: "AMBIGUOUS_MATCH", message: "selector matched multiple elements"))
     }

package/dist/apple/runner/AgentDeviceRunner/AgentDeviceRunnerUITests/RunnerTests+Keyboard.swift

@@ -21,23 +21,34 @@ private enum KeyboardDismissObservationTiming {
   static let settleRequiredConsecutiveMatches: Int = 3
 }
 
+// The mechanism that actually resigned the keyboard, disclosed to the caller
+// (#1598) so a response never claims "dismissed" without saying how — a
+// safe-area tap has a very different reliability/side-effect profile than
+// tapping the keyboard's own Done key, and callers need to know which one
+// fired.
+enum RunnerKeyboardDismissMechanism: String {
+  case dismissKey
+}
+
 extension RunnerTests {
   func isKeyboardVisible(app: XCUIApplication) -> Bool {
     return visibleKeyboardFrame(app: app) != nil
   }
 
-  func dismissKeyboard(app: XCUIApplication) -> (wasVisible: Bool, dismissed: Bool, visible: Bool) {
+  func dismissKeyboard(
+    app: XCUIApplication
+  ) -> (wasVisible: Bool, dismissed: Bool, visible: Bool, mechanism: RunnerKeyboardDismissMechanism?) {
     let keyboard = app.keyboards.firstMatch
     let wasVisible = isKeyboardVisible(app: app)
     guard wasVisible else {
-      return (wasVisible: false, dismissed: false, visible: false)
+      return (wasVisible: false, dismissed: false, visible: false, mechanism: nil)
     }
 
 #if os(tvOS)
     _ = pressTvRemote(.menu)
     sleepFor(0.2)
     let visible = isKeyboardVisible(app: app)
-    return (wasVisible: true, dismissed: !visible, visible: visible)
+    return (wasVisible: true, dismissed: !visible, visible: visible, mechanism: visible ? nil : .dismissKey)
 #else
     if tapKeyboardDismissControl(app: app) {
       _ = keyboard.waitForNonExistence(timeout: KeyboardDismissObservationTiming.timeout)
@@ -47,13 +58,20 @@ extension RunnerTests {
         requiredConsecutiveMatches: KeyboardDismissObservationTiming.settleRequiredConsecutiveMatches
       )
       let visible = isKeyboardVisible(app: app)
-      return (wasVisible: true, dismissed: !visible, visible: visible)
+      return (wasVisible: true, dismissed: !visible, visible: visible, mechanism: visible ? nil : .dismissKey)
     }
 
-    return (wasVisible: true, dismissed: false, visible: isKeyboardVisible(app: app))
+    // #1606 review P1 (twice): generic background-tap dismissal is
+    // deliberately UNSUPPORTED. No geometry or role query can prove a
+    // coordinate is side-effect-free — a full-screen unlabeled Pressable is
+    // indistinguishable from an inert backdrop, so a "safe-area" tap can
+    // navigate or submit while reporting a successful dismiss. The dismiss
+    // key is the only mechanism the runner can vouch for.
+    return (wasVisible: true, dismissed: false, visible: isKeyboardVisible(app: app), mechanism: nil)
 #endif
   }
 
+
   // AX-free on purpose (screenshot bytes, not the accessibility tree) so it holds
   // under the same AX degradation the synthesized gesture lane is built to survive.
   // Bounded and self-terminating: returns as soon as `requiredConsecutiveMatches`

package/dist/apple/runner/AgentDeviceRunner/AgentDeviceRunnerUITests/RunnerTests+Lifecycle.swift

@@ -86,6 +86,7 @@ extension RunnerTests {
     currentApp = app
     currentBundleId = nil
     currentAppProcessIdentifier = nil
+    clearRememberedTextEntryTap()
     snapshotXCTestPenaltyWarmupExemptionPending = false
   }
 
@@ -96,11 +97,17 @@ extension RunnerTests {
     currentApp = nil
     currentBundleId = nil
     currentAppProcessIdentifier = nil
+    clearRememberedTextEntryTap()
     snapshotXCTestPenaltyWarmupExemptionPending = false
   }
 
   func resetTargetAfterExternalRelaunch() -> Response {
     invalidateCachedTarget(reason: "external_app_relaunch")
+    // The app process is replaced, but the retained runner survives. Clear
+    // process-bound capture state explicitly because invalidation drops the
+    // old PID before refreshCachedTargetIfProcessChanged can observe it.
+    clearSnapshotXCTestChannelPenalty(reason: "external_app_relaunch")
+    clearPrivateAXAcceptedDepth(reason: "external_app_relaunch")
     needsFirstInteractionDelay = true
     return Response(ok: true, data: DataPayload(message: "target reset"))
   }
@@ -121,7 +128,9 @@ extension RunnerTests {
     )
     currentApp = candidate
     currentAppProcessIdentifier = observedProcessIdentifier
+    clearRememberedTextEntryTap()
     clearSnapshotXCTestChannelPenalty(reason: "target_process_changed")
+    clearPrivateAXAcceptedDepth(reason: "target_process_changed")
     snapshotXCTestPenaltyWarmupExemptionPending = true
     needsFirstInteractionDelay = true
   }
@@ -194,6 +203,7 @@ extension RunnerTests {
     currentApp = target
     currentBundleId = bundleId
     currentAppProcessIdentifier = Self.processIdentifier(of: target)
+    clearRememberedTextEntryTap()
     snapshotXCTestPenaltyWarmupExemptionPending = false
     needsFirstInteractionDelay = true
     return target

package/dist/apple/runner/AgentDeviceRunner/AgentDeviceRunnerUITests/RunnerTests+LifecycleCacheTests.swift

@@ -3,71 +3,4 @@ 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)
-  }
-
-  func testTargetResetInvalidatesProcessBoundStateWithoutRestartingRunner() {
-    currentApp = app
-    currentBundleId = "com.example.app"
-    currentAppProcessIdentifier = 42
-    snapshotXCTestPenaltyWarmupExemptionPending = true
-    needsFirstInteractionDelay = false
-
-    let response = resetTargetAfterExternalRelaunch()
-
-    XCTAssertTrue(response.ok)
-    XCTAssertNil(currentApp)
-    XCTAssertNil(currentBundleId)
-    XCTAssertNil(currentAppProcessIdentifier)
-    XCTAssertFalse(snapshotXCTestPenaltyWarmupExemptionPending)
-    XCTAssertTrue(needsFirstInteractionDelay)
-  }
 }