Fix four defects found reviewing the matcher

All four reproduce on the customer's August file and three of them are
visible in what the customer reads.

Roll-up matches reported the first ERP entry's amount and line count
rather than the group's, so every roll-up rendered as a matched pair
whose two sides disagreed — "ERP 36,000.00 / Bank -438,623.89" for a
seven-entry roll-up. All 8 August and 27 July roll-ups now tie.

A reversal carries the same magnitude as the payment it backs out, and
candidates are keyed on magnitude, so a payment could be matched to its
own reversal — August holds 539,249.00 as two debits and one reversal
credit, and ranking on date alone could hand an ERP payment the credit.
That reports the reversal as cleared and leaves a real payment
outstanding. Reversals are now flagged and ranked last, so one is only
taken when nothing else fits. The ERP sign is not usable as a direction
check here: across the 132 reference-matched pairs the ERP side is
positive 101 times and negative 31, while the bank side is always a
debit.

_name_close compared the ERP payee against the whole bank description,
including "Payment Instruction", the reference number and the channel
suffix, which diluted the ratio below the threshold even for obvious
pairs — 'ACWORTH RECYCLING LL' against 'Acworth Recycling dba Payment
Instruction 1923-039-116-08' returned False. It now compares against the
payee portion and accepts containment in either direction, which also
covers the 27-char ERP truncation.

Unmatched totals summed signed amounts, so unmatched reversal credits
cancelled unmatched debits: August reported -$8,033,687.59 outstanding
where the gross is $9,764,417.37. Both figures are now gross and labelled
as such, including the one handed to the narrative prompt.

Coverage is unchanged at 91.6% ERP / 86.7% bank for August and 78.3% /
70.6% for July.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

app_chatgpt.py

@@ -391,13 +391,35 @@ def _norm_name(text):
     return re.sub(r"\s+", " ", s).strip()
 
 
+# Payment-rail boilerplate. Bank descriptions read "Acworth Recycling dba
+# Payment Instruction 1923-039-116-08 - Acworth Recycling dba Atlas Demolition
+# - ach"; only the text before the first marker is the payee.
+_RAIL_RE = re.compile(
+    r"\b(payment instruction|reversal|ref\.|wire|eft|trace|memo|ach|check)\b", re.I)
+
+
+def _bank_payee(description):
+    """The payee portion of a bank description, minus the rail boilerplate."""
+    text = _text(description)
+    m = _RAIL_RE.search(text)
+    head = text[:m.start()] if m else text
+    return head.strip(" -\u2013\u2014|,") or text
+
+
 def _name_close(a, b):
-    """True when two payee strings plausibly denote the same vendor. Either may
-    be a prefix of the other because of the 27-char ERP truncation."""
-    a, b = _norm_name(a), _norm_name(b)
+    """True when two payee strings plausibly denote the same vendor.
+
+    `b` is matched against its payee portion rather than the whole bank
+    description: comparing a 27-char truncated ERP payee against a string that
+    also carries "Payment Instruction", a reference number and a channel
+    suffix diluted the ratio far below any usable threshold, so this returned
+    False even for obvious pairs and the tolerance pass never fired.
+    Containment handles the truncation in either direction.
+    """
+    a, b = _norm_name(a), _norm_name(_bank_payee(b))
     if not a or not b:
         return False
-    if a.startswith(b) or b.startswith(a):
+    if a in b or b in a:
         return True
     return difflib.SequenceMatcher(None, a, b).ratio() >= 0.82
 
@@ -590,6 +612,11 @@ def normalize_bank_statement(df):
     })
     out = out[out["amount"].round(2) != 0].reset_index(drop=True)
     out["refs"] = out["desc"].map(lambda s: set(_REF_RE.findall(s)))
