agent-device 0.21.19 → 0.21.21

package/dist/apple/runner/AgentDeviceRunner/AgentDeviceRunner/AgentDeviceRunnerApp.m

@@ -66,6 +66,10 @@ int main(int argc, const char *argv[]) {
 @property(nonatomic, assign) NSUInteger firstAlertActions;
 @property(nonatomic, assign) NSUInteger replacementAlertActions;
 @property(nonatomic, strong) UILabel *textEntryWriteBackStatus;
+@property(nonatomic, strong) UILabel *textEntryDigitSlots;
+// Filled from the fixture field's own delegate callbacks so a test can tell that a gesture really
+// took focus from an input that has stopped answering the accessibility query that found it.
+@property(nonatomic, strong) UILabel *textEntryFocusWitness;
 @property(nonatomic, assign) NSUInteger textEntryWriteBacks;
 @property(nonatomic, copy, nullable) NSString *textEntryRenderedValue;
 @property(nonatomic, assign) NSTimeInterval textEntryLastEditTime;
@@ -73,6 +77,7 @@ int main(int argc, const char *argv[]) {
 @property(nonatomic, assign) NSUInteger textEntryBurstEdits;
 @property(nonatomic, assign) NSTimeInterval textEntryBurstMinGap;
 @property(nonatomic, assign) NSTimeInterval textEntryAcknowledgeWindowSeconds;
+@property(nonatomic, strong) NSLayoutConstraint *textEntryFieldTop;
 @property(nonatomic, assign) BOOL alertFixtureStarted;
 @property(nonatomic, strong) NSTimer *alertActivationBusyBackstop;
 @property(nonatomic, strong) NSTimer *alertBannerRepost;
@@ -81,6 +86,17 @@ int main(int argc, const char *argv[]) {
 #if TARGET_OS_IOS
 @interface AgentDeviceRunnerViewController () <UNUserNotificationCenterDelegate>
 @end
+
+// A one-time-code field that announces how many digits it holds instead of the digits, the way
+// React Native OTP inputs set `accessibilityValue` on their hidden text input.
+@interface AgentDeviceDigitCountTextField : UITextField
+@end
+
+@implementation AgentDeviceDigitCountTextField
+- (NSString *)accessibilityValue {
+  return [NSString stringWithFormat:@"%lu of 6 digits", (unsigned long)self.text.length];
+}
+@end
 #endif
 
 @implementation AgentDeviceRunnerViewController
@@ -265,6 +281,11 @@ static NSTimeInterval AgentDeviceTextEntryAcknowledgeWindow(void) {
 // Edits further apart than this belong to different bursts: one runner command's characters arrive
 // well inside it, and two commands are separated by at least a commit-wait poll and a status read.
 static const NSTimeInterval AgentDeviceTextEntryBurstBreakSeconds = 1.0;
+static const NSUInteger AgentDeviceTextEntryAutoSubmitLength = 6;
+
+static const CGFloat AgentDeviceTextEntryFieldTopInset = 24;
+static const CGFloat AgentDeviceTextEntryFieldHeight = 44;
+static const CGFloat AgentDeviceTextEntryNeighbourGap = 16;
 
 - (void)agentDeviceTextEntryDidChange:(UITextField *)textField {
   // A field whose app owns its value, the way a controlled React Native `TextInput` does. A burst
@@ -293,10 +314,56 @@ static const NSTimeInterval AgentDeviceTextEntryBurstBreakSeconds = 1.0;
     }
     [self updateTextEntryWriteBackStatus];
   }
+  self.textEntryDigitSlots.text = textField.text;
   if ([NSProcessInfo.processInfo.arguments containsObject:@"--agent-device-text-entry-disappear-after-input"] &&
       textField.text.length > 0) {
     [textField removeFromSuperview];
   }
+  // An auto-submitting one-time-code field: the last digit navigates away, to a screen whose own
+  // input takes the code field's place or to one without an input. `replace-after-input` is the
+  // same navigation landing before the code is complete.
+  NSArray<NSString *> *arguments = NSProcessInfo.processInfo.arguments;
+  BOOL codeComplete = textField.text.length >= AgentDeviceTextEntryAutoSubmitLength;
+  if (textField.superview == nil) {
+    return;
+  }
+  if ((codeComplete && [arguments containsObject:@"--agent-device-text-entry-auto-submit"]) ||
+      (textField.text.length > 0 && [arguments containsObject:@"--agent-device-text-entry-replace-after-input"])) {
+    UITextField *nextScreenField = [[UITextField alloc] initWithFrame:textField.frame];
+    if (![arguments containsObject:@"--agent-device-text-entry-unnamed-input"]) {
+      nextScreenField.accessibilityIdentifier = @"agent-device-auto-submit-next-screen-input";
+    }
+    nextScreenField.borderStyle = UITextBorderStyleRoundedRect;
+    [textField.superview addSubview:nextScreenField];
+    [textField removeFromSuperview];
+    [nextScreenField becomeFirstResponder];
+  } else if (codeComplete &&
+             [arguments containsObject:@"--agent-device-text-entry-auto-submit-without-successor"]) {
+    [textField removeFromSuperview];
+  }
+}
+
+// Stops answering the element-type query that found it, the moment it takes focus, under
+// `--agent-device-text-entry-unqueryable-on-focus`. #3060's Flutter password field reaches this shape
+// because its two accessibility channels disagree once focused — `TextField` through the legacy
+// attributes, `Other` through the modern ones — and what either channel leaves behind is the same:
+// the tap's element answers the query that resolved it up to the gesture and refuses it after, so a
+// read of it after dispatching records an XCTest failure instead of describing the tap that already
+// landed. The field keeps first-responder, so a test still needs a witness that is not the
+// accessibility tree to tell the gesture landed: `agent-device-text-entry-focus` is a label this
+// method fills in from the field's own delegate callback.
+- (void)agentDeviceTextEntryBecomesUnqueryable:(UITextField *)textField {
+  self.textEntryFocusWitness.text = @"focus";
+  textField.hidden = YES;
+}
+
+// Moves the field up by its own height plus the gap below it when it gains focus, the way keyboard
+// avoidance or a bottom sheet extending above the keyboard does, so the neighbouring field slides
+// into the point the focus tap hit.
+- (void)agentDeviceTextEntryDidBeginEditing:(UITextField *)textField {
+  self.textEntryFieldTop.constant =
+      AgentDeviceTextEntryFieldTopInset - AgentDeviceTextEntryFieldHeight - AgentDeviceTextEntryNeighbourGap;
+  [self.view layoutIfNeeded];
 }
 #endif
 
@@ -339,8 +406,13 @@ static const NSTimeInterval AgentDeviceTextEntryBurstBreakSeconds = 1.0;
   }
 
   if ([NSProcessInfo.processInfo.arguments containsObject:@"--agent-device-text-entry-regression"]) {
-    UITextField *textField = [[UITextField alloc] init];
-    textField.accessibilityIdentifier = @"agent-device-hardware-keyboard-input";
+    BOOL digitCountValue =
+        [NSProcessInfo.processInfo.arguments containsObject:@"--agent-device-text-entry-digit-count-value"];
+    UITextField *textField =
+        digitCountValue ? [[AgentDeviceDigitCountTextField alloc] init] : [[UITextField alloc] init];
+    if (![NSProcessInfo.processInfo.arguments containsObject:@"--agent-device-text-entry-unnamed-input"]) {
+      textField.accessibilityIdentifier = @"agent-device-hardware-keyboard-input";
+    }
     textField.borderStyle = UITextBorderStyleRoundedRect;
     // An empty input view keeps the software keyboard down, which is the hardware-keyboard responder
     // these routes are addressed to. `--agent-device-text-entry-soft-keyboard` leaves the real input
@@ -354,12 +426,46 @@ static const NSTimeInterval AgentDeviceTextEntryBurstBreakSeconds = 1.0;
         forControlEvents:UIControlEventEditingChanged];
     textField.translatesAutoresizingMaskIntoConstraints = NO;
     [self.view addSubview:textField];
+    self.textEntryFieldTop = [textField.topAnchor constraintEqualToAnchor:label.bottomAnchor
+                                                                 constant:AgentDeviceTextEntryFieldTopInset];
     [NSLayoutConstraint activateConstraints:@[
       [textField.centerXAnchor constraintEqualToAnchor:self.view.centerXAnchor],
-      [textField.topAnchor constraintEqualToAnchor:label.bottomAnchor constant:24],
+      self.textEntryFieldTop,
       [textField.widthAnchor constraintEqualToConstant:240],
-      [textField.heightAnchor constraintEqualToConstant:44],
+      [textField.heightAnchor constraintEqualToConstant:AgentDeviceTextEntryFieldHeight],
     ]];
+    if ([NSProcessInfo.processInfo.arguments containsObject:@"--agent-device-text-entry-unqueryable-on-focus"]) {
+      self.textEntryFocusWitness = [[UILabel alloc] init];
+      self.textEntryFocusWitness.accessibilityIdentifier = @"agent-device-text-entry-focus";
+      self.textEntryFocusWitness.translatesAutoresizingMaskIntoConstraints = NO;
+      [self.view addSubview:self.textEntryFocusWitness];
+      [NSLayoutConstraint activateConstraints:@[
+        [self.textEntryFocusWitness.centerXAnchor constraintEqualToAnchor:self.view.centerXAnchor],
+        [self.textEntryFocusWitness.topAnchor constraintEqualToAnchor:textField.bottomAnchor constant:24],
+      ]];
+      [textField addTarget:self
+                    action:@selector(agentDeviceTextEntryBecomesUnqueryable:)
+          forControlEvents:UIControlEventEditingDidBegin];
+    }
+    if ([NSProcessInfo.processInfo.arguments containsObject:@"--agent-device-text-entry-moves-on-focus"]) {
+      textField.text = @"stale";
+      [textField addTarget:self
+                    action:@selector(agentDeviceTextEntryDidBeginEditing:)
+          forControlEvents:UIControlEventEditingDidBegin];
+      UITextField *neighbour = [[UITextField alloc] init];
+      neighbour.accessibilityIdentifier = @"agent-device-text-entry-neighbour";
+      neighbour.borderStyle = UITextBorderStyleRoundedRect;
+      neighbour.text = @"neighbour";
+      neighbour.translatesAutoresizingMaskIntoConstraints = NO;
+      [self.view addSubview:neighbour];
+      [NSLayoutConstraint activateConstraints:@[
+        [neighbour.centerXAnchor constraintEqualToAnchor:self.view.centerXAnchor],
+        [neighbour.topAnchor constraintEqualToAnchor:textField.bottomAnchor
+                                            constant:AgentDeviceTextEntryNeighbourGap],
+        [neighbour.widthAnchor constraintEqualToConstant:240],
+        [neighbour.heightAnchor constraintEqualToConstant:AgentDeviceTextEntryFieldHeight],
+      ]];
+    }
     if ([NSProcessInfo.processInfo.arguments containsObject:@"--agent-device-text-entry-app-owned-value"]) {
       self.textEntryAcknowledgeWindowSeconds = AgentDeviceTextEntryAcknowledgeWindow();
       // Reports how many edits this app rendered and how many writes it had to make because a
@@ -375,6 +481,17 @@ static const NSTimeInterval AgentDeviceTextEntryBurstBreakSeconds = 1.0;
       ]];
       [self updateTextEntryWriteBackStatus];
     }
