@@ -97,6 +97,53 @@ - (NSString *)accessibilityValue {
   return [NSString stringWithFormat:@"%lu of 6 digits", (unsigned long)self.text.length];
 }
 @end
+
+// A field that reformats its own text on every edit into `## ### ## ##` digit groups, the way a
+// digit-grouping formatter in a Flutter or React Native input does. The accessibility value is
+// what the user sees — the formatted string — so it never equals the digits a `fill` sent (#2634).
+// The field owns the delegate it installs, keeping the formatter out of the view controller's
+// own delegate callbacks.
+@interface AgentDeviceDigitGroupingTextField : UITextField <UITextFieldDelegate>
+@end
+
+static NSString *AgentDeviceFormatGroupedDigits(NSString *raw) {
+  NSMutableString *digits = [NSMutableString string];
+  NSCharacterSet *nonDigits = [[NSCharacterSet decimalDigitCharacterSet] invertedSet];
+  for (NSString *chunk in [raw componentsSeparatedByCharactersInSet:nonDigits]) {
+    [digits appendString:chunk];
+  }
+  NSMutableArray<NSNumber *> *groupWidths = [NSMutableArray arrayWithArray:@[@2, @3, @2, @2]];
+  NSMutableString *formatted = [NSMutableString string];
+  NSUInteger cursor = 0;
+  for (NSNumber *width in groupWidths) {
+    if (cursor >= digits.length) {
+      break;
+    }
+    if (formatted.length > 0) {
+      [formatted appendString:@" "];
+    }
+    NSUInteger end = MIN(cursor + width.unsignedIntegerValue, digits.length);
+    [formatted appendString:[digits substringWithRange:NSMakeRange(cursor, end - cursor)]];
+    cursor = end;
+  }
+  // Digits past the last group keep grouping by threes rather than vanishing from the field.
+  while (cursor < digits.length) {
+    NSUInteger end = MIN(cursor + 3, digits.length);
+    [formatted appendString:[NSString stringWithFormat:@" %@", [digits substringWithRange:NSMakeRange(cursor, end - cursor)]]];
+    cursor = end;
+  }
+  return formatted;
+}
+
+@implementation AgentDeviceDigitGroupingTextField
+- (BOOL)textField:(UITextField *)textField
+      shouldChangeCharactersInRange:(NSRange)range
+               replacementString:(NSString *)string {
+  NSString *combined = [textField.text stringByReplacingCharactersInRange:range withString:string];
+  textField.text = AgentDeviceFormatGroupedDigits(combined);
+  return NO;
+}
+@end
 #endif
 
 @implementation AgentDeviceRunnerViewController