+    # A reversal carries the same magnitude as the payment it backs out, so it
+    # competes for the same match. Flagged here and ranked last, so it is only
+    # taken when nothing else fits.
+    out["is_reversal"] = out["desc"].str.contains(
+        r"revers|returned|nsf|chargeback|stop\s*pay", case=False, regex=True, na=False)
 
     n_ref = int(out["refs"].map(bool).sum())
     logger.info(f"🏦 Bank normalised: {len(out)} transaction(s), "
@@ -631,15 +658,23 @@ def match_transactions(erp, bank, amount_tol=0.01, date_tol_days=45):
     matches = []
 
     def take(ei, bi, method, confidence, erp_rows=None):
+        # A roll-up match owns several ERP entries, so the reported amount and
+        # line count are the group's. Reporting only the first entry's figures
+        # rendered every roll-up as a matched pair whose two sides disagreed.
+        rows = list(erp_rows) if erp_rows else [ei]
         e, b = erp.loc[ei], bank.loc[bi]
+        entries = [str(erp.at[i, "entry"]) for i in rows if _text(erp.at[i, "entry"])]
         matches.append({
-            "erp_entry": e["entry"], "erp_date": e["date"], "erp_payee": e["payee"],
-            "erp_amount": e["amount"], "erp_lines": int(e["n_lines"]),
+            "erp_entry": ", ".join(entries) if entries else "",
+            "erp_date": e["date"],
+            "erp_payee": e["payee"],
+            "erp_amount": float(erp.loc[rows, "amount"].sum()),
+            "erp_lines": int(erp.loc[rows, "n_lines"].sum()),
             "bank_date": b["date"], "bank_desc": b["desc"], "bank_amount": b["amount"],
             "method": method, "confidence": confidence,
-            "erp_rows": erp_rows or [ei],
+            "erp_rows": rows,
         })
-        for idx in (erp_rows or [ei]):
+        for idx in rows:
             erp_open.discard(idx)
         bank_open.discard(bi)
 
@@ -663,11 +698,23 @@ def match_transactions(erp, bank, amount_tol=0.01, date_tol_days=45):
         gap = day_gap(ei, bi)
         return True if gap is None else gap <= days
 
+    has_reversal_flag = "is_reversal" in bank.columns
+
+    def is_reversal(bi):
+        return bool(bank.at[bi, "is_reversal"]) if has_reversal_flag else False
+
     def nearest(ei, options):
-        """Of several equal-amount bank lines, the one closest in time."""
+        """Of several equal-amount bank lines, the best candidate.
+
+        Ordinary lines are preferred over reversals before date is considered.
+        August 2026 carried 539,249.00 as two debits and one reversal credit;
+        ranking on date alone could hand an ERP payment the reversal, which
+        reports the reversal as cleared and leaves a real payment outstanding.
+        """
         if not options:
             return None
-        return min(options, key=lambda bi: (day_gap(ei, bi) is None,
+        return min(options, key=lambda bi: (is_reversal(bi),
+                                            day_gap(ei, bi) is None,
                                             day_gap(ei, bi) or 0))
 
     # ── Pass 1: the bank's own reference to the ERP entry ────────────────────
@@ -1255,8 +1302,8 @@ FINAL FIGURES
 - ERP transactions (distribution lines rolled up to entries): {stats['erp_count']} (from {stats['erp_lines']} detail lines)
 - {stmt_label} transactions: {stats['bank_count']}
 - Matched: {stats['matched']} ({stats['erp_cov']:.1f}% of ERP, {stats['bank_cov']:.1f}% of {stmt_label})
-- Unmatched in ERP: {stats['erp_unmatched']} worth {_fmt_money(stats['erp_unmatched_value'])}
-- Unmatched in {stmt_label}: {stats['bank_unmatched']} worth {_fmt_money(stats['bank_unmatched_value'])}
+- Unmatched in ERP: {stats['erp_unmatched']} worth {_fmt_money(stats['erp_unmatched_value'])} gross
+- Unmatched in {stmt_label}: {stats['bank_unmatched']} worth {_fmt_money(stats['bank_unmatched_value'])} gross
 - Match methods used: {stats['methods']}
 
 LARGEST UNMATCHED {stmt_label.upper()} ITEMS
@@ -1339,9 +1386,9 @@ def render_reconciliation_markdown(matched, erp_un, bank_un, stats, stmt_label,
     parts.append(f"| ERP coverage | {stats['erp_cov']:.1f}% |")
     parts.append(f"| {stmt_label} coverage | {stats['bank_cov']:.1f}% |")
     parts.append(f"| Unmatched in ERP | {stats['erp_unmatched']:,} "
-                 f"({_fmt_money(stats['erp_unmatched_value'])}) |")
+                 f"({_fmt_money(stats['erp_unmatched_value'])} gross) |")
     parts.append(f"| Unmatched in {stmt_label} | {stats['bank_unmatched']:,} "
-                 f"({_fmt_money(stats['bank_unmatched_value'])}) |")
+                 f"({_fmt_money(stats['bank_unmatched_value'])} gross) |")
     parts.append("")
 
     if steps:
@@ -1414,8 +1461,10 @@ def reconcile_deterministic(erp_df, external_df, stmt_label, extraction_warning=
         "bank_cov": (len(bank) - len(bank_un)) / len(bank) * 100 if len(bank) else 0.0,
         "erp_unmatched": len(erp_un),
         "bank_unmatched": len(bank_un),
-        "erp_unmatched_value": float(erp_un["amount"].sum()) if not erp_un.empty else 0.0,
-        "bank_unmatched_value": float(bank_un["amount"].sum()) if not bank_un.empty else 0.0,
+        # Gross, not a signed net: unmatched reversal credits would otherwise
+        # cancel unmatched debits and understate the work remaining.
+        "erp_unmatched_value": float(erp_un["amount"].abs().sum()) if not erp_un.empty else 0.0,
+        "bank_unmatched_value": float(bank_un["amount"].abs().sum()) if not bank_un.empty else 0.0,
         "methods": methods,
     }