Update app.py

app.py

@@ -14,10 +14,12 @@ Primary goals for reconcile rate:
   5) recover fused first data row generically (two-signal guard: text fusion + money fusion must both fire)
   6) promote misplaced header row: when real column headers land in a data row, restructure the grid
   7) fix fused key-value rows in summary sections (e.g. Interest Summary) appended to transaction tables
+  8) reconstruct mid-table separator rows split across columns by OCR (e.g. 'Card account # XXXX 2 | | 889')
 - footer extraction enabled on all pages with deduplication guard (no double-print if body OCR already captured it)
+- Fix 4: cross-validate OCR table row counts against PDF text layer; inject missing duplicate rows
+         (safe no-op for scanned PDFs and non-transaction pages)
 """
 
-
 # Patch asyncio first (before Gradio imports it) to suppress Python 3.13 cleanup noise
 import asyncio
 try:
@@ -71,7 +73,7 @@ ENABLE_CONTRAST = True
 DEFAULT_ZONE_FRAC = 0.12
 PDF_HEADER_BAND_FRAC = 0.10
 
-ENABLE_FOOTER_OCR = True
+ENABLE_FOOTER_OCR = True        # enabled — 3-step fallback with dedup guard
 PDF_FOOTER_BAND_FRAC = 0.88
 
 MIN_CROP_HEIGHT = 112
@@ -439,9 +441,9 @@ def _drop_truly_empty_columns(grid):
 
 def _merge_blank_header_text_columns(grid):
     """
-    If the header row has blank columns, and most body rows have non-empty *text* in that blank column,
-    merge that column into the nearest non-empty header to the left (usually DESCRIPTION),
-    then remove the blank column.
+    If the header row has blank columns, and most body rows have non-empty *text* in that
+    blank column, merge that column into the nearest non-empty header to the left (usually
+    DESCRIPTION), then remove the blank column.
     This fixes transaction tables where DESCRIPTION is split across two columns.
     """
     if not grid or len(grid) < 2:
@@ -506,9 +508,10 @@ def _merge_blank_header_text_columns(grid):
 # --------------------------
 
 # Matches a standalone money value across currencies.
-# Covers: $3,447.10  -1,234.56  £500.00  1000  etc.
+# Covers: $3,447.10  -1,234.56  £500.00  Rs1000  etc.
 _MONEY_RE = re.compile(
-    r"^[\$£€¥]?\s*-?\s?\d{1,3}(?:,\d{3})*(?:\.\d{2})?$"
+    r"^(?:[\$£€¥]|Rs\.?|INR|PKR)?\s*-?\s?\d{1,3}(?:,\d{3})*(?:\.\d{1,4})?$",
+    re.IGNORECASE,
 )
 
 # All column-header keywords recognised across any bank statement format.
@@ -521,7 +524,6 @@ _HEADER_KW_PATTERNS = [
     r"TRANSACTION\s+DATE",
     r"ENTRY\s+DATE",
     r"EFFECTIVE\s+DATE",
-
     # Transaction ID / reference
     r"TRANSACTION(?:\s+(?:ID|TYPE|NO|NUMBER))?",
     r"TXN(?:\s+(?:ID|NO|TYPE))?",
@@ -531,7 +533,6 @@ _HEADER_KW_PATTERNS = [
     r"VOUCHER(?:\s*(?:NO|NUMBER))?",
     r"SR\.?\s*NO\.?",
     r"SERIAL(?:\s*(?:NO|NUMBER))?",
-
     # Description variants
     r"DESCRIPTION",
     r"DETAILS?",
@@ -539,7 +540,6 @@ _HEADER_KW_PATTERNS = [
     r"NARRATION",
     r"REMARKS?",
     r"NOTES?",
-
     # Debit variants
     r"DEBIT",
     r"DEBITS?",
@@ -547,7 +547,6 @@ _HEADER_KW_PATTERNS = [
     r"WITHDRAWALS?",
     r"PAID\s+OUT",
     r"MONEY\s+OUT",
-
     # Credit variants
     r"CREDIT",
     r"CREDITS?",
@@ -555,10 +554,8 @@ _HEADER_KW_PATTERNS = [
     r"DEPOSITS?",
     r"PAID\s+IN",
     r"MONEY\s+IN",
-
     # Amount
     r"AMOUNT",
-
     # Balance variants
     r"BALANCE",
     r"BAL\.?",
@@ -575,7 +572,6 @@ _HEADER_KW_PATTERNS = [
     r"OPENING\s+BAL\.?",
 ]
 
-
 # Pre-compiled: each pattern anchored at start, case-insensitive
 _HEADER_KW_RES = [
     re.compile(r"^(" + p + r")(.*)", re.IGNORECASE | re.DOTALL)
@@ -687,8 +683,8 @@ def _row_keyword_score(row):
     """
     Return the fraction of non-empty cells in this row that are pure header
     keywords (e.g. DATE, DESCRIPTION, DEBIT, CREDIT, BALANCE).
