Heat code extractor v3: capture all 6 KB419-1 codes; reject OCR-mangled English; normalize O→0

Three issues fixed from the staging test on KB419-1:

1) Missing KG416-1 and KS182-1: the OCR column heuristic was only
scanning 3 lines after a 'Heat No.' header. KB419-1's table has
6 rows, so the last 3 were dropped. Bumped both the pdfplumber
bbox-based scan (6 → 20 lines) and the OCR-text heuristic (3 → 20
non-empty lines) so multi-row tables are captured in full.

2) CON-REDUCER false positive: the previous 'isalpha()' check missed
tokens with dashes. Replaced with a 'must contain at least one digit'
rule that catches both pure-alpha (DIMENSION) and alpha+dash
(CON-REDUCER, WP304-S) tokens with no digits.

3) JNO21-1 vs JN021-1 cosmetic OCR drift: Tesseract reads the digit 0
as letter O. For OCR-sourced candidates, replace O→0 in-place.
None of our 14 confirmed real heat codes use letter O.

Side effect of (1) was that the wider lookahead also caught a wave of
OCR-mangled English words (ACC0RDING, BEL0W, FR0M, D0NE, ABO̧VE, etc.)
where Tesseract turned letter O into digit 0. Added a fourth filter:
reject candidates whose every digit is a zero. None of the real heat
codes match this pattern; all OCR-mangled English words do.

Validated locally against all 8 text-layer cases (all real codes
captured) and against KB419-1 in forced-OCR mode (all 6 codes captured,
4 extras remaining).

app/lib/utils/heat_code.py

@@ -176,6 +176,19 @@ def extract_heat_codes(file_bytes: bytes, filename: str | None = None) -> list[s
         except Exception as e:
             logger.debug("OCR fallback failed: %s", e)
 
+    # OCR commonly confuses the digit '0' with the letter 'O' (e.g. "JN021-1"
+    # becomes "JNO21-1"). None of our 14 confirmed real heat codes uses the
+    # letter O — every one has digit 0 in positions where O would appear. So
+    # for OCR-sourced candidates we replace O→0 in-place. This avoids creating
+    # duplicate folders ("JNO21-1" AND "JN021-1") and produces the canonical
+    # form. Text-layer candidates are left alone — they have the correct chars.
+    for idx in range(len(candidates)):
+        code, source = candidates[idx]
+        if source.startswith("ocr") and ("O" in code or "o" in code):
+            normalized = code.replace("O", "0").replace("o", "0")
+            if normalized != code:
+                candidates[idx] = (normalized, f"{source}_o2zero")
+
     # Build the set of tokens that appear as standards-references in the
     # document text. Combine text_layer + ocr_text if both were collected.
     combined_text = text_layer
@@ -324,9 +337,11 @@ def _from_column_position(file_bytes: bytes) -> Iterable[str]:
                     label_center = (x0 + x1) / 2
                     half_width = max((x1 - x0) / 2, 20.0)   # min 20pt to be forgiving
 
-                    # Scan up to 6 lines below for tokens whose center is within
-                    # half-width of the label.
-                    for next_key in sorted_keys[i + 1 : i + 7]:
+                    # Scan up to 20 lines below for tokens whose center is within
+                    # half-width of the label. Multi-row MTR tables (KB419-1
+                    # case has 6 rows; some have more) need a generous lookahead
+                    # or we miss data rows farther down the table.
+                    for next_key in sorted_keys[i + 1 : i + 21]:
                         for nw in lines[next_key]:
                             nw_center = (nw["x0"] + nw["x1"]) / 2
                             if abs(nw_center - label_center) <= half_width:
@@ -347,14 +362,17 @@ def _from_ocr_column_heuristic(ocr_text: str) -> Iterable[str]:
     for i, line in enumerate(lines):
         if not label_re.search(line):
             continue
-        # Look at the next 3 non-empty lines.
+        # Look at the next 20 non-empty lines. Multi-row MTR tables can have
+        # 6+ data rows (KB419-1 case); a tight lookahead drops rows past the
+        # first few. Spec-prefix and material-spec filters downstream catch
+        # the noise this wider lookahead would otherwise admit.
         looked = 0
-        for j in range(i + 1, min(i + 8, len(lines))):
+        for j in range(i + 1, min(i + 40, len(lines))):
             nxt = lines[j].strip()
             if not nxt:
                 continue
             looked += 1
-            if looked > 3:
+            if looked > 20:
                 break
             for tok in _tokenize_cell(nxt):
                 if _CODE_SHAPE_RE.match(tok):
@@ -500,9 +518,20 @@ def _is_plausible_heat_code(code: str) -> bool:
     # overlaps with real heat codes; we don't reject those on shape alone.
     if any(upper.startswith(p) for p in _SPEC_PREFIXES):
         return False
-    # Reject all-letter tokens regardless of length — real heat codes have at
-    # least one digit. (None of our 14 confirmed samples are pure-alpha.)
-    if upper.isalpha():
+    # Reject tokens with no digits at all. Real heat codes always contain at
+    # least one digit (verified across all 14 confirmed samples). This catches
+    # both pure-alpha tokens (DIMENSION) and alpha+dash tokens (CON-REDUCER,
+    # WP304-S, etc.) that the per-char isalpha() check would miss.
+    digits = [c for c in upper if c.isdigit()]
+    if not digits:
+        return False
+
+    # Reject tokens whose ONLY digit(s) are zero(s). This is the OCR-mangled-
+    # English-word signature: Tesseract reads letter O as digit 0, so words
+    # like ACCORDING, BELOW, FROM, DONE, COMPOSITION, etc. become ACC0RDING,
+    # BEL0W, FR0M, D0NE, C0MP0SITI0N. None of our 14 confirmed real heat codes
+    # have all-zero digits; they always have at least one 1–9 digit.
+    if all(d == "0" for d in digits):
         return False
 
     return True