agent-device 0.20.5 → 0.20.6

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

@@ -144,6 +144,41 @@ extension RunnerTests {
     return pending
   }
 
+  /// The pre-seeded first-failure a penalized plan stamps into its verdict. The deferred case
+  /// uses the dedicated 'deferred' code: the breaker pre-selected the backend, nothing new
+  /// degraded on this capture, and the daemon keys warning suppression and the settle budget
+  /// reset off exactly that distinction. The bounded probe keeps 'budget': its short XCTest
+  /// slice genuinely constrains what this capture could read.
+  static func xcTestChannelStateFirstFailure(
+    _ state: SnapshotXCTestChannelPlanState
+  ) -> (reason: String, code: String)? {
+    switch state {
+    case .normal:
+      return nil
+    case .deferredToIndependentBackend:
+      return (
+        "XCTest-backed snapshot tiers were deferred after recent slow accessibility work on this screen",
+        "deferred"
+      )
+    case .boundedXCTestProbe:
+      return (
+        "XCTest-backed snapshot tiers are running with a short recovery probe after recent slow accessibility work on this screen",
+        "budget"
+      )
+    }
+  }
+
+  /// Pure gate: a capture is planned as penalized when the channel penalty is
+  /// active OR the daemon pinned the private-AX backend (same-backend evidence
+  /// probe) — both mean "do not enter XCTest tree work first, and stamp the
+  /// pre-selection as 'deferred' rather than a degradation".
+  static func snapshotXCTestChannelTreatedAsPenalized(
+    penalized: Bool,
+    preferredBackend: String?
+  ) -> Bool {
+    penalized || preferredBackend == SnapshotBackendKind.privateAX.rawValue
+  }
+
   /// 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.