-    Also handles cells like "DATE DESCRIPTION" where two keywords are space-joined
-    into one cell — these count as a keyword cell too.
+    Also handles cells like "DATE DESCRIPTION" where two keywords are
+    space-joined into one cell — these count as a keyword cell too.
     """
     non_empty = [str(c or "").strip() for c in row if str(c or "").strip()]
     if not non_empty:
@@ -696,12 +692,9 @@ def _row_keyword_score(row):
 
     keyword_hits = 0
     for cell in non_empty:
-        # Check if the whole cell is a known keyword
         if _HEADER_KW_EXACT_RE.match(cell):
             keyword_hits += 1
             continue
-        # Check if the cell is two or more space-separated keywords
-        # e.g. "DATE DESCRIPTION"
         parts = cell.split()
         if all(_HEADER_KW_EXACT_RE.match(p) for p in parts) and len(parts) > 1:
             keyword_hits += 1
@@ -710,66 +703,25 @@ def _row_keyword_score(row):
     return keyword_hits / len(non_empty)
 
 
-def _split_merged_keyword_cell(cell_text: str, target_ncols: int, col_idx: int, total_cols: int):
-    """
-    When a data cell contains multiple space-separated keywords (e.g. "DATE DESCRIPTION"),
-    split it into individual keyword tokens.  Returns a list of strings to replace
-    the single cell — padded/trimmed to fit the available column space.
-    """
-    parts = cell_text.strip().split()
-    # Only split if every part is a keyword
-    if len(parts) > 1 and all(_HEADER_KW_EXACT_RE.match(p) for p in parts):
-        return parts
-    return [cell_text]
-
-
 def _promote_misplaced_header_row(grid):
     """
-    Detects and fixes the OCR artifact where the real column headers (DATE,
-    DESCRIPTION, DEBIT, CREDIT, BALANCE …) land in a <td> data row instead
-    of the <th> header row.
-
-    This happens when a bank PDF wraps the transaction section in a larger
-    table that also contains section titles (e.g. "ACCOUNT ACTIVITY" and
-    "Transactions by Date (continued)"), so the OCR emits:
-
-        <th>ACCOUNT ACTIVITY</th>          ← wrong header (section title)
-        <td>Transactions by Date …</td>    ← subtitle row
-        <td>DATE DESCRIPTION</td> <td>DEBIT</td> <td>CREDIT</td> <td>BALANCE</td>
-        <td>01/05 …</td> …                 ← real data
-
-    The fix:
-      1. Scan every data row (rows 1+) for a row whose cells are predominantly
-         pure header keywords.
-      2. When found, promote that row to be the new header (row 0) and discard
-         all rows above it (they are section titles / subtitles).
-      3. If any cell in the promoted row contains multiple space-joined keywords
-         (e.g. "DATE DESCRIPTION"), expand it into separate columns and
-         re-align the data rows below accordingly.
+    Detects and fixes the OCR artifact where real column headers land in a
+    <td> data row instead of the <th> header row.
 
     Guard conditions (no-op if not met — safe for all other PDFs):