+    if (digitCountValue) {
+      // The slots an OTP screen renders next to its input: the digits the field really holds.
+      self.textEntryDigitSlots = [[UILabel alloc] init];
+      self.textEntryDigitSlots.accessibilityIdentifier = @"agent-device-text-entry-digit-slots";
+      self.textEntryDigitSlots.translatesAutoresizingMaskIntoConstraints = NO;
+      [self.view addSubview:self.textEntryDigitSlots];
+      [NSLayoutConstraint activateConstraints:@[
+        [self.textEntryDigitSlots.centerXAnchor constraintEqualToAnchor:self.view.centerXAnchor],
+        [self.textEntryDigitSlots.topAnchor constraintEqualToAnchor:textField.bottomAnchor constant:12],
+      ]];
+    }
   }
 
   if ([NSProcessInfo.processInfo.arguments containsObject:@"--agent-device-crowded-screen"]) {
@@ -422,6 +539,8 @@ static const NSTimeInterval AgentDeviceTextEntryBurstBreakSeconds = 1.0;
 // UIApplicationSceneManifest in Info.plist names this class; a rename must update the manifest.
 @interface AgentDeviceRunnerSceneDelegate : UIResponder <UIWindowSceneDelegate>
 @property(nonatomic, strong) UIWindow *window;
+// Held for the app's lifetime: a window nobody retained would be gone before the test queried it.
+@property(nonatomic, strong) UIWindow *secondWindow;
 @end
 
 @implementation AgentDeviceRunnerSceneDelegate
@@ -442,6 +561,16 @@ static const NSTimeInterval AgentDeviceTextEntryBurstBreakSeconds = 1.0;
   if ([NSProcessInfo.processInfo.arguments containsObject:@"--agent-device-dismiss-popup-window"]) {
     self.window.accessibilityIdentifier = @"Dismiss popup";
   }
+  // A second window the app keeps visible, so `app.windows` reports the main window and this one.
+  // Window order is what the resolver walks, and a candidate behind the answer must never be read.
+  if ([NSProcessInfo.processInfo.arguments containsObject:@"--agent-device-second-window"]) {
+    UIWindow *second = [[UIWindow alloc] initWithWindowScene:(UIWindowScene *)scene];
+    second.frame = ((UIWindowScene *)scene).coordinateSpace.bounds;
+    second.accessibilityIdentifier = @"agent-device-second-window";
+    second.rootViewController = [UIViewController new];
+    self.secondWindow = second;
+    [second makeKeyAndVisible];
+  }
 #endif
   [self.window makeKeyAndVisible];
 }

