diff --git a/api/src/normalizer/ocr/amounts.py b/api/src/normalizer/ocr/amounts.py
index 2158a96..ae36cab 100644
--- a/api/src/normalizer/ocr/amounts.py
+++ b/api/src/normalizer/ocr/amounts.py
@@ -1,14 +1,18 @@
 """Суммы из OCR-ячеек (§11.1 п. 7). Перенос `_parse_amount`, `_is_blank` и регулярок старого ядра с одним отличием —
 порядком вычисления `verified` (решение №13 design.md, см. комментарий в `parse_amount`).
 
-Что делает разбор: запятая → точка, пробелы долой; если есть круглые скобки — берётся содержимое первой пары, и сумма
+Что делает разбор: если текст целиком (после strip, без пробелов, с учётом скобок — берётся содержимое первой пары — и
+знака) имеет вид `[+-]?[1-9]\\d{0,2}(,\\d{3})+`, запятые — разделители тысяч и удаляются (`4,200` → `4200`,
+`(4,200)` → `-4200`, `1,234,567` → `1234567`); это не отбрасывание символов, `verified` не страдает. Правило тысяч —
+решение владельца 15.10.2026 (AURORA-1405, scan-gateway#35), см. docs/context/05-domain-rules.md §11.1 п. 7.
+Затем запятая → точка, пробелы долой; если есть круглые скобки — берётся содержимое первой пары, и сумма
 отрицательная; всё, кроме цифр, `+`, `-` и `.`, отбрасывается; если точек больше одной, удаляются ВСЕ точки
 (`1.234,56` → `123456`, а не `1234.56`: последняя точка тоже теряется, такая сумма всегда `verified = False`).
 `verified` — разбор не отбрасывал символов (скобки в счёт не идут). Побочный эффект №13: скобки без содержимого
 (`()`, `( )`, `(.)`) дают `(None, verified = True)`, в источнике — `False`.
 
-Количество знаков после запятой здесь не проверяется: `1,234` → `1.234`; ограничение `Money` (не больше двух знаков) —
-в `document._value` (решение №30)."""
+Количество знаков после запятой здесь не проверяется: `0,125` → `0.125`, `12,3456` → `12.3456`;
+ограничение `Money` (не больше двух знаков) — в `document._value` (решение №30)."""
 
 import re
 from dataclasses import dataclass
@@ -19,6 +23,8 @@ __all__ = ["ParsedAmount", "is_blank", "parse_amount"]
 _BLANK_CHARS_RE = re.compile(r"[\s\-–—]")
 _ALLOWED_RE = re.compile(r"[^\d+\-.]")
 _BRACKET_RE = re.compile(r"\(([^()]*)\)")
+# запятая-разделитель тысяч (AURORA-1405, scan-gateway#35): «4,200», «-1,234,567»; проверяется на всей строке
+_THOUSANDS_RE = re.compile(r"[+-]?[1-9]\d{0,2}(?:,\d{3})+")
 
 
 @dataclass(frozen=True)
@@ -30,14 +36,20 @@ class ParsedAmount:
 def parse_amount(raw: str) -> ParsedAmount:
     """Парсит сумму из распознанного текста OCR-ячейки.
 