-      - The current header row must NOT already look like real column headers
-        (keyword score < threshold).
-      - At least one data row must have keyword score >= threshold.
-      - The candidate row must appear within the first 5 data rows (it is
-        always near the top of the table, never buried mid-table).
+      - Current header keyword score < threshold.
+      - A data row within the first 5 rows has keyword score >= threshold.
     """
     if not grid or len(grid) < 2:
         return grid
 
-    current_header = grid[0]
-    current_header_score = _row_keyword_score(current_header)
-
-    # If the current header already looks like real column headers, do nothing.
+    current_header_score = _row_keyword_score(grid[0])
     if current_header_score >= _HEADER_ROW_KEYWORD_THRESHOLD:
         return grid
 
-    # Search the first few data rows for a candidate header row.
     candidate_idx = None
     candidate_score = 0.0
-    search_limit = min(len(grid), 6)  # rows 1..5
-
-    for i in range(1, search_limit):
+    for i in range(1, min(len(grid), 6)):
         score = _row_keyword_score(grid[i])
         if score >= _HEADER_ROW_KEYWORD_THRESHOLD and score > candidate_score:
             candidate_score = score
@@ -778,7 +730,6 @@ def _promote_misplaced_header_row(grid):
     if candidate_idx is None:
         return grid
 
-    # --- Promote the candidate row ---
     candidate_row = grid[candidate_idx]
 
     # Expand any merged keyword cells (e.g. "DATE DESCRIPTION" → ["DATE", "DESCRIPTION"])
@@ -792,28 +743,21 @@ def _promote_misplaced_header_row(grid):
             expanded_header.append(cell_s)
 
     new_ncols = len(expanded_header)
-    old_ncols = len(candidate_row)
-    col_expansion = new_ncols - old_ncols  # how many extra columns were added
+    col_expansion = new_ncols - len(candidate_row)
 
-    # Re-align data rows below the candidate (expand first cell if needed)
     new_data_rows = []
     for row in grid[candidate_idx + 1:]:
         if col_expansion > 0 and row:
-            # The first cell of a data row often contains DATE + start of DESCRIPTION
-            # fused together (e.g. "01/05 TD ZELLE RECEIVED,...").
-            # Split it into [date_part, description_part] to fill the expanded columns.
             first_cell = str(row[0] or "").strip()
             date_match = re.match(r"^(\d{1,2}/\d{1,2})\s+(.*)", first_cell, re.DOTALL)
             if date_match and col_expansion == 1:
                 new_row = [date_match.group(1), date_match.group(2).strip()] + list(row[1:])
             else:
-                # Can't split cleanly — pad with empty cells to maintain column count
                 new_row = list(row) + [""] * col_expansion
             new_data_rows.append(new_row)
         else:
             new_data_rows.append(list(row))
 
-    # Normalise all rows to new_ncols width
     def pad(row, n):
         r = list(row)
         while len(r) < n:
@@ -827,17 +771,13 @@ def _promote_misplaced_header_row(grid):
     return new_grid
 
 
-
 # --------------------------
 # Fix 3: Fused key-value rows in summary sections
 # --------------------------
 
-# Matches a value suffix that looks like a number or percentage fused onto the
-# end of a label string.  Examples:
-#   "Beginning Interest Rate0.00%"   → label="Beginning Interest Rate"  value="0.00%"
-#   "Number of days in this Period31" → label="Number of days in this Period"  value="31"
-#   "Interest Earned this Period0.00" → label="Interest Earned this Period"    value="0.00"
-# Pattern: label text (non-digit) followed by a numeric/percentage token at the end.
+# Matches a value suffix fused onto a label with no space.
+# e.g. "Beginning Interest Rate0.00%" → label + "0.00%"
+#      "Number of days in this Period31" → label + "31"
 _FUSED_KV_RE = re.compile(
     r"^(.+?)\s*(-?\d{1,3}(?:,\d{3})*(?:\.\d+)?%?)$",
     re.DOTALL,
@@ -846,39 +786,22 @@ _FUSED_KV_RE = re.compile(
 
 def _fix_fused_keyvalue_rows(grid):
     """