package/dist/apple/runner/AgentDeviceRunner/AgentDeviceRunnerUITests/RunnerSynthesizedGesture.h

@@ -5,6 +5,12 @@ NS_ASSUME_NONNULL_BEGIN
 FOUNDATION_EXPORT NSInteger RunnerControlledScrollFrameCount(double durationMs);
 FOUNDATION_EXPORT double RunnerControlledScrollProgress(double t);
 
+typedef NS_ENUM(NSInteger, RunnerTapSynthesisStatus) {
+  RunnerTapSynthesisStatusSucceeded,
+  RunnerTapSynthesisStatusDeadlineExceeded,
+  RunnerTapSynthesisStatusFailed,
+};
+
 @interface RunnerSynthesizedGesture : NSObject
 
 // `resolvedWindow` is the app window the caller already resolved for the gesture's reference
@@ -26,10 +32,12 @@ FOUNDATION_EXPORT double RunnerControlledScrollProgress(double t);
                                                                y2:(double)y2
                                                         durationMs:(double)durationMs;
 
-+ (NSString * _Nullable)synthesizeTapWithApplication:(id)application
++ (RunnerTapSynthesisStatus)synthesizeTapWithApplication:(id)application
                                       resolvedWindow:(id _Nullable)resolvedWindow
                                                    x:(double)x
