ocr.recoverNumericZerosFromCheckboxes: accept cells whose stripped

content parses to the recovery value

Self-fix for cells like '$ 0\n:selected:' — Azure DI's layout step
recognized the digit AND a stray selection mark in the same cell. The
original eligibility rule rejected the cell because the digit broke the
"no digits or letters after stripping" check, even though the digit IS
the recovery value and the cell still has an overlapping selection
mark (the checkbox-as-zero signal we're targeting).

cellIsEligibleByContent() now additionally accepts when the stripped
content parses to the configured recoveryValue. The mark-overlap gate
is unchanged — we still require a real selection-mark polygon inside
the cell, so this only widens the content rule, not the trust model.

Cells with a 0 in content but no overlapping mark stay rejected
(different pattern, out of strict "checkbox-as-zero" scope), and
non-zero digit cells (e.g. '$ 5') still fail even with an overlapping
mark since the stripped content doesn't equal the recoveryValue. The
three new tests cover all three cases.

Validated on prod benchmark dfaddb26-… (standalone Python script on
the experiment branch): +11 recoveries on top of the 111 from title +
A + B = 122 total. The 11 are exactly the cells the diagnostic
flagged as having both a digit AND an overlapping selection mark
(10 in one sample with '$ 0\n:selected:' on every income row, 1 in
another with '$ 0\n:unselected:').

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: strukalex

apps/temporal/src/activities/ocr-recover-numeric-zeros.test.ts

@@ -967,4 +967,137 @@ describe("recoverNumericZerosFromCheckboxes", () => {
     ).toBe("positional-anchor");
     expect(out.metadata?.applied).toBe(36);
   });
+
+  // -------------------------------------------------------------------------
+  // Self-fix #1 — accept cells where stripped content parses to recoveryValue
+  // -------------------------------------------------------------------------
+
+  it("Self-fix #1: recovers '$ 0' cells where Azure saw both the digit AND a selection mark", async () => {
+    // Cell content looks like '$ 0\n:selected:' — Azure DI's layout step
+    // recognized both the 0 digit AND a stray selection mark in the same
+    // cell. Original rule rejected because of the digit; new rule accepts
+    // since the digit IS the recovery value AND a mark overlaps the cell.
+    const cells: TableCell[] = [
+      makeCell(0, 0, "Declare all income", [0, 0, 100, 10], "columnHeader"),
+      makeCell(1, 1, "Applicant", [50, 10, 70, 20], "columnHeader"),
+      makeCell(2, 0, "Net Employment Income", [0, 20, 50, 30]),
+      makeCell(2, 1, "$ 0\n:selected:", [50, 20, 70, 30]),
+      makeCell(3, 0, "Rental Income", [0, 30, 50, 40]),
+      makeCell(3, 1, "$ 0.00", [50, 30, 70, 40]),
+    ];
+    // Both cells have an overlapping selection mark (required by the
+    // existing eligibility gate, which Self-fix #1 does not relax).
+    const marks: SelectionMark[] = [
+      makeMark("selected", [55, 22, 60, 27]),
+      makeMark("unselected", [55, 32, 60, 37]),
+    ];
+    const fields: Record<string, Record<string, unknown>> = {
+      applicant_net_employment_income: { type: "number", confidence: 0.3 },
+      applicant_rental_income: { type: "number", confidence: 0.5 },
+    };
+    const ocrResult = makeOcrResult({ cells, fields, marks });
+
+    const out = await recoverNumericZerosFromCheckboxes({
+      ocrResult,
+      tables: [
+        {
+          find: { firstCellTextContains: "Declare all income" },
+          columns: [{ prefix: "applicant_", headerEquals: "Applicant" }],
+          rows: [
+            {
+              suffix: "net_employment_income",
+              labelEquals: "Net Employment Income",
+            },
+            { suffix: "rental_income", labelEquals: "Rental Income" },
+          ],
+        },
+      ],
+    });
+
+    const recovered = out.ocrResult.documents?.[0]?.fields;
+    if (!recovered) throw new Error("missing");
+    expect(recovered.applicant_net_employment_income.valueNumber).toBe(0);
+    expect(recovered.applicant_rental_income.valueNumber).toBe(0);
+    expect(out.metadata?.applied).toBe(2);
+  });
+
+  it("Self-fix #1: a '$ 0' cell with NO overlapping mark is still rejected", async () => {
+    // The new rule widens content eligibility but does NOT relax the
+    // selection-mark requirement. A '$ 0' cell with zero overlapping marks
+    // must remain rejected — that's a "model missed a recognized 0" pattern,
+    // not a "checkbox-as-zero" pattern.
+    const cells: TableCell[] = [
+      makeCell(0, 0, "Declare all income", [0, 0, 100, 10], "columnHeader"),
+      makeCell(1, 1, "Applicant", [50, 10, 70, 20], "columnHeader"),
+      makeCell(2, 0, "Net Employment Income", [0, 20, 50, 30]),
+      makeCell(2, 1, "$ 0", [50, 20, 70, 30]),
+    ];
+    const fields: Record<string, Record<string, unknown>> = {
+      applicant_net_employment_income: { type: "number", confidence: 0.5 },
+    };
+    const ocrResult = makeOcrResult({ cells, fields, marks: [] });
+
+    const out = await recoverNumericZerosFromCheckboxes({
+      ocrResult,
+      tables: [
+        {
+          find: { firstCellTextContains: "Declare all income" },
+          columns: [{ prefix: "applicant_", headerEquals: "Applicant" }],
+          rows: [
+            {
+              suffix: "net_employment_income",
+              labelEquals: "Net Employment Income",
+            },
+          ],
+        },
+      ],
+    });
+
+    expect(out.metadata?.applied).toBe(0);
+    expect(
+      (out.metadata?.skippedByReason as Record<string, number>)[
+        "no_selection_mark_in_cell"
+      ],
+    ).toBe(1);
+  });
+
+  it("Self-fix #1: non-zero digit cells are still rejected even with overlapping mark", async () => {
+    // Cell content '$ 5' with a mark overlap: stripped='5' parses to 5, not
+    // 0 (the recoveryValue), so eligibility still fails. Critical: this
+    // protects against turning real-value cells into 0.
+    const cells: TableCell[] = [
+      makeCell(0, 0, "Declare all income", [0, 0, 100, 10], "columnHeader"),
+      makeCell(1, 1, "Applicant", [50, 10, 70, 20], "columnHeader"),
+      makeCell(2, 0, "Net Employment Income", [0, 20, 50, 30]),
+      makeCell(2, 1, "$ 5", [50, 20, 70, 30]),
+    ];
+    const marks = [makeMark("unselected", [55, 22, 60, 27])];
+    const fields: Record<string, Record<string, unknown>> = {
+      applicant_net_employment_income: { type: "number", confidence: 0.5 },
+    };
+    const ocrResult = makeOcrResult({ cells, fields, marks });
+
+    const out = await recoverNumericZerosFromCheckboxes({
+      ocrResult,
+      tables: [
+        {
+          find: { firstCellTextContains: "Declare all income" },
+          columns: [{ prefix: "applicant_", headerEquals: "Applicant" }],
+          rows: [
+            {
+              suffix: "net_employment_income",
+              labelEquals: "Net Employment Income",
+            },
+          ],
+        },
+      ],
+    });
+
+    expect(out.metadata?.applied).toBe(0);
+    expect(
+      (out.metadata?.skippedByReason as Record<string, number>)[
+        "cell_has_digits_or_letters"
+      ],
+    ).toBe(1);
+  });
 });