-    Generic fix for rows where a label and its value are fused into the first
-    cell while all other cells in that row are empty.
-
-    This happens when a bank statement appends a summary section (e.g. Interest
-    Summary, Fee Summary) after the main transaction table without a clear
-    column separator.  The OCR wraps it inside the same table and each line
-    becomes a single-cell row like:
-
-        <td>Beginning Interest Rate0.00%</td> <td></td> <td></td> ...
-
-    The fix:
-      - For every data row where exactly the first cell is non-empty and all
-        other cells are empty, AND the first cell ends with a numeric/percentage
-        token fused directly onto text (no space separator), split it into
-        label (col 0) and value (last column of the table).
-      - If the cell already has a natural space before the value it is NOT
-        fused — leave it alone.  This prevents touching normal description rows
-        that happen to end with a number.
+    Fix rows where label+value are fused into the first cell with all other
+    cells empty — common in Interest Summary / Fee Summary sections appended
+    to a transaction table by OCR.
 
     Guard conditions (no-op if not met — safe for all other tables):
-      - The row must have ALL cells empty except the first.
-      - The first cell must match the fused pattern (text immediately followed
-        by a digit with no whitespace gap before the digit run).
-      - The match must produce a non-empty label AND a non-empty value.
+      - All cells except first must be empty.
+      - A non-space character must immediately precede the digit run (fused).
+      - Both label and value parts must be non-empty after splitting.
     """
     if not grid or len(grid) < 2:
         return grid
 
     ncols = len(grid[0])
-    new_grid = [grid[0]]  # keep header unchanged
+    new_grid = [grid[0]]
 
     for row in grid[1:]:
-        # Guard: only process rows where first cell is non-empty and rest are empty
         cells = [str(c or "").strip() for c in row]
         if not cells:
             new_grid.append(row)
@@ -891,12 +814,8 @@ def _fix_fused_keyvalue_rows(grid):
             new_grid.append(row)
             continue
 
-        # Guard: fused pattern requires NO whitespace immediately before the
-        # numeric suffix — "Rate0.00%" is fused, "Rate 0.00%" is not.
-        # We check by requiring the character just before the digit run is NOT
-        # a space.
-        fused_match = re.search(r"\S\d", first)
-        if not fused_match:
+        # Require no-space immediately before the digit run
+        if not re.search(r"\S\d", first):
             new_grid.append(row)
             continue
 
@@ -912,7 +831,6 @@ def _fix_fused_keyvalue_rows(grid):
             new_grid.append(row)
             continue
 
-        # Build the fixed row: label in col 0, value in last col, rest empty
         new_row = [""] * ncols
         new_row[0] = label
         new_row[ncols - 1] = value
@@ -921,6 +839,316 @@ def _fix_fused_keyvalue_rows(grid):
     return new_grid
 
 
+# --------------------------
+# Fix 4: PDF text-layer row-count patch
+# --------------------------
+
+def _extract_textlayer_rows(pdf_path: str, page_num: int):
+    """
+    Extract structured transaction rows from the PDF text layer using pymupdf.
+
+    Returns list of {"date": str, "desc": str, "amount": str} dicts, or []
+    if the PDF has no text layer, pymupdf is unavailable, or fewer than 2
+    transaction rows are found (guards against non-transaction pages).
+
+    How it works:
+      - Read all words with bounding boxes from the text layer.
+      - Group words into logical lines by clustering on y-coordinate
+        (words within 5pt of each other vertically share a line).
+      - Parse each line as a transaction row: first token = date pattern,
+        last token = amount pattern, middle tokens = description.
+    """
+    try:
+        import pymupdf as fitz
+
+        doc = fitz.open(pdf_path)
+        page = doc[page_num]
+        words = page.get_text("words")
+        doc.close()
+
+        if not words:
+            return []
+
+        # Group words by y-bucket (5pt tolerance)
+        lines_by_y = {}
+        for w in words:
+            x0, y0, word = float(w[0]), float(w[1]), w[4]
+            bucket = None
+            for existing_y in lines_by_y:
+                if abs(existing_y - y0) <= 5:
+                    bucket = existing_y
+                    break
+            if bucket is None:
+                bucket = y0
+            lines_by_y.setdefault(bucket, []).append((x0, word))
+
+        sorted_lines = []
+        for y in sorted(lines_by_y):
+            line_words = sorted(lines_by_y[y], key=lambda t: t[0])
+            sorted_lines.append([w for _, w in line_words])
+
+        # Date: MM/DD/YY, MM/DD/YYYY, MM/DD
+        date_re = re.compile(r"^\d{1,2}/\d{2}(?:/\d{2,4})?$")
+        # Amount: -1,234.56  $193.63  -$240.46
+        amount_re = re.compile(
+            r"^-?\$?\d{1,3}(?:,\d{3})*(?:\.\d{1,4})?$|^\$-?\d{1,3}(?:,\d{3})*(?:\.\d{1,4})?$"
+        )
+
+        rows = []
+        for line in sorted_lines:
+            if len(line) < 2:
+                continue
+            if not date_re.match(line[0]):
+                continue
+            if not amount_re.match(line[-1]):
+                continue
+            desc = " ".join(line[1:-1]).strip()
+            if not desc:
+                continue
+            rows.append({"date": line[0], "desc": desc, "amount": line[-1]})
+
+        # Guard: require at least 2 rows to avoid false positives on non-transaction pages
+        return rows if len(rows) >= 2 else []
+
+    except Exception as e:
+        log.debug("_extract_textlayer_rows failed (page %d): %s", page_num, e)
+        return []
+
+
+def _patch_ocr_with_textlayer(page_md: str, pdf_path: str, page_num: int) -> str:
+    """
+    Compare OCR table rows against PDF text-layer rows and inject any rows
+    the OCR model silently dropped (typically identical consecutive rows).
+
+    Guard conditions (all must pass for any injection):
+      1. PDF text layer must exist and yield >= 2 transaction rows.
+      2. The OCR table must have DATE + DESCRIPTION + AMOUNT columns.
+      3. At least one (date, desc, amount) key must appear in both OCR and
+         text layer — ensures we are patching the right table.
+      4. Only injects copies of rows ALREADY present in OCR (ocr_count > 0)
+         — never invents new row content.
+      5. Entire function wrapped in try/except — any error returns page_md unchanged.
+    """
+    if not page_md or "<table" not in page_md.lower():
+        return page_md
+
+    try:
+        tl_rows = _extract_textlayer_rows(pdf_path, page_num)
+        if not tl_rows:
+            return page_md  # scanned PDF or non-transaction page — safe no-op
+
+        def _norm(s):
+            return re.sub(r"\s+", " ", str(s or "").strip().lower())
+
+        # Build text-layer frequency map
+        tl_freq = {}
+        for r in tl_rows:
+            key = (_norm(r["date"]), _norm(r["desc"]), _norm(r["amount"]))
+            tl_freq[key] = tl_freq.get(key, 0) + 1
+
+        table_pattern = re.compile(r"<table[^>]*>.*?</table>", re.DOTALL | re.IGNORECASE)
+        result = page_md
+
+        for tbl_match in table_pattern.finditer(page_md):
+            table_html = tbl_match.group(0)
+
+            p = TableGridParser()
+            p.feed(table_html)
+            grid = _build_grid(p.rows)
+            if len(grid) < 2:
+                continue
+
+            # Identify DATE, DESCRIPTION, AMOUNT column indices
+            header = [str(c or "").strip().upper() for c in grid[0]]
+            date_col = desc_col = amt_col = None
+            for ci, h in enumerate(header):
+                if re.search(r"\bDATE\b", h) and date_col is None:
+                    date_col = ci
+                elif re.search(r"\b(DESCRIPTION|DETAILS?|NARRATION|PARTICULARS?)\b", h) and desc_col is None:
+                    desc_col = ci
+                elif re.search(r"\b(AMOUNT|DEBIT|CREDIT|DR|CR)\b", h) and amt_col is None:
+                    amt_col = ci
+
+            if date_col is None or desc_col is None or amt_col is None:
+                continue  # not a transaction table
+
+            # Build OCR frequency map
+            ocr_freq = {}
+            ocr_rows_indexed = []
+            for ri, row in enumerate(grid[1:], start=1):
+                cells = [str(c or "").strip() for c in row]
+                if len(cells) <= max(date_col, desc_col, amt_col):
+                    continue
+                d = _norm(cells[date_col])
+                desc = _norm(cells[desc_col])
+                amt = _norm(cells[amt_col])
+                if not d or not desc:
+                    continue
+                key = (d, desc, amt)
+                ocr_freq[key] = ocr_freq.get(key, 0) + 1
+                ocr_rows_indexed.append((ri, key))
+
+            # Guard: overlap required
+            overlap = set(ocr_freq.keys()) & set(tl_freq.keys())
+            if not overlap:
+                continue
+
+            # Determine missing rows
+            to_inject = {}
+            for key in tl_freq:
+                ocr_count = ocr_freq.get(key, 0)
+                tl_count = tl_freq[key]
+                if tl_count > ocr_count and ocr_count > 0:
+                    # Guard: only restore rows already present in OCR
+                    to_inject[key] = tl_count - ocr_count
+
+            if not to_inject:
+                continue
+
+            # Build patched grid — inject missing rows after last occurrence
+            new_grid = [grid[0]]
+            for ri, row in enumerate(grid[1:], start=1):
+                new_grid.append(row)
+                cells = [str(c or "").strip() for c in row]
+                if len(cells) <= max(date_col, desc_col, amt_col):
+                    continue
+                d = _norm(cells[date_col])
+                desc = _norm(cells[desc_col])
+                amt = _norm(cells[amt_col])
+                key = (d, desc, amt)
+                if key in to_inject and to_inject[key] > 0:
+                    last_occ = max(idx for idx, k in ocr_rows_indexed if k == key)
+                    if ri == last_occ:
+                        for _ in range(to_inject[key]):
+                            new_grid.append(list(row))
+                        to_inject[key] = 0
+
+            new_table_html = _grid_to_html(new_grid)
+            result = result.replace(table_html, new_table_html, 1)
+            log.info("page %d: injected missing duplicate row(s) from text layer", page_num)
+
+        return result
+
+    except Exception as e:
+        log.warning("_patch_ocr_with_textlayer failed (page %d): %s", page_num, e)
+        return page_md  # always safe — return original on any error
+
+
+
+# --------------------------
+# Fix 5: Mid-table separator row reconstruction
+# --------------------------
+
+# Date pattern for transaction rows: MM/DD, MM/DD/YY, MM/DD/YYYY
+_DATE_RE = re.compile(r"^\d{1,2}/\d{2}(?:/\d{2,4})?$")
+
+# Standalone money amount (may be split off a separator label by OCR)
+_SPLIT_AMOUNT_RE = re.compile(
+    r"^-?\$?\d{1,3}(?:,\d{3})*(?:\.\d{1,4})?$|^\$-?\d{1,3}(?:,\d{3})*(?:\.\d{1,4})?$"
+)
+
+
+def _reconstruct_separator_rows(grid):
+    """
+    Detect and reconstruct mid-table separator / label rows that OCR has
+    incorrectly split across columns.
+
+    The artifact (Bank of America and similar):
+      A section label like "Card account # XXXX XXXX XXXX 2889" sits between
+      transaction rows as a full-width label.  Because the table has columns
+      (Date, Description, Amount) and "2889" is right-aligned, OCR splits it:
+          col 0: "Card account # XXXX XXXX XXXX 2"
+          col 1: ""                                  ← description empty
+          col 2: "889"                               ← trailing digits treated as amount
+
+    How to detect a split separator row (ALL conditions must hold):
+      - The row has exactly 1 non-empty cell OR the last non-empty cell is a
+        short numeric fragment (1-4 digits, no decimal, no sign) that is NOT
+        a plausible standalone amount.
+      - The first cell does NOT match a date pattern (separators are never dates).
+      - The first cell is non-empty and looks like a label (has letters).
+      - The last cell (if non-empty and different from first) is a short digit
+        fragment that makes sense as the tail of the label in col 0.
+
+    The fix:
+      - Concatenate all non-empty cells (trimming the spurious digit fragment
+        back onto the label), place the result in col 0, and blank all other cells.
+
+    Guard conditions (no-op if not met — safe for all other tables):
+      - Grid must have at least 2 columns and 2 rows.
+      - First cell must not be a date (transaction rows are left alone).
+      - Last cell, if different from first, must be a short pure-digit fragment
+        (1-4 digits, no decimal point) — this is very specific and avoids
+        touching legitimate amount cells like "-14.19".
+      - Entire row must have at most 2 non-empty cells total.
+    """
+    if not grid or len(grid) < 2:
+        return grid
+
+    ncols = len(grid[0])
+    if ncols < 2:
+        return grid
+
+    new_grid = [grid[0]]  # keep header unchanged
+
+    for row in grid[1:]:
+        cells = [str(c or "").strip() for c in row]
+
+        # Pad to ncols if needed
+        while len(cells) < ncols:
+            cells.append("")
+
+        non_empty = [(i, c) for i, c in enumerate(cells) if c]
+
+        # Guard 1: must have 1 or 2 non-empty cells total
+        if len(non_empty) == 0 or len(non_empty) > 2:
+            new_grid.append(row)
+            continue
+
+        first_idx, first_val = non_empty[0]
+
+        # Guard 2: first cell must not be a date token
+        if _DATE_RE.match(first_val):
+            new_grid.append(row)
+            continue
+
+        # Guard 3: first cell must contain letters (it's a label, not a number)
+        if not re.search(r"[A-Za-z]", first_val):
+            new_grid.append(row)
+            continue
+
+        if len(non_empty) == 1:
+            # Only one cell has content — already a clean label row, ensure
+            # it is in col 0 and all other cells are blank.
+            new_row = [""] * ncols
+            new_row[0] = first_val
+            new_grid.append(new_row)
+            continue
+
+        # Exactly 2 non-empty cells
+        last_idx, last_val = non_empty[1]
+
+        # Guard 4: last cell must be a short pure-digit fragment (1-4 digits,
+        # no decimal, no sign, no $) — the hallmark of a split card/account number.
+        if not re.fullmatch(r"\d{1,4}", last_val):
+            new_grid.append(row)
+            continue
+
+        # Guard 5: the standalone fragment must NOT be a plausible amount on its own
+        # (amounts have decimals; a bare 2-4 digit integer alone could be a year or
+        # ref number but not a transaction amount in a USD statement)
+        if _SPLIT_AMOUNT_RE.match(last_val) and "." in last_val:
+            new_grid.append(row)
+            continue
+
+        # Reconstruct: join first_val + last_val (they are adjacent parts of the label)
+        reconstructed = (first_val + last_val).strip()
+        new_row = [""] * ncols
+        new_row[0] = reconstructed
+        new_grid.append(new_row)
+
+    return new_grid
+
 # --------------------------
 # Normalizer entry point
 # --------------------------
@@ -934,7 +1162,8 @@ def normalize_html_tables(text: str) -> str:
       4. Fix 1 — clean fused header artifacts and recover the lost first data row.
       5. Fix 2 — promote a misplaced header row when real column headers landed
                   in a <td> data row instead of the <th> header row.
-      6. Emit normalised <table> HTML.
+      6. Fix 3 — split fused key-value rows in summary sections.
+      7. Emit normalised <table> HTML.
     """
     if not text or "<table" not in text.lower():
         return text