-                                                   y:(double)y;
+                                                   y:(double)y
+                                            deadline:(NSDate * _Nullable)deadline
+                                        errorMessage:(NSString * _Nullable * _Nullable)errorMessage;
 
 // Each pointer is an ordered array of { x, y, offsetMs } samples. The first sample
 // starts contact; subsequent samples move it; all pointers lift at their final offset.

package/dist/apple/runner/AgentDeviceRunner/AgentDeviceRunnerUITests/RunnerSynthesizedGesture.m

@@ -75,7 +75,13 @@ static NSString * _Nullable RunnerTrySynthesizeDrag(
   NSString *recordName,
   RunnerDragPointerPathFactory pathFactory
 );
-static NSString * _Nullable RunnerTrySynthesizeTap(id application, id _Nullable resolvedWindow, CGPoint point);
+static RunnerTapSynthesisStatus RunnerTrySynthesizeTap(
+  id application,
+  id _Nullable resolvedWindow,
+  CGPoint point,
+  NSDate * _Nullable deadline,
+  NSString * _Nullable * _Nullable errorMessage
+);
 // XCTest's proven swipe profile reaches the endpoint in 100 ms, then holds for the planned
 // fling duration. Fast movement is what lets UIKit distinguish a fling from a timed pan.
 static const NSTimeInterval RunnerSwipeMovementDurationSeconds = 0.1;