-    Заменяет запятую на точку, удаляет пробелы, извлекает содержимое круглых скобок
+    Если содержимое (без пробелов, с учётом скобок) целиком вида `[+-]?[1-9]\\d{0,2}(,\\d{3})+` — удаляет запятые
+    (разделители тысяч: `4,200` → 4200) без потери verified. Затем заменяет запятую на точку, удаляет пробелы,
+    извлекает содержимое круглых скобок
     (означает отрицательное число), удаляет непотребные символы; если точек больше одной — считает их разделителями
     тысяч и удаляет все (десятичная часть при этом не сохраняется: `1.234,56` → 123456).
 
     verified=True только если в исходной строке не пришлось отбрасывать символы
     (после удаления скобок).
     """
-    s = raw.strip().replace(",", ".").replace(" ", "")
+    s = raw.strip().replace(" ", "")
+    inner = _BRACKET_RE.search(s)
+    if _THOUSANDS_RE.fullmatch(inner.group(1) if inner else s):
+        s = s.replace(",", "")
+    s = s.replace(",", ".")
     stripped_raw = s
     if not stripped_raw:
         return ParsedAmount(None, stripped_raw == raw)
diff --git a/api/src/normalizer/ocr/document.py b/api/src/normalizer/ocr/document.py
index 45fa8a8..1cc9cc1 100644
--- a/api/src/normalizer/ocr/document.py
+++ b/api/src/normalizer/ocr/document.py
@@ -142,8 +142,9 @@ def _value(cell: Cell | None, column_index: int, build: _Build) -> StatementValu
     amount = parsed.amount
     verified = parsed.verified
     if amount is not None and _decimal_places(amount) > MONEY_DECIMAL_PLACES:
-        # решение №30: `Money` контракта — не больше двух знаков; «1,234» (пробел тысяч как запятая) — артефакт OCR,
-        # сумма не принимается, текст остаётся в string_value, иначе ValidationError ронял бы всю таблицу
+        # решение №30: `Money` контракта — не больше двух знаков; «1,234» теперь = 1234 (правило тысяч в parse_amount,
+        # AURORA-1405), а «0,125», «12.3456» и т. п. — артефакт OCR: сумма не принимается, текст остаётся в
+        # string_value, иначе ValidationError ронял бы всю таблицу
         amount, verified = None, False
     # DBML: string_value — «как распознано, если не число» (решение №16): только когда сумма не разобрана
     string_value = text if amount is None and text and not is_blank(text) else None
diff --git a/api/tests/unit/normalizer/test_amounts.py b/api/tests/unit/normalizer/test_amounts.py
index 5c6474c..e277fbc 100644
--- a/api/tests/unit/normalizer/test_amounts.py
+++ b/api/tests/unit/normalizer/test_amounts.py
@@ -24,11 +24,22 @@ from src.normalizer.ocr.amounts import ParsedAmount, is_blank, parse_amount
         # несколько точек: удаляются ВСЕ точки, десятичная часть теряется (`1.234,56` — не 1234.56), всегда не verified
         ("1.234,56", Decimal("123456"), False),
         ("1,234.56", Decimal("123456"), False),
-        (
-            "1,234",
-            Decimal("1.234"),
-            True,
-        ),  # знаков после запятой больше двух — `Money` отсекает `document._value` (№30)
+        # запятая-разделитель тысяч (AURORA-1405, scan-gateway#35): удаляется до замены запятой на точку, verified=True
+        ("1,234", Decimal("1234"), True),
+        ("4,200", Decimal("4200"), True),
+        ("(4,200)", Decimal("-4200"), True),
+        ("1,234,567", Decimal("1234567"), True),
+        ("-4,200", Decimal("-4200"), True),
+        ("+4,200", Decimal("4200"), True),
+        ("(-4,200)", Decimal("-4200"), True),
+        ("4,2", Decimal("4.2"), True),
+        ("12,34", Decimal("12.34"), True),
+        ("1,23", Decimal("1.23"), True),
+        # не тысячи: больше двух знаков после запятой остаётся десятичным — `Money` отсекает `document._value` (№30)
+        ("0,125", Decimal("0.125"), True),
+        ("12,3456", Decimal("12.3456"), True),
+        ("4,200,", Decimal("4200"), False),  # хвостовая запятая: правило не применяется (две точки удалены, как раньше)
+        ("(4,200}", Decimal("4.200"), False),  # нет пары скобок: правило не применяется, минус не ставится
         # №13: скобки без содержимого — не сумма, но и не «неразобранный текст»
         ("()", None, True),
         ("( )", None, True),
diff --git a/api/tests/unit/normalizer/test_document.py b/api/tests/unit/normalizer/test_document.py
index b6df5ed..d334701 100644
--- a/api/tests/unit/normalizer/test_document.py
+++ b/api/tests/unit/normalizer/test_document.py
@@ -450,7 +450,7 @@ class TestKnownCodeConfidence:
 class TestMoneyPrecision:
     """Решение №30: `Money` контракта — не больше двух знаков; ячейка с большим числом знаков не валит таблицу."""
 
-    @pytest.mark.parametrize("text", ["1,234", "0,125", "12.3456", "(1,234)"])
+    @pytest.mark.parametrize("text", ["12,3456", "0,125", "12.3456", "(0,125)"])
     def test_more_than_two_decimals_is_not_an_amount(self, text: str) -> None:
         table = _table(
             "Бухгалтерский баланс",
@@ -467,17 +467,31 @@ class TestMoneyPrecision:
         table = _table(
             "Бухгалтерский баланс",
             CLEAN_BALANCE["rows"][0],
-            _row(1, (0, "ОС", 100), (1, "1150", 100), (2, "1,234", 100), (3, "56,78", 100)),
+            _row(1, (0, "ОС", 100), (1, "1150", 100), (2, "0,125", 100), (3, "56,78", 100)),
             _row(2, (0, "НМА", 100), (1, "1110", 100), (2, "7", 100), (3, "8,5", 100)),
         )
         built = _build(table)
         first, second = built.document.lines
-        assert (first.values[0].amount, first.values[0].string_value) == (None, "1,234")
+        assert (first.values[0].amount, first.values[0].string_value) == (None, "0,125")
         assert (first.values[1].amount, first.values[1].is_recognized) == (Decimal("56.78"), True)
         assert (second.values[0].amount, second.values[0].is_recognized) == (Decimal("7"), True)
         assert (second.values[1].amount, second.values[1].is_recognized) == (Decimal("8.5"), True)
         built.document.to_wire()  # контрактная модель сериализуется без ValidationError
 
+    @pytest.mark.parametrize(
+        ("text", "amount"),
+        [("4,200", Decimal("4200")), ("(4,200)", Decimal("-4200")), ("1,234,567", Decimal("1234567"))],
+    )
+    def test_thousands_comma_gives_amount(self, text: str, amount: Decimal) -> None:
+        """AURORA-1405, scan-gateway#35: «4,200» в PDF — это 4200, а не 4.200 (отсекаемое №30)."""
+        table = _table(
+            "Бухгалтерский баланс",
+            CLEAN_BALANCE["rows"][0],
+            _row(1, (0, "ОС", 100), (1, "1150", 100), (2, text, 100), (3, "2", 100)),
+        )
+        value = _build(table).document.lines[0].values[0]
+        assert value.amount == amount and value.is_recognized is True and value.string_value is None
+
     @pytest.mark.parametrize("text", ["1,23", "1,2", "0", "-5", "1 234,50"])
     def test_up_to_two_decimals_is_kept(self, text: str) -> None:
         table = _table(