@@ -953,6 +1182,9 @@ def normalize_html_tables(text: str) -> str:
             grid = _drop_truly_empty_columns(grid)
             grid = _merge_blank_header_text_columns(grid)
 
+            # Fix 5: reconstruct mid-table separator rows split across columns by OCR
+            grid = _reconstruct_separator_rows(grid)
+
             # Fix 1: fused-header artifact (two-signal guard — safe on clean PDFs)
             grid, recovered_row = _clean_header_artifacts(grid)
             if recovered_row is not None:
@@ -961,7 +1193,7 @@ def normalize_html_tables(text: str) -> str:
             # Fix 2: misplaced header row promotion (keyword-score guard — safe on clean PDFs)
             grid = _promote_misplaced_header_row(grid)
 
-                # Fix 3: fused key-value rows in summary sections (no-space guard — safe on all PDFs)
+            # Fix 3: fused key-value rows in summary sections (no-space guard — safe on all PDFs)
             grid = _fix_fused_keyvalue_rows(grid)
 
             out.append(_grid_to_html(grid) if grid else table_html)
@@ -1104,16 +1336,17 @@ def run_ocr(uploaded_file):
             if hdr and hdr.strip():
                 parts.append(fix_account_number(normalize_money_glyphs(hdr.strip())))
 