@@ -132,14 +138,20 @@ static id RunnerTapPointerPath(
   }
 }
 
-+ (NSString * _Nullable)synthesizeTapWithApplication:(id)application
++ (RunnerTapSynthesisStatus)synthesizeTapWithApplication:(id)application
                                       resolvedWindow:(id _Nullable)resolvedWindow
                                                    x:(double)x
-                                                   y:(double)y {
+                                                   y:(double)y
+                                            deadline:(NSDate * _Nullable)deadline
+                                        errorMessage:(NSString * _Nullable * _Nullable)errorMessage {
+  if (errorMessage != NULL) *errorMessage = nil;
   @try {
-    return RunnerTrySynthesizeTap(application, resolvedWindow, CGPointMake(x, y));
+    return RunnerTrySynthesizeTap(application, resolvedWindow, CGPointMake(x, y), deadline, errorMessage);
   } @catch (NSException *exception) {
-    return RunnerFormatXCTestException(exception, @"private XCTest event synthesis failed");
+    if (errorMessage != NULL) {
+      *errorMessage = RunnerFormatXCTestException(exception, @"private XCTest event synthesis failed");
+    }
+    return RunnerTapSynthesisStatusFailed;
   }
 }
 
@@ -227,7 +239,13 @@ static NSString * _Nullable RunnerTrySynthesizeDrag(
   return RunnerSynthesizeEventRecord(&bridge, record);
 }
 
-static NSString * _Nullable RunnerTrySynthesizeTap(id application, id _Nullable resolvedWindow, CGPoint point) {
+static RunnerTapSynthesisStatus RunnerTrySynthesizeTap(
+  id application,
+  id _Nullable resolvedWindow,
+  CGPoint point,
+  NSDate * _Nullable deadline,
+  NSString * _Nullable * _Nullable errorMessage
+) {
   RunnerGestureEventBridge bridge;
   id record = nil;
   NSString *error = RunnerCreateEventRecord(
@@ -237,14 +255,23 @@ static NSString * _Nullable RunnerTrySynthesizeTap(id application, id _Nullable
     &bridge,
     &record
   );
-  if (error != nil) return error;
+  if (error != nil) {
+    if (errorMessage != NULL) *errorMessage = error;
+    return RunnerTapSynthesisStatusFailed;
+  }
 
   id path = RunnerTapPointerPath(&bridge, point);
   if (path == nil) {
-    return @"private XCTest event synthesis failed: could not create pointer path";
+    if (errorMessage != NULL) *errorMessage = @"private XCTest event synthesis failed: could not create pointer path";
+    return RunnerTapSynthesisStatusFailed;
   }
   ((RunnerMsgSendAddPath)objc_msgSend)(record, bridge.core.addPathSelector, path);
-  return RunnerSynthesizeEventRecord(&bridge, record);
+  if (deadline != nil && deadline.timeIntervalSinceNow <= 0) {
+    return RunnerTapSynthesisStatusDeadlineExceeded;
+  }
+  error = RunnerSynthesizeEventRecord(&bridge, record);
+  if (errorMessage != NULL) *errorMessage = error;
+  return error == nil ? RunnerTapSynthesisStatusSucceeded : RunnerTapSynthesisStatusFailed;
 }
 
 static NSString * _Nullable RunnerResolveGestureEventBridge(

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

@@ -138,12 +138,40 @@ extension RunnerTests {
 #if !os(tvOS)
         guard !frame.isEmpty else { return }
 #endif
+#if os(iOS)
+        let postEventWaitSelector = NSSelectorFromString("_waitForQuiescenceAsPreEvent:")
+        guard alert.ownerApp.responds(to: postEventWaitSelector) else {
+          outcome = .unsupported(
+            message: "alert activation could not wait for post-event quiescence",
+            hint: "Inspect the current alert before deciding whether to act again."
+          )
+          return
+        }
+        switch synthesizedTapAt(app: alert.ownerApp, x: frame.midX, y: frame.midY, deadline: deadline) {
+        case .performed?:
+          typealias WaitForQuiescence = @convention(c) (NSObject, Selector, Bool) -> Void
+          let waitForQuiescence = unsafeBitCast(
+            alert.ownerApp.method(for: postEventWaitSelector),
+            to: WaitForQuiescence.self
+          )
+          waitForQuiescence(alert.ownerApp, postEventWaitSelector, false)
+          outcome = .performed
+        case .unsupported(let message, _)?:
+          outcome = .unsupported(
+            message: message,
+            hint: "Inspect the current alert before deciding whether to act again."
+          )
+        case nil:
+          break
+        }
+#else
         outcome = activateElement(
           app: alert.ownerApp,
           element: button,
           action: "alert \(action)",
           resolvedFrame: frame
         )
+#endif
       }
     }
     return outcome

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

@@ -125,22 +125,9 @@ final class RunnerCommandJournal {
   }
 
   private func encodeResponseJson(command: Command, response: Response) -> String? {
-    guard shouldRetainResponseJson(command: command) else { return nil }
+    guard command.traits.retainsJournalResponseJson else { return nil }
     guard let data = try? JSONEncoder().encode(response) else { return nil }
     guard data.count <= maxResponseJsonBytes else { return nil }
     return String(data: data, encoding: .utf8)
   }
-
-  private func shouldRetainResponseJson(command: Command) -> Bool {
-    switch command.command {
-    case .snapshot, .screenshot:
-      return false
-    case .tap, .mouseClick, .longPress, .drag,
-         .remotePress, .type, .swipe, .scroll, .desktopScroll, .findText, .querySelector, .readText,
-         .backInApp, .backSystem, .home, .rotate, .appSwitcher, .actionButton, .keyboardDismiss, .keyboardReturn,
-         .alert, .sequence, .gesture, .gestureViewport, .recordStart, .recordStop,
-         .status, .uptime, .appState, .pasteboardWrite, .activate, .terminate, .targetReset, .shutdown:
-      return true
-    }
-  }
 }

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

@@ -224,25 +224,23 @@ extension RunnerTests {
 
 
 
-  func resolveRunnerWindow(app: XCUIApplication) -> (window: XCUIElement?, frame: CGRect) {
-    let windows = app.windows.allElementsBoundByIndex
-    var frames: [CGRect?] = []
-    for window in windows {
-      frames.append(window.exists ? window.frame : nil)
-    }
-    if let index = Self.firstUsableWindowIndex(frames: frames) {
-      return (windows[index], frames[index] ?? .zero)
-    }
-    return (nil, app.frame)
-  }
 
-  static func firstUsableWindowIndex(frames: [CGRect?]) -> Int? {
-    for (index, frame) in frames.enumerated() {
-      if let frame, !frame.isEmpty {
-        return index
+
+
+
+
+
+
+
+
+  func resolveRunnerWindow(app: XCUIApplication) -> (window: XCUIElement?, frame: CGRect) {
+    for window in app.windows.allElementsBoundByIndex where window.exists {
+      let frame = window.frame
+      if !frame.isEmpty {
+        return (window, frame)
       }
     }
-    return nil
+    return (nil, app.frame)
   }
 
   func onScreenWindowFrame(app: XCUIApplication) -> CGRect {

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

@@ -102,16 +102,20 @@ struct CommandTraits {
 
   let convertsRecordedFailure: Bool
 
+  let retainsJournalResponseJson: Bool
+
   init(
     isInteraction: Bool = false,
     retryOnSessionLoss: Bool = false,
     launchPolicy: CommandLaunchPolicy,
-    convertsRecordedFailure: Bool = false
+    convertsRecordedFailure: Bool = false,
+    retainsJournalResponseJson: Bool
   ) {
     self.isInteraction = isInteraction
     self.retryOnSessionLoss = retryOnSessionLoss
     self.launchPolicy = launchPolicy
     self.convertsRecordedFailure = convertsRecordedFailure
+    self.retainsJournalResponseJson = retainsJournalResponseJson
   }
 }
 
@@ -121,18 +125,26 @@ fileprivate extension CommandTraits {
   static let interaction = CommandTraits(
     isInteraction: true,
     launchPolicy: .mayLaunch,
-    convertsRecordedFailure: true
+    convertsRecordedFailure: true,
+    retainsJournalResponseJson: true
   )
 
 
 
 
 
-  static let appMutation = CommandTraits(launchPolicy: .mayLaunch, convertsRecordedFailure: true)
+  static let appMutation = CommandTraits(
+    launchPolicy: .mayLaunch, convertsRecordedFailure: true, retainsJournalResponseJson: true
+  )
 
 
 
-  static let appRead = CommandTraits(retryOnSessionLoss: true, launchPolicy: .existingApp)
+  static func appRead(retainsJournalResponseJson: Bool) -> CommandTraits {
+    CommandTraits(
+      retryOnSessionLoss: true, launchPolicy: .existingApp,
+      retainsJournalResponseJson: retainsJournalResponseJson
+    )
+  }
 
 
 
@@ -140,33 +152,41 @@ fileprivate extension CommandTraits {
 
   static let selectorResolution = CommandTraits(
     launchPolicy: .existingApp,
-    convertsRecordedFailure: true
+    convertsRecordedFailure: true,
+    retainsJournalResponseJson: true
   )
 
 
 
-  static let runnerCaptureRead = CommandTraits(retryOnSessionLoss: true, launchPolicy: .noApp)
+  static func runnerCaptureRead(retainsJournalResponseJson: Bool) -> CommandTraits {
+    CommandTraits(
+      retryOnSessionLoss: true, launchPolicy: .noApp,
+      retainsJournalResponseJson: retainsJournalResponseJson
+    )
+  }
 
 
-  static let runnerLifecycle = CommandTraits(launchPolicy: .noApp)
+  static let runnerLifecycle = CommandTraits(launchPolicy: .noApp, retainsJournalResponseJson: true)
 
 
 
 
-  static let deviceState = CommandTraits(launchPolicy: .noApp)
+  static let deviceState = CommandTraits(launchPolicy: .noApp, retainsJournalResponseJson: true)
 
 
 
 
   static let presentedSurfaceMutation = CommandTraits(
     launchPolicy: .presentedSurface,
-    convertsRecordedFailure: true
+    convertsRecordedFailure: true,
+    retainsJournalResponseJson: true
   )
 
 
   static let presentedSurfaceQuery = CommandTraits(
     retryOnSessionLoss: true,
-    launchPolicy: .presentedSurface
+    launchPolicy: .presentedSurface,
+    retainsJournalResponseJson: true
   )
 }
 
@@ -243,13 +263,19 @@ extension Command {
          .keyboardDismiss, .keyboardReturn, .sequence, .gesture:
       return .interaction
 
-    case .findText, .readText, .snapshot, .gestureViewport:
-      return .appRead
+    case .findText, .readText, .gestureViewport:
+      return .appRead(retainsJournalResponseJson: true)
+
+    case .snapshot:
+      return .appRead(retainsJournalResponseJson: false)
 
 
 
-    case .screenshot, .status, .appState:
-      return .runnerCaptureRead
+    case .status, .appState:
+      return .runnerCaptureRead(retainsJournalResponseJson: true)
+
+    case .screenshot:
+      return .runnerCaptureRead(retainsJournalResponseJson: false)
 
     case .alert:
       return (action ?? "get").lowercased() == "get"
@@ -444,6 +470,13 @@ struct DataPayload: Codable {
   var keyboardMinY: Double?
   var maestroNonHittableCoordinateFallbackUsed: Bool?
   var textEntryRoute: String?
+
+
+  var verification: String?
+  var requested: String?
+  var before: String?
+  var after: String?
+  var target: TextEntryVerificationTargetPayload?
   var runnerFatal: Bool?
   var runnerFatalReason: String?
 
@@ -461,6 +494,26 @@ struct DataPayload: Codable {
 }
 
 
+struct TextEntryVerificationTargetPayload: Codable, Equatable {
+  let resourceId: String?
+  let className: String?
+  let packageName: String?
+  let rect: SnapshotRect
+
+  enum CodingKeys: String, CodingKey {
+    case resourceId, className, packageName, rect
+  }
+
+  func encode(to encoder: Encoder) throws {
+    var container = encoder.container(keyedBy: CodingKeys.self)
+    try container.encode(resourceId, forKey: .resourceId)
+    try container.encode(className, forKey: .className)
+    try container.encode(packageName, forKey: .packageName)
+    try container.encode(rect, forKey: .rect)
+  }
+}
+
+
 
 
 

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

@@ -68,6 +68,7 @@ extension RunnerTests {
 
 
 
+
   func awaitSynthesizedReplacementCommit(
     app: XCUIApplication,
     target: TextEntryTarget,
@@ -82,6 +83,7 @@ extension RunnerTests {
     let outcome = Self.awaitSynthesizedReplacementCommitOutcome(
       expectedText: expectedText,
       placeholder: ingredients.placeholder,
+      fieldIsSecure: ingredients.fieldIsSecure,
       now: { Date() },
       observe: ingredients.observe,
       waitForNextObservation: ingredients.waitForNextObservation
@@ -132,13 +134,16 @@ extension RunnerTests {
     expectedText: String
   ) -> (
     placeholder: String?,
+    fieldIsSecure: Bool,
     observe: () -> String?,
     waitForNextObservation: () -> Void
   ) {
-    let placeholder = resolveTextEntryElement(app: app, target: target)?.placeholderValue
+    let field = resolveTextEntryElement(app: app, target: target)
+    let placeholder = field?.placeholderValue
     let waitStartedAt = Date()
     return (
       placeholder: placeholder,
+      fieldIsSecure: field?.elementType == .secureTextField,
       observe: {
         let observedText = self.editableTextValue(
           for: self.resolveTextEntryElement(app: app, target: target),

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

@@ -143,9 +143,14 @@ extension RunnerTests {
     _ app: XCUIApplication,
     kind: SynthesizedGesturePolicyKind,
     context: SynthesizedCoordinateContext?,
-    synthesize: () -> RunnerInteractionOutcome
+    synthesize: () -> RunnerInteractionOutcome?
   ) -> SynthesizedGestureAttempt {
-    let (timing, outcome) = performGesture(app, idleTimeout: false, synthesize)
+    var outcome: RunnerInteractionOutcome?
+    let timing = measureGesture { outcome = synthesize() }
+    guard let outcome else {
+      logSynthesizedGesturePolicyDecision(kind: kind, context: context, fallbackAttempted: false)
+      return .refused(timing: timing, message: "synthesized gesture deadline expired before dispatch", hint: nil)
+    }
     guard case .unsupported(let message, let hint) = outcome else {
       logSynthesizedGesturePolicyDecision(kind: kind, context: context, fallbackAttempted: false)
       return .performed(timing: timing)