apps/temporal/src/activities/ocr-recover-numeric-zeros.ts

@@ -255,9 +255,26 @@ function cellHasSelectionMark(
   return false;
 }
 
+/**
+ * A cell is eligible if, after stripping the configured tokens and collapsing
+ * whitespace, ANY of these holds:
+ *   - the remaining string is empty (the only thing in the cell was a
+ *     currency/selection-mark marker — classic checkbox-as-zero pattern);
+ *   - the remaining string contains no digits and no letters (e.g. lone
+ *     punctuation left over after stripping);
+ *   - the remaining string parses to the configured `recoveryValue` (e.g.
+ *     `"0"`, `"0.00"`, `"0,00"` when recoveryValue=0). This covers cells
+ *     like `"$ 0\n:selected:"` where Azure DI's layout step recognized the
+ *     digit AND a stray selection mark in the same cell — the custom model
+ *     emitted null but the digit is provably present.
+ *
+ * The selection-mark-overlap gate is applied separately by the caller, so we
+ * still require a real checkbox glyph in the cell.
+ */
 function cellIsEligibleByContent(
   content: string,
   stripTokens: string[],
+  recoveryValue?: number,
 ): boolean {
   let stripped = content;
   for (const token of stripTokens) {
@@ -267,7 +284,12 @@ function cellIsEligibleByContent(
   }
   stripped = stripped.replace(/\s+/g, "");
   if (stripped.length === 0) return true;
-  return !/[A-Za-z0-9]/.test(stripped);
+  if (!/[A-Za-z0-9]/.test(stripped)) return true;
+  if (typeof recoveryValue === "number") {
+    const parsed = Number(stripped.replace(",", "."));
+    if (!Number.isNaN(parsed) && parsed === recoveryValue) return true;
+  }
+  return false;
 }
 
 function fieldIsEmpty(field: AzureDocumentFieldValue | undefined): boolean {
@@ -842,7 +864,9 @@ export async function recoverNumericZerosFromCheckboxes(
           skipped.push({ fieldKey, reason: "cell_not_found" });
           continue;
         }
-        if (!cellIsEligibleByContent(cell.content, stripTokens)) {
+        if (
+          !cellIsEligibleByContent(cell.content, stripTokens, recoveryValue)
+        ) {
           skipped.push({ fieldKey, reason: "cell_has_digits_or_letters" });
           continue;
         }