-            # Main OCR markdown, stabilized
+            # Main OCR body: stabilize then patch missing duplicate rows from text layer
             if page_md and page_md.strip():
-                parts.append(stabilize_tables_and_text(page_md.strip()))
-
-            # Footer extraction.
-            # Uses the same 3-step fallback as header: PDF text layer -> band words -> OCR crop.
-            # Deduplication guard: if the footer text is already present in the main body OCR
-            # output (accidental capture on some pages), we skip appending it to avoid
-            # printing it twice. Comparison is done on a normalised lowercase snippet of the
-            # first non-empty footer line so minor whitespace differences don't matter.
+                stabilized = stabilize_tables_and_text(page_md.strip())
+                # Fix 4: restore any rows OCR dropped by cross-checking the PDF text layer.
+                # Safe no-op for scanned PDFs (no text layer) and non-transaction pages.
+                if is_pdf:
+                    stabilized = _patch_ocr_with_textlayer(stabilized, path, page_num)
+                parts.append(stabilized)
+
+            # Footer extraction: PDF text layer -> band words -> OCR crop
+            # Deduplication guard prevents double-printing when body OCR already captured it.
             if ENABLE_FOOTER_OCR and page_num < len(page_images):
                 ftr = ""
                 if is_pdf:
@@ -1124,8 +1357,6 @@ def run_ocr(uploaded_file):
                     ftr = ocr_zone(page_images[page_num], fs, 1.0)
                 if ftr and ftr.strip():
                     ftr_clean = normalize_money_glyphs(ftr.strip())
-                    # Deduplication: check if the first meaningful line of the footer
-                    # already appears anywhere in the assembled page content so far.
                     ftr_first_line = next(
                         (ln.strip().lower() for ln in ftr_clean.splitlines() if ln.strip()),
                         ""