@@ -72,8 +72,7 @@ extension RunnerTests {
       latest = observed
       let result = RunnerTests.replacementTextEntryResult(requested: requested, baseline: baseline, observed: observed)
       let settled = sampledAt.timeIntervalSince(stableSince) >= TextEntryTiming.verificationStabilityWindow
-      let moved = baseline.map { !observed.isSettled(with: $0) } ?? true
-      if settled && (moved || result.verified != false || sampledAt >= deadline) {
+      if settled && (result.verified != false || sampledAt >= deadline) {
         return result
       }
       if sampledAt >= deadline {
 
@@ -146,6 +146,44 @@ extension RunnerTests {
     XCTAssertFalse(result.repaired)
   }
 
+  func testReplacementMismatchWaitsForCorrectTextOrDeadline() throws {
+    let startedAt = Date(timeIntervalSinceReferenceDate: 100)
+    let unidentified = TextEntryElementIdentity(
+      identifier: nil, elementType: "TextField", frame: Self.otpFieldIdentity.frame
+    )
+    let shifted = TextEntryElementIdentity(
+      identifier: nil, elementType: "TextField", frame: unidentified.frame.offsetBy(dx: 0, dy: 60)
+    )
+    let cases: [(String, TextEntryObservation, TextEntryObservation)] = [
+      ("partial value", Self.otpObservation(""), Self.otpObservation("123")),
+      (
+        "empty moved field",
+        TextEntryObservation(value: "", identity: unidentified, isFocused: true),
+        TextEntryObservation(value: "", identity: shifted, isFocused: true)
+      ),
+    ]
+    for (name, baseline, mismatch) in cases {
+      var confirmation = ReplacementTextEntryConfirmation(requested: "123456", baseline: baseline, startedAt: startedAt)
+      XCTAssertNil(confirmation.observe(mismatch, at: startedAt.addingTimeInterval(0.1)), name)
+      XCTAssertNil(confirmation.observe(mismatch, at: startedAt.addingTimeInterval(0.31)), name)
+      let correct = TextEntryObservation(value: "123456", identity: mismatch.identity, isFocused: mismatch.isFocused)
+      XCTAssertNil(confirmation.observe(correct, at: startedAt.addingTimeInterval(0.5)), name)
+      let success = try XCTUnwrap(confirmation.observe(correct, at: startedAt.addingTimeInterval(0.71)), name)
+      XCTAssertEqual(success.verified, true, name)
+      XCTAssertNil(success.failure, name)
+      XCTAssertFalse(success.repaired, name)
+
+      var persistent = ReplacementTextEntryConfirmation(requested: "123456", baseline: baseline, startedAt: startedAt)
+      XCTAssertNil(persistent.observe(mismatch, at: startedAt.addingTimeInterval(0.1)), name)
+      XCTAssertNil(persistent.observe(mismatch, at: startedAt.addingTimeInterval(0.31)), name)
+      let failure = try XCTUnwrap(persistent.observe(mismatch, at: startedAt.addingTimeInterval(1.1)), name)
+      XCTAssertEqual(failure.verified, false, name)
+      XCTAssertEqual(failure.observedText, mismatch.value, name)
+      XCTAssertNil(failure.failure, name)
+      XCTAssertFalse(failure.repaired, name)
+    }
+  }
+
   func testReplacementSubmitDoesNotTreatMultilineContentAsASubmitKey() {
     for after in ["", "hllo", "submitted"] {
       let submitted = Self.replacementTextEntryResult(
 
@@ -184,7 +184,7 @@ Stabilizers:
 Text-entry quirks:
   iOS Allow Paste cannot be exercised under XCUITest; prefill with clipboard write "some text" instead and test the system prompt manually.
   Android Gboard handwriting/stylus UI can capture text in an IME-owned input instead of the app field. If fill reports that input was captured by the keyboard/IME, use the diagnostic targetInput/actualInput details, inspect keyboard status/get if needed, and switch or disable handwriting outside the command plan before retrying. Do not keep retrying fill/type against the same field while the IME owns focus. If the exact target changes but app-owned formatting prevents raw equality, fill succeeds with verification: "unconfirmed" plus target-bound requested/before/after evidence; inspect that evidence instead of retrying the same mutation.
-  iOS accessibility-driven fill types the replacement once and never clears and retypes a read-back mismatch. Exact settled text confirms the entry. A value containing only characters in order from the post-clear value plus the request fails with TEXT_ENTRY_MISMATCH, including plain dropped characters and unchanged values; legitimate trimming or masks can also hit this limit ("5" into "$0.00" displaying "$0.05"). Other settled values return verification: "unconfirmed" with requested/before/after/target evidence, including grouping ("00 062 91 77" for "000629177"), currency ("$10.00" for "1000"), and OTP summaries. Missing, reordered, duplicated or stale text can also be unconfirmed, so assert the expected value with a value selector, get/is, or the resulting screen before continuing. For single-line fills ending in a submit key, any non-matching value observed on the same target succeeds unverified, including partial or cleared text; this exception skips dropped-character checks because the submit may change the field. Assert the resulting screen. Multiline fields compare newlines as content. Unreadable or removed fields remain unverified. The coordinate-driven fill route still requires an exact match. After TEXT_ENTRY_MISMATCH, inspect the field and retry fill only if it needs correction, using the --delay-ms value from the error hint.
+  iOS accessibility-driven fill types the replacement once and never clears and retypes a read-back mismatch. Exact settled text confirms the entry. Nonempty replacements wait until the confirmation deadline before reporting TEXT_ENTRY_MISMATCH. A value containing only characters in order from the post-clear value plus the request fails with TEXT_ENTRY_MISMATCH, including plain dropped characters and unchanged values; legitimate trimming or masks can also hit this limit ("5" into "$0.00" displaying "$0.05"). Other settled values return verification: "unconfirmed" with requested/before/after/target evidence, including grouping ("00 062 91 77" for "000629177"), currency ("$10.00" for "1000"), and OTP summaries. Missing, reordered, duplicated or stale text can also be unconfirmed, so assert the expected value with a value selector, get/is, or the resulting screen before continuing. For single-line fills ending in a submit key, any non-matching value observed on the same target succeeds unverified, including partial or cleared text; this exception skips dropped-character checks because the submit may change the field. Assert the resulting screen. Multiline fields compare newlines as content. Unreadable or removed fields remain unverified. The coordinate-driven fill route still requires an exact match. After TEXT_ENTRY_MISMATCH, inspect the field and retry fill only if it needs correction, using the --delay-ms value from the error hint.
 
 React Native internals:
   If the question is about React component props, state, hooks, the component tree, performance, render causes, slow components, or rerenders, use help react-devtools instead of inferring from screenshots or logs.`,
 
@@ -502,7 +502,7 @@ Text-entry errors and what to do:
 - `TEXT_INPUT_SYNTHESIS_BUDGET_EXCEEDED` (iOS `fill`): the text is too long to type in one runner command, and nothing was typed. Fill up to the character limit the hint names for your `--delay-ms`, then append the rest with `type`. `--delay-ms` lowers the limit; a longer timeout does not help.
 - `TEXT_ENTRY_MISMATCH` (iOS `fill`): the settled value contains only characters, in order, from the field's value after clearing plus your text. That covers dropped characters and an unchanged value. This can also reject legitimate filtering, trimming, or masks (`5` into `$0.00` may show `$0.05`). Inspect the field and retry `fill` only if it needs correction, using the `--delay-ms` value from the error hint.
 
-Except for `TEXT_INPUT_SYNTHESIS_BUDGET_EXCEEDED`, where you append the rest with `type` after the shorter `fill`, recover from these with `fill`, never `type`, which appends to whatever the field already holds. iOS `fill` types the replacement once and does not clear and retype a mismatch on its own.
+Except for `TEXT_INPUT_SYNTHESIS_BUDGET_EXCEEDED`, where you append the rest with `type` after the shorter `fill`, recover from these with `fill`, never `type`, which appends to whatever the field already holds. iOS `fill` types the replacement once and does not clear and retype a mismatch on its own. On the iOS accessibility route, nonempty fills wait until the confirmation deadline before reporting `TEXT_ENTRY_MISMATCH`.
 
 On iOS, a single-line `fill` ending in a submit key, or a field that became unreadable or disappeared after typing, succeeds without verification; assert the resulting screen.