agent-device 0.19.2 → 0.20.0

package/dist/{apple-runner → apple/runner}/AgentDeviceRunner/AgentDeviceRunnerUITests/RunnerTests+SequenceExecution.swift

@@ -9,7 +9,7 @@ extension RunnerTests {
 
   /// Allowlisted step kinds. Validated on both sides so an unsupported kind is rejected with a
   /// clear INVALID_ARGS naming the step index, executing nothing.
-  private var sequenceableStepKinds: Set<String> { ["tap", "doubleTap", "longPress", "drag"] }
+  private var sequenceableStepKinds: Set<String> { ["tap", "doubleTap", "longPress"] }
 
   /// Per-step outcome carried by `assembleSequenceExecution`. The timing is captured by the
   /// executor closure (via performGesture) so ordering/stop-on-failure stay device-free testable.
@@ -127,17 +127,12 @@ extension RunnerTests {
   private func validateSequenceStep(_ step: SequenceStep, index: Int) -> Response? {
     guard sequenceableStepKinds.contains(step.kind) else {
       return sequenceInvalidArgs(
-        "sequence step \(index) has unsupported kind \"\(step.kind)\"; allowed: tap, doubleTap, longPress, drag"
+        "sequence step \(index) has unsupported kind \"\(step.kind)\"; allowed: tap, doubleTap, longPress"
       )
     }
     guard let x = step.x, let y = step.y, x.isFinite, y.isFinite else {
       return sequenceInvalidArgs("sequence step \(index) (\(step.kind)) requires finite x and y")
     }
-    if step.kind == "drag" {
-      guard let x2 = step.x2, let y2 = step.y2, x2.isFinite, y2.isFinite else {
-        return sequenceInvalidArgs("sequence step \(index) (drag) requires finite x2 and y2")
-      }
-    }
     return nil
   }
 
@@ -194,91 +189,6 @@ extension RunnerTests {
 #endif
       // Synthesis unsupported (e.g. macOS) — fall through to the drag-based tapAt below.
     }
-    if step.kind == "drag", step.synthesized == true {
-      let policyKind = SynthesizedGesturePolicyKind.synthesizedDrag
-      let dragPoints: DragPoints
-      let dragContext: SynthesizedCoordinateContext?
-#if os(iOS)
-      guard let dragPlan = axFreeSynthesizedDragPlan(
-        app: activeApp,
-        x: x,
-        y: y,
-        x2: step.x2 ?? x,
-        y2: step.y2 ?? y,
-        context: synthesizedContext
-      ) else {
-        let nowMs = ProcessInfo.processInfo.systemUptime * 1000
-        logSynthesizedGesturePolicyDecision(kind: policyKind, context: synthesizedContext, fallbackAttempted: false)
-        return SequenceStepOutcome(
-          outcome: .unsupported(
-            message: "synthesized coordinate drag could not resolve a finite coordinate frame",
-            hint: "Retry after the app is foregrounded, or use a plain screenshot to choose coordinates."
-          ),
-          gestureStartUptimeMs: nowMs,
-          gestureEndUptimeMs: nowMs
-        )
-      }
-      dragPoints = dragPlan.points
-      dragContext = dragPlan.context
-#else
-      dragPoints = keyboardAvoidingDragPoints(
-        app: activeApp, x: x, y: y, x2: step.x2 ?? x, y2: step.y2 ?? y)
-      dragContext = nil
-#endif
-      let durationMs = min(max(step.durationMs ?? 250, 16), 10000)
-      let (timing, outcome) = performGesture(activeApp, idleTimeout: false) {
-        synthesizedDragAt(
-          app: activeApp,
-          x: dragPoints.x,
-          y: dragPoints.y,
-          x2: dragPoints.x2,
-          y2: dragPoints.y2,
-          durationMs: durationMs,
-          context: dragContext
-        )
-      }
-      if case .performed = outcome {
-        logSynthesizedGesturePolicyDecision(kind: policyKind, context: dragContext, fallbackAttempted: false)
-        if let pauseMs = step.pauseMs, pauseMs > 0 {
-          sleepFor(min(max(pauseMs, 0), 10000) / 1000.0)
-        }
-        return SequenceStepOutcome(
-          outcome: outcome,
-          gestureStartUptimeMs: timing.gestureStartUptimeMs,
-          gestureEndUptimeMs: timing.gestureEndUptimeMs
-        )
-      }
-#if os(iOS)
-      guard dragContext?.allowsXCTestCoordinateFallback == true else {
-        logSynthesizedGesturePolicyDecision(kind: policyKind, context: dragContext, fallbackAttempted: false)
-        return SequenceStepOutcome(
-          outcome: outcome,
-          gestureStartUptimeMs: timing.gestureStartUptimeMs,
-          gestureEndUptimeMs: timing.gestureEndUptimeMs
-        )
-      }
-#endif
-      logSynthesizedGesturePolicyDecision(kind: policyKind, context: dragContext, fallbackAttempted: true)
-      let fallbackHoldDuration = synthesizedSwipeFallbackHoldDuration(durationMs: step.durationMs ?? 250)
-      let (fallbackTiming, fallbackOutcome) = performGesture(activeApp) {
-        dragAt(
-          app: activeApp,
-          x: dragPoints.x,
-          y: dragPoints.y,
-          x2: dragPoints.x2,
-          y2: dragPoints.y2,
-          holdDuration: fallbackHoldDuration
-        )
-      }
-      if case .performed = fallbackOutcome, let pauseMs = step.pauseMs, pauseMs > 0 {
-        sleepFor(min(max(pauseMs, 0), 10000) / 1000.0)
-      }
-      return SequenceStepOutcome(
-        outcome: fallbackOutcome,
-        gestureStartUptimeMs: fallbackTiming.gestureStartUptimeMs,
-        gestureEndUptimeMs: fallbackTiming.gestureEndUptimeMs
-      )
-    }
     let (timing, outcome) = performGesture(activeApp) {
       switch step.kind {
       case "doubleTap":
@@ -287,20 +197,6 @@ extension RunnerTests {
       case "longPress":
         let duration = min(max(step.durationMs ?? 800, 16), 10000) / 1000.0
         return longPressAt(app: activeApp, x: x, y: y, duration: duration)
-      case "drag":
-        // Route through keyboardAvoidingDragPoints for parity with the individual `.drag` command.
-        // The non-synthesized coordinate-drag path ignores durationMs, matching that command's
-        // non-synthesized branch.
-        let dragPoints = keyboardAvoidingDragPoints(
-          app: activeApp, x: x, y: y, x2: step.x2 ?? x, y2: step.y2 ?? y)
-        return dragAt(
-          app: activeApp,
-          x: dragPoints.x,
-          y: dragPoints.y,
-          x2: dragPoints.x2,
-          y2: dragPoints.y2,
-          holdDuration: coordinateDragHoldDuration()
-        )
       default:
         return tapAt(app: activeApp, x: x, y: y)
       }

package/dist/{apple-runner → apple/runner}/AgentDeviceRunner/AgentDeviceRunnerUITests/RunnerTests+Snapshot.swift

@@ -101,15 +101,22 @@ extension RunnerTests {
 
   static let flatInteractiveFallbackBudget: TimeInterval = 1.0
 
+  // The single production entry point -- always compiled, no unit-test overload. A unit test
+  // exercises this exact function; the only injectable seam lives inside
+  // `boundedBlockingSystemAlertSnapshot`'s probe closure (see `systemModalProbeOverrideForTesting`
+  // in RunnerTests.swift), so reverting this entry point to bypass the bounded probe fails the
+  // regression test.
   func snapshotFast(app: XCUIApplication, options: SnapshotOptions) throws -> DataPayload {
-    if let blocking = blockingSystemAlertSnapshot() {
+    let deadline = Date().addingTimeInterval(Self.snapshotPlanBudget)
+    if let blocking = boundedBlockingSystemAlertSnapshot(deadline: deadline) {
       return blocking
     }
     return try runSnapshotCapturePlan(
       Self.regularVisiblePlan,
       app: app,
       options: options,
-      terminal: .sparseWithFatalOnAXFailure
+      terminal: .sparseWithFatalOnAXFailure,
+      deadline: deadline
     )
   }
 
@@ -189,7 +196,12 @@ extension RunnerTests {
         regularSnapshot: true
       )
 
-      let key = "\(snapshot.elementType)-\(evaluation.label)-\(evaluation.identifier)-\(snapshot.frame.origin.x)-\(snapshot.frame.origin.y)"
+      let key = Self.snapshotTraversalIdentity(
+        elementType: snapshot.elementType,
+        label: evaluation.label,
+        identifier: evaluation.identifier,
+        frame: snapshot.frame
+      )
       let isDuplicate = seen.contains(key)
       if !isDuplicate {
         seen.insert(key)
@@ -245,18 +257,98 @@ extension RunnerTests {
     )
   }
 
+  // See `snapshotFast` above: the single production entry point, no unit-test overload.
   func snapshotRaw(app: XCUIApplication, options: SnapshotOptions) throws -> DataPayload {
-    if let blocking = blockingSystemAlertSnapshot() {
+    let deadline = Date().addingTimeInterval(Self.snapshotPlanBudget)
+    if let blocking = boundedBlockingSystemAlertSnapshot(deadline: deadline) {
       return blocking
     }
     return try runSnapshotCapturePlan(
       Self.rawDiagnosticPlan,
       app: app,
       options: options,
-      terminal: .throwOnAXFailure
+      terminal: .throwOnAXFailure,
+      deadline: deadline
     )
   }
 
+  /// Runs the pre-plan SpringBoard system-modal probe as a bounded capture tier sharing the plan
+  /// deadline, so a slow alert enumeration cannot bypass the snapshot timeout and stall (#1244).
+  func boundedBlockingSystemAlertSnapshot(deadline: Date) -> DataPayload? {
+    boundedBlockingSystemAlertSnapshotBody(deadline: deadline) { probeDeadline in
+      return self.blockingSystemAlertSnapshot(deadline: probeDeadline)
+    }
+  }
+
+  /// The real bounding/hook machinery used by `boundedBlockingSystemAlertSnapshot` above: the
+  /// probe closure it's given always calls `self.blockingSystemAlertSnapshot` in production, and
+  /// in unit-test builds may first consult `systemModalProbeOverrideForTesting`. Keeping this in
+  /// one place means the `runMainThreadWork` wrap and the `onAbandoned`/`onDrained` hooks can
+  /// never drift between what production runs and what the unit tests exercise.
+  private func boundedBlockingSystemAlertSnapshotBody(
+    deadline: Date,
+    probe: @escaping (Date) -> DataPayload?
+  ) -> DataPayload? {
+    #if os(macOS)
+      return nil
+    #else
+    let slice = Self.systemModalProbeSlice(
+      budget: systemModalProbeBudget,
+      deadlineRemaining: deadline.timeIntervalSinceNow
+    )
+    guard slice > 0 else {
+      NSLog("AGENT_DEVICE_RUNNER_SYSTEM_MODAL_PROBE_SKIPPED reason=budget_exhausted")
+      return nil
+    }
+    let probeDeadline = Date().addingTimeInterval(slice)
+    let startedAt = Date()
+    do {
+      return try runMainThreadWork(
+        command: nil,
+        timeout: slice,
+        timeoutError: {
+          SnapshotCaptureFailure(
+            code: Self.xCTestSnapshotTimeoutCode,
+            message: "the system-modal probe exceeded its \(slice)s time slice",
+            hint: "The capture plan recovers through non-XCTest snapshot tiers while the modal probe drains."
+          )
+        },
+        onAbandoned: {
+          self.retainAbandonedXCTestChannelWork()
+          NSLog("AGENT_DEVICE_RUNNER_SYSTEM_MODAL_PROBE_TIMEOUT slice=%.1f", slice)
+          self.penalizeSnapshotXCTestChannel(
+            bundleId: self.currentBundleId,
+            reason: "system_modal_probe_timeout"
+          )
+        },
+        onDrained: {
+          self.releaseAbandonedXCTestChannelWork()
+          NSLog("AGENT_DEVICE_RUNNER_SYSTEM_MODAL_PROBE_DRAINED")
+        }
+      ) {
+        probe(probeDeadline)
+      }
+    } catch {
+      NSLog(
+        "AGENT_DEVICE_RUNNER_SYSTEM_MODAL_PROBE_ABORTED elapsedMs=%d error=%@",
+        Int(Date().timeIntervalSince(startedAt) * 1000),
+        String(describing: error)
+      )
+      return nil
+    }
+    #endif
+  }
+
+  /// The probe gets its own budget, clamped by whatever remains of the shared plan deadline, and
+  /// 0 (skip entirely) once that deadline is already spent.
+  static func systemModalProbeSlice(
+    budget: TimeInterval,
+    deadlineRemaining: TimeInterval
+  ) -> TimeInterval {
+    guard deadlineRemaining > 0 else { return 0 }
+    return min(budget, deadlineRemaining)
+  }
+
   func rawTreeSnapshotPayload(
     context: SnapshotTraversalContext,
     options: SnapshotOptions
@@ -566,6 +658,20 @@ extension RunnerTests {
     return abandonedTreeCaptureCount > 0
   }
 
+  /// The watchdog abandoned one unit of XCTest main-thread capture work that is still draining on
+  /// main; XCTest-backed snapshot tiers skip (`hasAbandonedTreeCapture`) until a matching release.
+  func retainAbandonedXCTestChannelWork() {
+    treeCaptureLock.lock()
+    abandonedTreeCaptureCount += 1
+    treeCaptureLock.unlock()
+  }
+
+  func releaseAbandonedXCTestChannelWork() {
+    treeCaptureLock.lock()
+    abandonedTreeCaptureCount -= 1
+    treeCaptureLock.unlock()
+  }
+
   /// Runs the blocking tree-snapshot XPC on the main thread bounded by `sliceSeconds`. On
   /// timeout the XPC keeps running on main (it cannot be cancelled); the capture is marked
   /// abandoned so plans avoid XCTest-backed tiers until it drains, the tree backend is penalized
@@ -583,9 +689,7 @@ extension RunnerTests {
       timeout: sliceSeconds,
       timeoutError: treeCaptureTimeoutError(sliceSeconds: sliceSeconds),
       onAbandoned: {
-        self.treeCaptureLock.lock()
-        self.abandonedTreeCaptureCount += 1
-        self.treeCaptureLock.unlock()
+        self.retainAbandonedXCTestChannelWork()
         NSLog("AGENT_DEVICE_RUNNER_TREE_CAPTURE_SLICE_TIMEOUT slice=%.1f", sliceSeconds)
         self.penalizeSnapshotXCTestChannel(
           bundleId: self.currentBundleId,
@@ -593,9 +697,7 @@ extension RunnerTests {
         )
       },
       onDrained: {
-        self.treeCaptureLock.lock()
-        self.abandonedTreeCaptureCount -= 1
-        self.treeCaptureLock.unlock()
+        self.releaseAbandonedXCTestChannelWork()
         NSLog("AGENT_DEVICE_RUNNER_TREE_CAPTURE_DRAINED")
       }
     ) {
@@ -789,6 +891,19 @@ extension RunnerTests {
     return .infinite
   }
 
+  static func snapshotTraversalIdentity(
+    elementType: XCUIElement.ElementType,
+    label: String,
+    identifier: String,
+    frame: CGRect
+  ) -> String {
+    #if os(iOS)
+    "\(elementType)-\(label)-\(identifier)-\(frame.origin.x)-\(frame.origin.y)-\(frame.width)-\(frame.height)"
+    #else
+    return "\(elementType)-\(label)-\(identifier)-\(frame.origin.x)-\(frame.origin.y)"
+    #endif
+  }
+
   private func aggregatedLabel(for snapshot: XCUIElementSnapshot, depth: Int = 0) -> String? {
     if depth > 4 { return nil }
     let text = snapshot.label.trimmingCharacters(in: .whitespacesAndNewlines)

package/dist/{apple-runner → apple/runner}/AgentDeviceRunner/AgentDeviceRunnerUITests/RunnerTests+SnapshotCapturePlan.swift

@@ -118,6 +118,17 @@ extension RunnerTests {
     )
   }
 
+  func clearSnapshotXCTestChannelPenalty(reason: String) {
+    snapshotXCTestChannelPenaltyLock.lock()
+    let hadActivePenalty = Date() < snapshotXCTestChannelPenaltyUntil
+    snapshotXCTestChannelPenaltyBundleId = nil
+    snapshotXCTestChannelPenaltyUntil = Date.distantPast
+    snapshotXCTestChannelPenaltyLock.unlock()
+    if hadActivePenalty {
+      NSLog("AGENT_DEVICE_RUNNER_SNAPSHOT_XCTEST_CHANNEL_PENALTY_CLEARED reason=%@", reason)
+    }
+  }
+
   func isSnapshotXCTestChannelPenalized(bundleId: String?) -> Bool {
     snapshotXCTestChannelPenaltyLock.lock()
     defer { snapshotXCTestChannelPenaltyLock.unlock() }
@@ -127,6 +138,12 @@ extension RunnerTests {
     return penalized == bundleId
   }
 
+  func consumeSnapshotXCTestPenaltyWarmupExemption() -> Bool {
+    let pending = snapshotXCTestPenaltyWarmupExemptionPending
+    snapshotXCTestPenaltyWarmupExemptionPending = false
+    return pending
+  }
+
   /// 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.
@@ -168,12 +185,15 @@ extension RunnerTests {
     _ plan: [SnapshotBackendKind],
     app: XCUIApplication,
     options: SnapshotOptions,
-    terminal: SnapshotCaptureTerminalPolicy
+    terminal: SnapshotCaptureTerminalPolicy,
+    deadline: Date? = nil
   ) throws -> DataPayload {
     var best: (kind: SnapshotBackendKind, capture: SnapshotBackendCapture)?
     var firstFailure: (reason: String, code: String)?
     var axFailure: SnapshotCaptureFailure?
-    let deadline = Date().addingTimeInterval(Self.snapshotPlanBudget)
+    // A caller may share the pre-plan system-modal probe's deadline; otherwise own the full budget (#1244).
+    let deadline = deadline ?? Date().addingTimeInterval(Self.snapshotPlanBudget)
+    let suppressXCTestPenalty = consumeSnapshotXCTestPenaltyWarmupExemption()
 
     // 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;
@@ -237,14 +257,30 @@ extension RunnerTests {
             treeCaptureSliceBudgetOverride: effective.treeCaptureSliceBudgetOverride
           )
         else {
-          recordSlowXCTestSnapshotBackendIfNeeded(kind, startedAt: backendStartedAt)
+          recordSlowXCTestSnapshotBackendIfNeeded(
+            kind,
+            startedAt: backendStartedAt,
+            penaltySuppressed: suppressXCTestPenalty
+          )
           continue
         }
         capture = result
-        recordSlowXCTestSnapshotBackendIfNeeded(kind, startedAt: backendStartedAt)
+        recordSlowXCTestSnapshotBackendIfNeeded(
+          kind,
+          startedAt: backendStartedAt,
+          penaltySuppressed: suppressXCTestPenalty
+        )
       } catch let failure as SnapshotCaptureFailure {
-        recordXCTestSnapshotBackendFailureIfNeeded(kind, failure: failure)
-        recordSlowXCTestSnapshotBackendIfNeeded(kind, startedAt: backendStartedAt)
+        recordXCTestSnapshotBackendFailureIfNeeded(
+          kind,
+          failure: failure,
+          penaltySuppressed: suppressXCTestPenalty
+        )
+        recordSlowXCTestSnapshotBackendIfNeeded(
+          kind,
+          startedAt: backendStartedAt,
+          penaltySuppressed: suppressXCTestPenalty
+        )
         if Self.isAxSnapshotFailure(failure) { axFailure = failure }
         if firstFailure == nil {
           firstFailure = (failure.message, Self.isAxSnapshotFailure(failure) ? "ax-rejected" : "capture-failed")
@@ -313,7 +349,12 @@ extension RunnerTests {
 
   /// Marks XCTest-backed snapshot tiers as penalized when one attempt ground past the slow-capture
   /// threshold — even a successful one: the next capture of this screen must not re-grind.
-  private func recordSlowXCTestSnapshotBackendIfNeeded(_ kind: SnapshotBackendKind, startedAt: Date) {
+  private func recordSlowXCTestSnapshotBackendIfNeeded(
+    _ kind: SnapshotBackendKind,
+    startedAt: Date,
+    penaltySuppressed: Bool
+  ) {
+    guard !penaltySuppressed else { return }
     guard kind.usesXCTestAccessibilityChannel else { return }
     let elapsed = Date().timeIntervalSince(startedAt)
     guard elapsed > snapshotXCTestSlowCaptureThreshold else { return }
@@ -325,8 +366,10 @@ extension RunnerTests {
 
   private func recordXCTestSnapshotBackendFailureIfNeeded(
     _ kind: SnapshotBackendKind,
-    failure: SnapshotCaptureFailure
+    failure: SnapshotCaptureFailure,
+    penaltySuppressed: Bool
   ) {
+    guard !penaltySuppressed else { return }
     guard kind.usesXCTestAccessibilityChannel, failure.code == Self.xCTestSnapshotTimeoutCode else { return }
     penalizeSnapshotXCTestChannel(
       bundleId: currentBundleId,

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

@@ -0,0 +1,24 @@
+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 → apple/runner}/AgentDeviceRunner/AgentDeviceRunnerUITests/RunnerTests+SynthesizedGesturePolicy.swift

@@ -103,7 +103,7 @@ func synthesizedGesturePolicy(_ kind: SynthesizedGesturePolicyKind) -> Synthesiz
 
 func sequenceHasSynthesizedCoordinateStep(_ steps: [SequenceStep]) -> Bool {
   steps.contains { step in
-    step.synthesized == true && (step.kind == "tap" || step.kind == "drag")
+    step.synthesized == true && step.kind == "tap"
   }
 }
 

package/dist/{apple-runner → apple/runner}/AgentDeviceRunner/AgentDeviceRunnerUITests/RunnerTests+SystemModal.swift

@@ -3,17 +3,15 @@ import XCTest
 extension RunnerTests {
   // MARK: - Blocking System Modal Snapshot
 
-  func blockingSystemAlertSnapshot() -> DataPayload? {
+  func blockingSystemAlertSnapshot(deadline: Date = .distantFuture) -> DataPayload? {
     #if os(macOS)
       return nil
     #else
-    guard let modal = firstBlockingSystemModal(in: springboard) else {
-      return nil
-    }
-    let actions = actionableElements(in: modal)
-    guard !actions.isEmpty else {
+    guard case .resolved(let resolvedModal) = resolveBlockingSystemModal(deadline: deadline) else {
       return nil
     }
+    let modal = resolvedModal.root
+    let actions = resolvedModal.actions
 
     let title = preferredSystemModalTitle(modal)
     guard let modalNode = safeMakeSnapshotNode(
@@ -29,20 +27,6 @@ extension RunnerTests {
     }
     var nodes: [SnapshotNode] = [modalNode]
 
-    for content in informativeElements(in: modal, excluding: actions) {
-      guard let contentNode = safeMakeSnapshotNode(
-        element: content,
-        index: nodes.count,
-        type: elementTypeName(content.elementType),
-        depth: 1,
-        parentIndex: 0,
-        hittableOverride: false
-      ) else {
-        continue
-      }
-      nodes.append(contentNode)
-    }
-
     for action in actions {
       guard let actionNode = safeMakeSnapshotNode(
         element: action,
@@ -57,11 +41,33 @@ extension RunnerTests {
       nodes.append(actionNode)
     }
 
+    // Action controls are the interaction contract. Informative text is useful context, but
+    // must not make a usable modal miss the bounded system-modal probe deadline.
+    let contentDeadline = deadline.addingTimeInterval(-0.5)
+    for content in informativeElements(in: modal, deadline: contentDeadline) {
+      guard Date() < contentDeadline,
+            let contentNode = safeMakeSnapshotNode(
+              element: content,
+              index: nodes.count,
+              type: elementTypeName(content.elementType),
+              depth: 1,
+              parentIndex: 0,
+              hittableOverride: false
+            )
+      else {
+        break
+      }
+      nodes.append(contentNode)
+    }
+
     return DataPayload(nodes: nodes, truncated: false)
     #endif
   }
 
-  func firstBlockingSystemModal(in springboard: XCUIApplication) -> XCUIElement? {
+  func firstBlockingSystemModal(
+    in springboard: XCUIApplication,
+    deadline: Date = .distantFuture
+  ) -> XCUIElement? {
     let disableSafeProbe = RunnerEnv.isTruthy("AGENT_DEVICE_RUNNER_DISABLE_SAFE_MODAL_PROBE")
     let queryElements: (() -> [XCUIElement]) -> [XCUIElement] = { fetch in
       if disableSafeProbe {
@@ -79,6 +85,12 @@ extension RunnerTests {
       }
     }
 
+    // Don't start the second (sheet) enumeration once the shared probe deadline is spent (#1244).
+    if Date() >= deadline {
+      NSLog("AGENT_DEVICE_RUNNER_SYSTEM_MODAL_PROBE_DEADLINE stage=sheets")
+      return nil
+    }
+
     let sheets = queryElements {
       springboard.sheets.allElementsBoundByIndex
     }
@@ -137,20 +149,18 @@ extension RunnerTests {
     }
   }
 
-  private func informativeElements(in element: XCUIElement, excluding actions: [XCUIElement]) -> [XCUIElement] {
-    let actionKeys = Set(actions.map(systemModalElementKey))
+  private func informativeElements(in element: XCUIElement, deadline: Date) -> [XCUIElement] {
     var seen = Set<String>()
     var contents: [XCUIElement] = []
-    let descendants = readableSystemModalTypes.flatMap {
-      modalDescendants(in: element, matching: $0, limit: 2)
-    }
-    for candidate in descendants {
-      guard let key = safeInformativeElementKey(candidate, actionKeys: actionKeys) else {
-        continue
+    for type in readableSystemModalTypes {
+      guard Date() < deadline else { break }
+      for candidate in modalDescendants(in: element, matching: type, limit: 2) {
+        guard Date() < deadline else { return contents }
+        guard let key = safeInformativeElementKey(candidate) else { continue }
+        if seen.contains(key) { continue }
+        seen.insert(key)
+        contents.append(candidate)
       }
-      if seen.contains(key) { continue }
-      seen.insert(key)
-      contents.append(candidate)
     }
     return contents
   }
@@ -173,11 +183,9 @@ extension RunnerTests {
     return Array(elements.prefix(limit))
   }
 
-  private func safeInformativeElementKey(_ candidate: XCUIElement, actionKeys: Set<String>) -> String? {
+  private func safeInformativeElementKey(_ candidate: XCUIElement) -> String? {
     safely("MODAL_CONTENT") { () -> String? in
       let key = systemModalElementKey(candidate)
-      if actionKeys.contains(key) { return nil }
-      if actionableTypes.contains(candidate.elementType) { return nil }
       if !candidate.exists { return nil }
       let frame = candidate.frame
       if frame.isNull || frame.isEmpty { return nil }

package/dist/{apple-runner → apple/runner}/AgentDeviceRunner/AgentDeviceRunnerUITests/RunnerTests.swift

@@ -29,6 +29,15 @@ final class RunnerTests: XCTestCase {
   }
 
   static let springboardBundleId = "com.apple.springboard"
+  // SpringBoard hosts blocking system modals on iOS/visionOS; tvOS (PineBoard/HeadBoard)
+  // and macOS have no such host, so there is nothing to probe there.
+  static let hasSpringBoardSystemModalHost: Bool = {
+    #if os(tvOS) || os(macOS)
+      return false
+    #else
+      return true
+    #endif
+  }()
   static let defaultRecordingFps: Int32 = 15
   var listener: NWListener?
   var doneExpectation: XCTestExpectation?
@@ -38,6 +47,7 @@ final class RunnerTests: XCTestCase {
   lazy var springboard = XCUIApplication(bundleIdentifier: Self.springboardBundleId)
   var currentApp: XCUIApplication?
   var currentBundleId: String?
+  var currentAppProcessIdentifier: Int?
   let maxRequestBytes = 2 * 1024 * 1024
   let mainThreadExecutionTimeout: TimeInterval = 30
   let appExistenceTimeout: TimeInterval = 30
@@ -76,6 +86,7 @@ final class RunnerTests: XCTestCase {
   var snapshotXCTestChannelPenaltyBundleId: String?
   var snapshotXCTestChannelPenaltyUntil = Date.distantPast
   let snapshotXCTestChannelPenaltyDuration: TimeInterval = 120
+  var snapshotXCTestPenaltyWarmupExemptionPending = false
   // Bluesky-class screens can grind ~4-8s before an XCTest-backed snapshot tier fails; anything
   // past this threshold marks the screen hostile so the next capture uses non-XCTest recovery.
   let snapshotXCTestSlowCaptureThreshold: TimeInterval = 3
@@ -87,6 +98,9 @@ final class RunnerTests: XCTestCase {
   let treeCaptureLock = NSLock()
   var abandonedTreeCaptureCount = 0
   let treeCaptureSliceBudget: TimeInterval = 8
+  // Bounds the pre-plan SpringBoard system-modal probe, which can otherwise grind for tens of
+  // seconds on remote-hosted consent dialogs and bypass the plan budget (#1244).
+  let systemModalProbeBudget: TimeInterval = 4
   // Observability for the record(_:) suppression below: how many AX-broken-screen snapshot
   // issues this session muted, so wedge investigations see the volume without grepping logs.
   let suppressedIssueLock = NSLock()