@@ -408,8 +455,20 @@ - (void)viewDidLoad {
   if ([NSProcessInfo.processInfo.arguments containsObject:@"--agent-device-text-entry-regression"]) {
     BOOL digitCountValue =
         [NSProcessInfo.processInfo.arguments containsObject:@"--agent-device-text-entry-digit-count-value"];
-    UITextField *textField =
-        digitCountValue ? [[AgentDeviceDigitCountTextField alloc] init] : [[UITextField alloc] init];
+    BOOL digitGroupingValue =
+        [NSProcessInfo.processInfo.arguments containsObject:@"--agent-device-text-entry-digit-grouping-value"];
+    UITextField *textField;
+    if (digitCountValue) {
+      textField = [[AgentDeviceDigitCountTextField alloc] init];
+    } else if (digitGroupingValue) {
+      textField = [[AgentDeviceDigitGroupingTextField alloc] init];
+    } else {
+      textField = [[UITextField alloc] init];
+    }
+    if (digitGroupingValue) {
+      // The formatter field is its own delegate: every edit is reformatted before it lands.
+      textField.delegate = (id<UITextFieldDelegate>)textField;
+    }
     if (![NSProcessInfo.processInfo.arguments containsObject:@"--agent-device-text-entry-unnamed-input"]) {
       textField.accessibilityIdentifier = @"agent-device-hardware-keyboard-input";
     }
 
@@ -523,10 +523,11 @@ extension RunnerTests {
   /// shipped one, so only a test that is asking about time has to name it.
   ///
   /// Only an exact match settles. A value with a hole in the middle ("ada@example" -> "aexample")
-  /// is the corruption this wait exists to catch, and `.replacement` mode has no formatter or
-  /// autocomplete carve-out: `isRepairableTextEntryMismatch` (RunnerTests+TextTyping.swift) treats
-  /// every `.replacement` mismatch as repairable, because `fill` owns the whole field via
-  /// select-all. A settled non-match is therefore always the wait's failure case.
+  /// is the corruption this wait exists to catch, and the repair gate
+  /// `isRepairableTextEntryMismatch` (RunnerTests+TextTyping.swift) accepts only an empty field or
+  /// a short in-order cut of the request, so a field longer than the request — one that normalizes
+  /// what it holds (#2634) — is never retyped either. A settled non-match is therefore always the
+  /// wait's failure case.
   static func awaitSynthesizedReplacementCommitOutcome(
     expectedText: String,
     placeholder: String?,
 
@@ -52,9 +52,25 @@ extension RunnerTests {
       || isOrderedSubsequence(residualAndRequest, of: observed)
   }
 
+  /// Whether `observed` shows every character of the request, in order, at a field whose baseline
+  /// did not already show them: the requested text with app-owned insertions around it. This is the
+  /// shape a field that normalizes its content presents — a `## ### ## ##` digit grouping of the
+  /// typed digits, a phone or currency mask (#2634). The value carries nothing out of order and
+  /// drops nothing, and a retype posts the same characters through the same formatter, so no
+  /// repair can bring it closer to raw equality; the fill is unconfirmed with target-bound
+  /// evidence, not failed.
+  static func textEntryValueCarriesRequest(observed: String, expected: String, baseline: String) -> Bool {
+    let request = textEntryRequestWithoutSubmitKeys(expected)
+    guard !request.isEmpty, !isOrderedSubsequence(request, of: baseline) else {
+      return false
+    }
+    return isOrderedSubsequence(request, of: observed)
+  }
+
   /// Classifies a replacement whose read-back never matched. The entry is unconfirmed, not failed,
   /// only when the same element's value moved off its pre-entry baseline to one that does not echo
-  /// the request; every other mismatch stays a failure.
+  /// the request, or that carries the whole request in order a normalizing field can never render
+  /// raw (#2634); every other mismatch stays a failure.
   static func unconfirmedTextEntryEvidence(
     requested: String,
     baseline: TextEntryObservation?,
@@ -66,6 +82,11 @@ extension RunnerTests {
           baseline.identity.isSameElement(as: observed.identity),
           observed.value != baseline.value,
           !textEntryValueEchoes(observed: observed.value, expected: requested, baseline: baseline.value)
+            || textEntryValueCarriesRequest(
+              observed: observed.value,
+              expected: requested,
+              baseline: baseline.value
+            )
     else {
       return nil
     }
 
@@ -346,7 +346,6 @@ extension RunnerTests {
       app: app,
       target: activeTarget,
       expectedText: expectedText,
-      repairMode: repairMode,
       baseline: entryBaseline
     )
     logTextEntryPhase(
@@ -393,7 +392,6 @@ extension RunnerTests {
     app: XCUIApplication,
     target: TextEntryTarget,
     expectedText: String?,
-    repairMode: TextTypingRepairMode,
     baseline: TextEntryObservation?
   ) -> TextEntryResult {
     if target.boundIdentity != nil, resolveTextEntryElement(app: app, target: target) == nil {
@@ -436,8 +434,7 @@ extension RunnerTests {
     guard shouldRepairTextEntry(
       app: app,
       target: target,
-      expectedText: expectedText,
-      repairMode: repairMode
+      expectedText: expectedText
     ) else {
       return verifyTextEntry(
         app: app,
@@ -634,8 +631,7 @@ extension RunnerTests {
   private func shouldRepairTextEntry(
     app: XCUIApplication,
     target: TextEntryTarget,
-    expectedText: String,
-    repairMode: TextTypingRepairMode
+    expectedText: String
   ) -> Bool {
 #if os(iOS)
     var latestObservedText: String?
@@ -652,10 +648,9 @@ extension RunnerTests {
         return false
       }
       latestObservedText = observedText
-      if !isRepairableTextEntryMismatch(
+      if !Self.isRepairableTextEntryMismatch(
         observedText: observedText,
-        expectedText: expectedText,
-        repairMode: repairMode
+        expectedText: expectedText
       ) {
         return false
       }
@@ -672,34 +667,37 @@ extension RunnerTests {
     ) else {
       return false
     }
-    return isRepairableTextEntryMismatch(
+    return Self.isRepairableTextEntryMismatch(
       observedText: latestObservedText,
-      expectedText: expectedText,
-      repairMode: repairMode
+      expectedText: expectedText
     )
 #else
     return false
 #endif
   }
 
-  private func isRepairableTextEntryMismatch(
+  /// Whether clearing and retyping can still make the field answer with the request. Only two
+  /// shapes qualify: a field that reads EMPTY after entry (the text never arrived, or the app
+  /// swallowed it, and a retype is the only way to learn which), and a value that is a short,
+  /// in-order cut of the request (the dropped characters a too-fast burst produces). A field whose
+  /// value is LONGER than the request is not corrupted by entry: a field that normalizes what it
+  /// holds ("00 062 91 77" for "000629177", #2634) reaches this classifier with the complete,
+  /// formatted value, and the destructive clear-plus-retype would only mutate a correct field
+  /// before failing with the same mismatch it started on.
+  static func isRepairableTextEntryMismatch(
     observedText: String,
-    expectedText: String,
-    repairMode: TextTypingRepairMode
+    expectedText: String
   ) -> Bool {
     guard observedText != expectedText else {
       return false
     }
-    if repairMode == .replacement {
-      return true
-    }
     return observedText.isEmpty || isLikelyDroppedCharacterTextEntryMismatch(
       observedText: observedText,
       expectedText: expectedText
     )
   }
 
-  private func isLikelyDroppedCharacterTextEntryMismatch(observedText: String, expectedText: String) -> Bool {
+  static func isLikelyDroppedCharacterTextEntryMismatch(observedText: String, expectedText: String) -> Bool {
     guard observedText.count < expectedText.count else {
       return false
     }
 
@@ -62,6 +62,99 @@ extension RunnerTests {
     XCTAssertTrue(Self.textEntryValueEchoes(observed: "abc123abc12", expected: "abc123", baseline: "abc123"))
   }
 
+  // The #2634 decision, named. `textEntryValueEchoes` and its table above are UNCHANGED: a
+  // complete mask value is still an echo, because "echo" answers whether the value COULD be a
+  // degraded copy of baseline + request. What changes is what an echo withholds. Withholding
+  // evidence on echo alone rested on an equation — could-be-degraded implies cannot-be-complete —
+  // that is false: "00 062 91 77" for "000629177" is an echo AND the whole request with the
+  // formatter's separators in it, and no retype posts that value closer to raw equality. So
+  // evidence is now refused only when the value could be degraded AND cannot be complete: the
+  // request's length lower-bounds any value that carries it in order, which keeps the
+  // separator-free cut (`12456` for `123456`) refused without a separator dictionary. A cut
+  // DEEPER than the drop budget was never repairable either, and a separator-bearing mismatch
+  // already reached evidence before this change — what evidence must never do is claim the
+  // value correct; only `textEntryValueMatchesExpected` verifies, and it is untouched.
+  func testACompleteFormattedValueReachesUnconfirmedWhileAConfirmedCutStaysAFailure() {
+    let grouping = Self.unconfirmedTextEntryEvidence(
+      requested: "000629177",
+      baseline: Self.otpObservation(""),
+      observed: Self.otpObservation("00 062 91 77")
+    )
+    XCTAssertEqual(grouping?.after, "00 062 91 77")
+
+    // The mask pinned as an echo above now reaches evidence too, when the same identified field
+    // moved off its post-clear baseline: "(555) 123-4567" carries all ten requested digits.
+    let phone = Self.unconfirmedTextEntryEvidence(
+      requested: "5551234567",
+      baseline: Self.otpObservation(""),
+      observed: Self.otpObservation("(555) 123-4567")
+    )
+    XCTAssertEqual(phone?.after, "(555) 123-4567")
+
+    // A stale prefix that carries the WHOLE request is evidence too: post-clear, the prefix is
+    // the app's own text, and `before`/`after` show the caller exactly that.
+    let prefixed = Self.unconfirmedTextEntryEvidence(
+      requested: "123456",
+      baseline: Self.otpObservation(""),
+      observed: Self.otpObservation("old123456")
+    )
+    XCTAssertEqual(prefixed?.after, "old123456")
+
+    // The refusal this clause must not soften: a separator-free ordered cut is shorter than the
+    // request, so it cannot carry it, and it still echoes the residual — no evidence.
+    XCTAssertNil(
+      Self.unconfirmedTextEntryEvidence(
+        requested: "123456",
+        baseline: Self.otpObservation(""),
+        observed: Self.otpObservation("12456")
+      )
+    )
+    // A value that never moved is still no evidence, however short of the request it sits.
+    XCTAssertNil(
+      Self.unconfirmedTextEntryEvidence(
+        requested: "123456",
+        baseline: Self.otpObservation(""),
+        observed: Self.otpObservation("")
+      )
+    )
+    // The baseline already carrying the request keeps the old reading: the entry proved nothing,
+    // so there is no evidence to hand back.
+    XCTAssertNil(
+      Self.unconfirmedTextEntryEvidence(
+        requested: "123456",
+        baseline: Self.otpObservation("(555) 123-4567"),
+        observed: Self.otpObservation("5551234567")
+      )
+    )
+  }
+
+  // The completeness predicate's own table, paired positive/negative per the boundary this
+  // decision stands on. Carrying the request is ordered containment of a NON-EMPTY request the
+  // baseline did not already carry, so the separators a formatter inserts are irrelevant and the
+  // refusals are arithmetic, not a separator dictionary: a dropped character makes the value
+  // shorter than the request it claims to carry, and a reordering is a drop plus a re-insertion.
+  // The predicate never claims correctness — only `textEntryValueMatchesExpected` verifies — so
+  // its whole duty is refusing an incomplete value; that is what this table holds it to.
+  func testOnlyAValueContainingTheWholeFreshRequestCarriesIt() {
+    XCTAssertTrue(Self.textEntryValueCarriesRequest(observed: "00 062 91 77", expected: "000629177", baseline: ""))
+    XCTAssertTrue(Self.textEntryValueCarriesRequest(observed: "(555) 123-4567", expected: "5551234567", baseline: ""))
+    XCTAssertTrue(Self.textEntryValueCarriesRequest(observed: "R $12.00", expected: "R12.00", baseline: ""))
+    // One dropped digit: eight characters cannot contain a nine-character request.
+    XCTAssertFalse(Self.textEntryValueCarriesRequest(observed: "00 62 91 77", expected: "000629177", baseline: ""))
+    XCTAssertFalse(Self.textEntryValueCarriesRequest(observed: "12456", expected: "123456", baseline: ""))
+    // A reordering: the request appears in the value out of order.
+    XCTAssertFalse(Self.textEntryValueCarriesRequest(observed: "00 026 91 77", expected: "000629177", baseline: ""))
+    // An unrelated or degraded-echo value does not carry the request either way.
+    XCTAssertFalse(Self.textEntryValueCarriesRequest(observed: "6 of 6 digits", expected: "123456", baseline: ""))
+    XCTAssertFalse(Self.textEntryValueCarriesRequest(observed: "", expected: "123456", baseline: ""))
+    // The empty and already-contained requests cannot be proven by any value: the entry moved
+    // nothing new into the field.
+    XCTAssertFalse(Self.textEntryValueCarriesRequest(observed: "anything", expected: "", baseline: ""))
+    XCTAssertFalse(Self.textEntryValueCarriesRequest(observed: "5551234567", expected: "123456", baseline: "(555) 123-4567"))
+    // A submit key is pressed, not typed, so it must not sink the containment check.
+    XCTAssertTrue(Self.textEntryValueCarriesRequest(observed: "(555) 123-4567", expected: "5551234567\n", baseline: ""))
+  }
+
   func testEveryOtherReplacementMismatchStaysAFailure() {
     let baseline = Self.otpObservation("0 of 6 digits")
     let otherField = TextEntryElementIdentity(
@@ -133,6 +226,61 @@ extension RunnerTests {
     try assertDigitCountFillIsUnconfirmed(code: "6", summary: "1 of 6 digits")
   }
 
+  /// #2634: a field that reformats what it holds, the way a `## ### ## ##` digit-grouping formatter
+  /// does. Every requested digit arrives, so the fill succeeds with target-bound evidence instead of
+  /// failing on a value raw equality can never reach — and, the reported half, the runner does not
+  /// clear and retype the field it was asked to fill. The response message proves that: a repair
+  /// would report "typed after repair".
+  @MainActor
+  func testFillIntoDigitGroupingFieldReportsUnconfirmedEvidenceAndDoesNotRepair() throws {
+    app.launchArguments = [
+      "--agent-device-text-entry-regression",
+      "--agent-device-text-entry-digit-grouping-value",
+    ]
+    app.launch()
+    addTeardownBlock { [self] in
+      invalidateCachedTarget(reason: "unit_test_cleanup")
+      app.terminate()
+    }
+    let textField = app.textFields["agent-device-hardware-keyboard-input"]
+    XCTAssertTrue(textField.waitForExistence(timeout: appExistenceTimeout))
+    let frame = textField.frame
+    let command = try JSONDecoder().decode(
+      Command.self,
+      from: JSONSerialization.data(withJSONObject: [
+        "command": "type",
+        "commandId": "fill-digit-grouping",
+        "text": "000629177",
+        "textEntryMode": "replace",
+        "x": frame.midX,
+        "y": frame.midY,
+        "appBundleId": "com.callstack.agentdevice.runner",
+      ])
+    )
+
+    let failuresBeforeType = currentXCTestFailureCount()
+    let response = executeTypeCommand(activeApp: app, command: command)
+
+    XCTAssertFalse(didRecordXCTestFailure(since: failuresBeforeType))
+    XCTAssertTrue(response.ok, String(describing: response.error))
+    XCTAssertEqual(response.data?.message, "typed")
+    XCTAssertEqual(response.data?.verification, "unconfirmed")
+    XCTAssertEqual(response.data?.requested, "000629177")
+    XCTAssertEqual(response.data?.before, "")
+    XCTAssertEqual(response.data?.after, "00 062 91 77")
+    XCTAssertEqual(response.data?.target?.resourceId, "agent-device-hardware-keyboard-input")
+    // The field is left holding the digits the request carried, grouped: neither cleared out nor
+    // doubled by a retype.
+    let deadline = Date().addingTimeInterval(appExistenceTimeout)
+    var observed: String?
+    while Date() < deadline {
+      observed = textField.value as? String
+      if observed == "00 062 91 77" { break }
+      Thread.sleep(forTimeInterval: 0.25)
+    }
+    XCTAssertEqual(observed, "00 062 91 77")
+  }
+
   /// Fills the digit-count fixture field with `code` and asserts unconfirmed evidence and one entry.
   @MainActor
   private func assertDigitCountFillIsUnconfirmed(code: String, summary: String) throws {