@@ -182,11 +182,18 @@ extension RunnerTests {
 
     /// The target moved to the input a resolution read: its element, a refresh point at its center,
     /// and its identity while the target is unbound.
-    func withResolvedInput(_ input: ResolvedTextEntryInput?) -> TextEntryTarget {
+    ///
+    /// `translation` is the live snapshot-frame vector for the reading session (#3899): the snapshot
+    /// frame of a placed window's input names the window's content space, while a refresh point is
+    /// compared against screen-space probes, so the center enters the target translated.
+    func withResolvedInput(
+      _ input: ResolvedTextEntryInput?,
+      translation: CGSize? = nil
+    ) -> TextEntryTarget {
       guard let input else {
         return self
       }
-      let frame = input.snapshot?.frame ?? .zero
+      let frame = snapshotFrameOnScreen(input.snapshot?.frame ?? .zero, translation: translation)
       return TextEntryTarget(
         element: input.element,
         refreshPoint: frame.isEmpty ? refreshPoint : CGPoint(x: frame.midX, y: frame.midY),
@@ -259,9 +266,15 @@ extension RunnerTests {
     private(set) var target: TextEntryTarget
     private var lastRead: ResolvedTextEntryInput?
     private let resolve: (TextEntryTarget) -> ResolvedTextEntryInput?
+    private let translation: CGSize?
 
-    init(target: TextEntryTarget, resolve: @escaping (TextEntryTarget) -> ResolvedTextEntryInput?) {
-      self.target = target.withResolvedInput(target.postFocusRead)
+    init(
+      target: TextEntryTarget,
+      translation: CGSize? = nil,
+      resolve: @escaping (TextEntryTarget) -> ResolvedTextEntryInput?
+    ) {
+      self.translation = translation
+      self.target = target.withResolvedInput(target.postFocusRead, translation: translation)
       lastRead = target.postFocusRead
       self.resolve = resolve
     }
@@ -271,7 +284,7 @@ extension RunnerTests {
         return lastRead
       }
       let read = resolve(target)
-      target = target.withResolvedInput(read)
+      target = target.withResolvedInput(read, translation: translation)
       lastRead = read
       return read
     }
 
@@ -134,7 +134,10 @@ extension RunnerTests {
     let input = textInputAt(app: app, x: x, y: y)
     let target = input?.element
     let requestedPoint = CGPoint(x: x, y: y)
-    if let frame = input?.attributes.frame, !frame.isEmpty {
+    // The input's frame arrives from a snapshot, which reports a placed window's content in the
+    // window's own space; the tap below is a screen point (#3899).
+    if let read = input, !read.attributes.frame.isEmpty {
+      let frame = snapshotFrameOnScreen(read.attributes.frame, translation: liveContentTranslation(app: app))
       _ = tapAt(app: app, x: frame.midX, y: frame.midY)
     } else {
       _ = tapAt(app: app, x: x, y: y)
 
@@ -1,4 +1,5 @@
 import XCTest
+import AgentDeviceSnapshotPresentation
 
 final class TextInputProbeIssues {
   let thread = Thread.current
@@ -153,6 +154,7 @@ extension RunnerTests {
     shouldStop: () -> Bool
   ) -> [ResolvedTextEntryInput] {
     var inputs: [ResolvedTextEntryInput] = []
+    let translation = liveContentTranslation(app: app)
     for query in [app.textFields, app.secureTextFields, app.searchFields, app.textViews] {
       if shouldStop() { break }
       let candidates = query.allElementsBoundByIndex
@@ -168,12 +170,36 @@ extension RunnerTests {
         if shouldStop() { break }
         guard let candidate = ResolvedTextEntryInput(readingListed: element) else { continue }
         let attributes = candidate.attributes
-        if isCoordinateTextInputCandidate(enabled: attributes.isEnabled, frame: attributes.frame, point: point) {
+        let frame = snapshotFrameOnScreen(attributes.frame, translation: translation)
+        if isCoordinateTextInputCandidate(enabled: attributes.isEnabled, frame: frame, point: point) {
           inputs.append(candidate)
         }
       }
     }
     guard !shouldStop() else { return [] }
     return inputs.sorted { smallestElementFirst($0.attributes, $1.attributes) }
   }
+
+  /// The vector that carries this session's snapshot-read app-content frames to their place on the
+  /// screen, or nil when the app fills the screen (#3899).
+  ///
+  /// The live `XCUIElement.frame` property already reports a placed window's content in screen space,
+  /// but `XCUIElementSnapshot.frame` reports it in the window's own content space, so the same probe
+  /// sees two spaces on an iPad Windowed Apps window. The signature and the vector are the capture's
+  /// rule (`SnapshotContentTranslation`, ADR 0004) read from the two live boxes that name it: the
+  /// application's `frame` is a `(0,0)`-anchored copy of the box the resolved window reports at its
+  /// place on the screen. Any other pair of boxes declares no vector, so full-screen, iPhone, and
+  /// each foldable panel keep their frames exactly as read.
+  func liveContentTranslation(app: XCUIApplication) -> CGSize? {
+    safely("LIVE_CONTENT_TRANSLATION", nil) {
+      guard let resolved = resolveRunnerWindowElement(app: app) else { return nil }
+      return SnapshotContentTranslation.offset(reportedBox: app.frame, viewportBox: resolved.frame)
+    }
+  }
+}
+
+/// `frame` as the screen names it, given `liveContentTranslation`'s vector.
+func snapshotFrameOnScreen(_ frame: CGRect, translation: CGSize?) -> CGRect {
+  guard let translation else { return frame }
+  return frame.offsetBy(dx: translation.width, dy: translation.height)
 }
@@ -16,7 +16,13 @@ extension RunnerTests {
   ) -> TextEntryResult {
     let totalStartedAt = Date()
     let resolve = { (target: TextEntryTarget) in self.resolveTextEntryInput(app: app, target: target) }
-    var reader = TextEntryReader(target: target, resolve: resolve)
+    // Reads inside the typing loop answer from snapshots, which report a placed window's content in
+    // the window's own space; the reader's refresh points are screen points (#3899).
+    var reader = TextEntryReader(
+      target: target,
+      translation: liveContentTranslation(app: app),
+      resolve: resolve
+    )
     guard !text.isEmpty else {
       // Replacing a field WITH the empty string is the clear-field primitive (#2063): the typing
       // is vacuous but the clear is not. Returning here unconditionally left the old value in
@@ -74,7 +80,11 @@ extension RunnerTests {
       case .completed(let result):
         return result
       case .fallback(let fallbackTarget):
-        reader = TextEntryReader(target: fallbackTarget, resolve: resolve)
+        reader = TextEntryReader(
+          target: fallbackTarget,
+          translation: liveContentTranslation(app: app),
+          resolve: resolve
+        )
       }
     }
     let shouldUseSynthesizedFirstResponderType = Self.shouldUseSynthesizedFirstResponderType(
 
@@ -660,8 +660,9 @@ Translation is the one rule that reads an origin, so it is the only place the fi
 Capture is half of the promise; dispatch is the other half.
 The measured dispatch spaces for a placed window are both screen-anchored: the synthesized path lands a point at its screen position, and XCTest's own `XCUICoordinate` on the app anchors at the screen's origin too.
 `interactionCoordinate` therefore passes the caller's screen point through, and `resolveRunnerWindow` keeps naming the window a foldable's tap resolves its display on (ADR 0025).
-The live `XCUIElement.frame` reads that the tap path already compares — the selector match, the input probe, the tree's sweep candidates — report screen space on a placed window, as the ref-tap path proved on the device.
-Only the snapshot channel arrives window-relative, and only that channel converts.
+The live `XCUIElement.frame` property reports screen space on a placed window, as the selector-tap path proved on the device: it measured the `Add` button at (641,321) for a window at (324,307).
+The one live read that does not is `XCUIElementSnapshot.frame`, which reports the window's content space like the capture channel does.
+So the snapshot capture converts in `SnapshotGeometrySpace.normalized`, and the text-input probe converts its snapshot reads through the same `SnapshotContentTranslation` rule read from the two live boxes (`app.frame` against the resolved window's frame); every other live read needs no conversion.
 
 ## Amendment: modal containment in the presentation cut