@@ -198,9 +233,15 @@ extension RunnerTests {
     // 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;
     // physical devices have no independent semantic backend yet, so they use a bounded probe.
+    // A daemon-preferred private-AX capture (same-backend evidence probe) takes the exact
+    // penalized route: privateAX-first plan, 'deferred' verdict — the backend was pre-selected
+    // deliberately, so no degradation warning should render for it.
     var xCTestChannelPenalized = false
 #if os(iOS)
-    xCTestChannelPenalized = isSnapshotXCTestChannelPenalized(bundleId: currentBundleId)
+    xCTestChannelPenalized = Self.snapshotXCTestChannelTreatedAsPenalized(
+      penalized: isSnapshotXCTestChannelPenalized(bundleId: currentBundleId),
+      preferredBackend: options.preferredBackend
+    )
 #endif
     let effective = Self.effectiveSnapshotCapturePlan(
       plan,
@@ -208,20 +249,13 @@ extension RunnerTests {
       availableBackends: Set(SnapshotBackendKind.allCases.filter(\.isAvailableOnCurrentPlatform))
     )
     let effectivePlan = effective.plan
+    firstFailure = Self.xcTestChannelStateFirstFailure(effective.xCTestChannelState)
     switch effective.xCTestChannelState {
     case .normal:
       break
     case .deferredToIndependentBackend:
-      firstFailure = (
-        "XCTest-backed snapshot tiers were deferred after recent slow accessibility work on this screen",
-        "budget"
-      )
       NSLog("AGENT_DEVICE_RUNNER_SNAPSHOT_XCTEST_CHANNEL_DEFERRED bundle=%@", currentBundleId ?? "")
     case .boundedXCTestProbe:
-      firstFailure = (
-        "XCTest-backed snapshot tiers are running with a short recovery probe after recent slow accessibility work on this screen",
-        "budget"
-      )
       NSLog("AGENT_DEVICE_RUNNER_SNAPSHOT_XCTEST_CHANNEL_PROBE_BOUNDED bundle=%@", currentBundleId ?? "")
     }
 
@@ -519,7 +553,7 @@ extension RunnerTests {
     guard quality.state != "healthy" || quality.collapsedLeafIndexes != nil else { return nil }
     var parts: [String] = []
     if quality.state == "recovered" {
-      let meaning = quality.reasonCode == "budget"
+      let meaning = quality.reasonCode == "budget" || quality.reasonCode == "deferred"
         ? " The primary capture ran out of its time budget (busy app or simulator); the recovered tree is authoritative for this screen."
         : " This usually means the app publishes an unhealthy accessibility tree — fixing the app's accessibility is the real cure. Treat screenshot as visual truth when this warning appears."
       parts.append(
@@ -536,8 +570,11 @@ extension RunnerTests {
       )
     }
     if let depth = quality.effectiveDepth {
+      // No --depth remedy here: an explicit --depth capture disables the
+      // frontier extension, so following it would return strictly less than
+      // this capture did. A plain re-run retries with a fresh extension budget.
       parts.append(
-        "The accessibility server rejected deeper requests; this tree is capped at depth \(depth) — re-run with --depth \(depth) --scope <container> for deeper content."
+        "The accessibility server rejected deeper requests; content below depth \(depth) may be missing — re-run snapshot to retry deeper content."
       )
     }
     return parts.isEmpty ? nil : parts.joined(separator: " ")

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

@@ -1,24 +1,4 @@
 import XCTest
 
 extension RunnerTests {
-  func testSnapshotTraversalIdentityPreservesSameOriginNodesWithDifferentBounds() {
-    let wrapper = Self.snapshotTraversalIdentity(
-      elementType: .other,
-      label: "Article",
-      identifier: "",
-      frame: CGRect(x: 0, y: 97, width: 393, height: 48)
-    )
-    let leaf = Self.snapshotTraversalIdentity(
-      elementType: .other,
-      label: "Article",
-      identifier: "",
-      frame: CGRect(x: 0, y: 97, width: 131, height: 48)
-    )
-
-    #if os(iOS)
-    XCTAssertNotEqual(wrapper, leaf)
-    #else
-    XCTAssertEqual(wrapper, leaf)
-    #endif
-  }
 }

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

@@ -0,0 +1,177 @@
+import XCTest
+
+// AX-independent text synthesis: private-XCTest boundary, pacing plan, and route policy.
+// The verified XCUIElement path remains in TextEntry/TextTyping.
+extension RunnerTests {
+  enum SynthesizedReplacementRouteOutcome {
+    case notApplicable
+    case completed(TextEntryResult)
+    case fallback(TextEntryTarget)
+  }
+
+  struct SynthesizedReplacementRequest {
+    let app: XCUIApplication
+    let target: TextEntryTarget
+    let text: String
+    let delaySeconds: Double
+    let synthesizer: any TextEntrySynthesizing
+    let commandId: String?
+    let startedAt: Date
+  }
+
+  enum SynthesizedTextEntryAction: Equatable {
+    case continueTyping
+    case fallback
+    case raise(String?)
+  }
+
+  protocol TextEntrySynthesizing {
+    func enterText(
+      app: XCUIApplication,
+      text: String,
+      replacingExistingText: Bool
+    ) -> SynthesizedTextEntryAction
+  }
+
+  struct PrivateXCTestTextEntrySynthesizer: TextEntrySynthesizing {
+    func enterText(
+      app: XCUIApplication,
+      text: String,
+      replacingExistingText: Bool
+    ) -> SynthesizedTextEntryAction {
+#if os(iOS)
+      let result = replacingExistingText
+        ? RunnerSynthesizedTextEntry.replaceText(withApplication: app, text: text)
+        : RunnerSynthesizedTextEntry.synthesizeText(withApplication: app, text: text)
+      return Self.action(status: result.status, message: result.message)
+#else
+      return .fallback
+#endif
+    }
+
+#if os(iOS)
+    static func action(
+      status: RunnerSynthesizedTextEntryStatus,
+      message: String?
+    ) -> SynthesizedTextEntryAction {
+      switch status {
+      case .succeeded:
+        return .continueTyping
+      case .unavailable:
+        return .fallback
+      case .failed:
+        return .raise(message)
+      @unknown default:
+        return .raise(message)
+      }
+    }
+#endif
+  }
+
+  struct SynthesizedReplacementStep: Equatable {
+    let text: String
+    let replacesExistingText: Bool
+  }
+
+  static func synthesizedReplacementSteps(
+    text: String,
+    delaySeconds: Double
+  ) -> [SynthesizedReplacementStep] {
+    let characters = Array(text)
+    guard delaySeconds > 0, characters.count > 1 else {
+      return [SynthesizedReplacementStep(text: text, replacesExistingText: true)]
+    }
+    return characters.enumerated().map { index, character in
+      SynthesizedReplacementStep(
+        text: String(character),
+        replacesExistingText: index == 0
+      )
+    }
+  }
+
+  func runSynthesizedReplacementRoute(
+    _ request: SynthesizedReplacementRequest
+  ) -> SynthesizedReplacementRouteOutcome {
+#if os(iOS)
+    NSLog("AGENT_DEVICE_RUNNER_TEXT_ENTRY_ROUTE route=synthesized-first-responder-replacement")
+    let steps = Self.synthesizedReplacementSteps(
+      text: request.text,
+      delaySeconds: request.delaySeconds
+    )
+    for (index, step) in steps.enumerated() {
+      switch request.synthesizer.enterText(
+        app: request.app,
+        text: step.text,
+        replacingExistingText: step.replacesExistingText
+      ) {
+      case .fallback:
+        NSLog("AGENT_DEVICE_RUNNER_TEXT_ENTRY_ROUTE route=verified-fallback reason=synthesis-unavailable")
+        guard let point = request.target.refreshPoint else { return .notApplicable }
+        return .fallback(
+          focusTextInputForTextEntry(app: request.app, x: point.x, y: point.y)
+        )
+      case .raise(let message):
+        NSException(
+          name: NSExceptionName.internalInconsistencyException,
+          reason: message ?? "private XCTest text synthesis failed"
+        ).raise()
+      case .continueTyping:
+        break
+      }
+      if index + 1 < steps.count {
+        sleepFor(request.delaySeconds)
+      }
+    }
+    logTextEntryPhase(
+      commandId: request.commandId,
+      phase: "total",
+      startedAt: request.startedAt,
+      chars: request.text.count,
+      mode: .replacement
+    )
+    return .completed(
+      TextEntryResult(
+        verified: nil,
+        repaired: false,
+        expectedText: request.text,
+        observedText: nil,
+        textEntryRoute: "synthesized-first-responder-replacement"
+      )
+    )
+#else
+    return .notApplicable
+#endif
+  }
+
+  static func shouldUseSynthesizedFirstResponderReplacement(
+    hasResolvedElement: Bool,
+    hasRefreshPoint: Bool,
+    xCTestChannelPenalized: Bool
+  ) -> Bool {
+    !hasResolvedElement && hasRefreshPoint && xCTestChannelPenalized
+  }
+
+  static func shouldUseSynthesizedFirstResponderType(
+    repairMode: TextTypingRepairMode,
+    fromTapWitness: Bool,
+    softwareKeyboardVisible: Bool
+  ) -> Bool {
+    repairMode == .none && fromTapWitness && !softwareKeyboardVisible
+  }
+
+  static func shouldUseResolvedCoordinateTextEntryRoute(
+    repairMode: TextTypingRepairMode,
+    hasX: Bool,
+    hasY: Bool,
+    xCTestChannelPenalized: Bool
+  ) -> Bool {
+    repairMode == .replacement && hasX && hasY && xCTestChannelPenalized
+  }
+
+  static func shouldFallbackFromSynthesizedTextEntryFocus(
+    _ outcome: RunnerInteractionOutcome
+  ) -> Bool {
+    if case .unsupported = outcome { return true }
+    return false
+  }
+}