feat(go/M2.1): port czech.Normalize — NFKD + Mn strip + lowercase

Adds internal/domain/czech.Normalize, the first pure-domain function in the Go rewrite (M2 milestone). Matches Python czech_utils.normalize byte- for-byte: NFKD decompose via golang.org/x/text/unicode/norm, drop Mn- category combining marks (unicode.Mn, not IsMark, to match Python's unicodedata.combining() semantics), then strings.ToLower. Includes 13-case table-driven test; all inputs spot-checked against the Python implementation before locking. Adds golang.org/x/text v0.36.0 as first external dependency. Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>
docs: Add branch-per-feature + Gitea MR workflow to CLAUDE.md
2026-05-05 22:23:40 +02:00 · 2026-05-05 21:52:25 +02:00 · 2026-05-05 17:22:54 +02:00
15 changed files with 824 additions and 120 deletions
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -92,6 +92,34 @@ Tiers are set in column B of the attendance sheet:

 `/qr?account=…&amount=…&message=…` generates a Czech QR Platba PNG (SPD format).

+## Branching & merge requests
+
+The remote is Gitea (`gitea.home.hrajfrisbee.cz/kacerr/fuj-management`).
+For **features**, do not commit to `main` directly. Use a branch + merge
+request flow:
+
+1. **Create a branch off `main`** before starting work:
+   - `feat/<slug>` for features (e.g. `feat/qr-code-overlay`)
+   - `fix/<slug>` for bug-fix branches the user explicitly asks for
+   - `<slug>` is short kebab-case
+2. **Commit on the branch** following the existing commit conventions
+   (Co-Authored-By trailer, etc.).
+3. **Push the branch** to `origin` with `-u` so it tracks.
+4. **Print the Gitea compare URL** so the user can open the MR in the browser:
+   `https://gitea.home.hrajfrisbee.cz/kacerr/fuj-management/compare/main...<branch>`
+   Do **not** use `tea`, `gh`, or call the Gitea API — the user opens and
+   merges the MR themselves.
+5. **Do not merge or delete the branch** from the CLI. The user does that
+   in Gitea.
+
+**Exceptions — when committing straight to `main` is fine:**
+- Small bug fixes / hotfixes the user describes as such.
+- Typo / comment / formatting tweaks.
+- Edits the user explicitly says to push to `main`.
+
+When uncertain whether something is a feature or a small fix, ask before
+committing.
+
 ## Git Commits

 When making git commits, always append yourself as co-author trailer to the end of the commit message to indicate AI assistance
--- a/app.py
+++ b/app.py
@@ -22,7 +22,7 @@ from config import (
    BANK_ACCOUNT, CREDENTIALS_PATH,
 )
 from attendance import get_members_with_fees, get_junior_members_with_fees, ADULT_MERGED_MONTHS, JUNIOR_MERGED_MONTHS
-from match_payments import reconcile, fetch_sheet_data, fetch_exceptions, normalize
+from match_payments import reconcile, fetch_sheet_data, fetch_exceptions, normalize, canonical_member_key
 from cache_utils import get_sheet_modified_time, read_cache, write_cache, _LAST_CHECKED, flush_cache
 from sync_fio_to_sheets import sync_to_sheets
 from infer_payments import infer_payments
@@ -57,6 +57,25 @@ def get_month_labels(sorted_months, merged_months):
            labels[m] = dt.strftime("%b %Y")
    return labels

+def group_payments_by_person(transactions, member_names=None):
+    canonical_by_key = (
+        {canonical_member_key(n): n for n in member_names} if member_names else {}
+    )
+    grouped = {}
+    for tx in transactions:
+        person = str(tx.get("person", "")).strip()
+        if not person:
+            continue
+        for p in person.split(","):
+            p = re.sub(r"\[\?\]\s*", "", p).strip()
+            if not p:
+                continue
+            key = canonical_by_key.get(canonical_member_key(p), p)
+            grouped.setdefault(key, []).append(tx)
+    for rows in grouped.values():
+        rows.sort(key=lambda t: str(t.get("date", "")), reverse=True)
+    return grouped
+
 def warmup_cache():
    """Pre-fetch all cached data so first request is fast."""
    logger = logging.getLogger(__name__)
@@ -304,6 +323,7 @@ def adults_view():
    unmatched = result["unmatched"]
    import json
    
+    raw_payments_by_person = group_payments_by_person(transactions, [name for name, _, _ in members])
    record_step("process_data")

    return render_template(
@@ -314,6 +334,7 @@ def adults_view():
        totals=formatted_totals,
        member_data=json.dumps(result["members"]),
        month_labels_json=json.dumps(month_labels),
+        raw_payments_json=json.dumps(raw_payments_by_person),
        credits=credits,
        debts=debts,
        unmatched=unmatched,
@@ -506,6 +527,7 @@ def juniors_view():
    credits = sorted([{"name": n, "amount": junior_settled_balance(n)} for n in junior_all_names if junior_settled_balance(n) > 0], key=lambda x: x["name"])
    debts = sorted([{"name": n, "amount": abs(junior_settled_balance(n))} for n in junior_all_names if junior_settled_balance(n) < 0], key=lambda x: x["name"])
    unmatched = result["unmatched"]
+    raw_payments_by_person = group_payments_by_person(transactions, [name for name, _, _ in adapted_members])
    import json

    record_step("process_data")
@@ -518,6 +540,7 @@ def juniors_view():
        totals=formatted_totals,
        member_data=json.dumps(result["members"]),
        month_labels_json=json.dumps(month_labels),
+        raw_payments_json=json.dumps(raw_payments_by_person),
        credits=credits,
        debts=debts,
        unmatched=unmatched,
@@ -535,29 +558,24 @@ def payments():
    
    transactions = get_cached_data("payments_transactions", PAYMENTS_SHEET_ID, fetch_sheet_data, PAYMENTS_SHEET_ID, credentials_path)
    record_step("fetch_payments")
-    
-    # Group transactions by person
-    grouped = {}
+
+    adults_data = get_cached_data("attendance_regular", ATTENDANCE_SHEET_ID, get_members_with_fees)
+    juniors_data = get_cached_data("attendance_juniors", ATTENDANCE_SHEET_ID, get_junior_members_with_fees)
+    member_names = []
+    if adults_data:
+        member_names.extend(name for name, _, _ in adults_data[0])
+    if juniors_data:
+        member_names.extend(name for name, _, _ in juniors_data[0])
+
+    grouped = group_payments_by_person(transactions, member_names)
+    # payments page also groups unmatched rows under a fallback key
    for tx in transactions:
-        person = str(tx.get("person", "")).strip()
-        if not person:
-            person = "Unmatched / Unknown"
-            
-        # Handle multiple people (comma separated)
-        people = [p.strip() for p in person.split(",") if p.strip()]
-        for p in people:
-            # Strip markers
-            clean_p = re.sub(r"\[\?\]\s*", "", p)
-            if clean_p not in grouped:
-                grouped[clean_p] = []
-            grouped[clean_p].append(tx)
-            
-    # Sort people and their transactions
+        if not str(tx.get("person", "")).strip():
+            grouped.setdefault("Unmatched / Unknown", []).append(tx)
+    for rows in grouped.values():
+        rows.sort(key=lambda t: str(t.get("date", "")), reverse=True)
    sorted_people = sorted(grouped.keys())
-    for p in sorted_people:
-        # Sort by date descending
-        grouped[p].sort(key=lambda x: str(x.get("date", "")), reverse=True)
-        
+
    record_step("process_data")
    return render_template(
        "payments.html",
--- a/docs/plans/2026-05-05-1637-member-modal-raw-payments-debug.md
+++ b/docs/plans/2026-05-05-1637-member-modal-raw-payments-debug.md
@@ -0,0 +1,99 @@
+# Member modal — raw payments debug list
+
+## Context
+
+When a payer's bank message doesn't follow our convention, [`infer_payments.py`](scripts/infer_payments.py) may map the transfer to the wrong period (or none), and today the member detail modal hides this — it only shows the post-allocation, per-month splits produced by [`reconcile()`](scripts/match_payments.py:295). To diagnose these cases the user needs to see the **original sheet rows** that were attributed to a member: full `Amount`, `Inferred Amount`, `Person`, `Purpose`, `Sender`, `Message`, `Bank ID`, `manual fix`. The list should be hidden by default and revealed by a small toggle, since it is only relevant during debugging.
+
+## Approach
+
+Reuse the grouping logic that already exists in the [`/payments` route](app.py:540-553): group raw `tx` dicts by parsed `Person`, expose that mapping to the modal, and render it on demand under a new collapsible section.
+
+### 1. Backend — group raw txs by member
+
+In [`app.py`](app.py):
+
+- Factor the existing per-person grouping in [`payments()`](app.py:530-568) into a small helper near the top of the file:
+  ```python
+  def group_payments_by_person(transactions):
+      grouped = {}
+      for tx in transactions:
+          person = str(tx.get("person", "")).strip()
+          if not person:
+              continue  # unmatched rows are not tied to a member
+          for p in person.split(","):
+              p = re.sub(r"\[\?\]\s*", "", p).strip()
+              if not p:
+                  continue
+              grouped.setdefault(p, []).append(tx)
+      for rows in grouped.values():
+          rows.sort(key=lambda t: str(t.get("date", "")), reverse=True)
+      return grouped
+  ```
+  Call it from [`payments()`](app.py:530), [`adults_view()`](app.py:160) and [`juniors_view()`](app.py:326) — the existing `payments()` body collapses to one line.
+
+- In `adults_view()` and `juniors_view()`, after `transactions = get_cached_data(...)`, build `raw_payments_by_person = group_payments_by_person(transactions)` and pass it to `render_template` as `raw_payments_json=json.dumps(raw_payments_by_person)`.
+
+- Note: rows where `Person` is empty are skipped on purpose — those have no member to attach to and are already shown by the dashboard's `Unmatched` block.
+
+### 2. Templates — add a collapsible raw section to the modal
+
+In [`templates/adults.html`](templates/adults.html) and [`templates/juniors.html`](templates/juniors.html), make the same structural and JS changes (the modal markup is mirrored in both files — `adults.html:677-682` and `juniors.html:658-663`).
+
+- Inject the new dataset alongside the existing `memberData`:
+  ```html
+  const rawPaymentsByPerson = {{ raw_payments_json| safe }};
+  ```
+  (next to [`adults.html:696`](templates/adults.html#L696)).
+
+- Add a new section directly **after** the Payment History block:
+  ```html
+  <div class="modal-section">
+      <div class="modal-section-title">
+          Raw Payments
+          <a href="#" id="rawPaymentsToggle" class="raw-toggle"
+             onclick="toggleRawPayments(event)">[show]</a>
+      </div>
+      <div id="modalRawList" class="tx-list" style="display: none;">
+          <!-- Filled by JS -->
+      </div>
+  </div>
+  ```
+  Add a small CSS rule for `.raw-toggle` (muted color, smaller font, `margin-left: 8px`) — a few lines next to the existing `.modal-section-title` style. Don't restyle the whole modal.
+
+- In `showMemberDetails(name)`:
+  - Reset the toggle to `[show]` and the `#modalRawList` to `display: none` on every open (so the state doesn't leak between members).
+  - Populate `#modalRawList` from `rawPaymentsByPerson[name] || []`. For each row render: `Date | Purpose` on the meta line, `Amount CZK` (with `Inferred: X CZK` annotation when `inferred_amount` differs from `amount`), `Sender`, `Person` (full string — useful when split between multiple people), `Message`, and a small footer with `Bank ID` and a `[manual fix]` marker if `manual_fix` is truthy. Reuse the existing `tx-item` / `tx-meta` / `tx-main` / `tx-msg` styles to match the rest of the modal.
+  - When the list is empty, render `<div style="color: #444; font-style: italic; padding: 10px 0;">No raw payments tied to this member.</div>` (same idiom used at [`adults.html:813`](templates/adults.html#L813)).
+
+- Add the toggle handler near `closeModal`:
+  ```js
+  function toggleRawPayments(ev) {
+      ev.preventDefault();
+      const list = document.getElementById('modalRawList');
+      const link = document.getElementById('rawPaymentsToggle');
+      const hidden = list.style.display === 'none';
+      list.style.display = hidden ? 'block' : 'none';
+      link.textContent = hidden ? '[hide]' : '[show]';
+  }
+  ```
+
+### 3. Why not extend `reconcile()` instead
+
+`reconcile()` already collapses each row into per-month allocated shares and drops `purpose`, `inferred_amount`, `bank_id`, `manual_fix`, and the gross `amount` ([trace](scripts/match_payments.py:436-469)). Carrying the raw `tx` through `reconcile()` would inflate the contract for every consumer when only the modal needs it. Grouping the already-fetched `transactions` list at the route level is one extra dict per request and reuses the cached payments data — no new sheet reads.
+
+## Critical files
+
+- [app.py](app.py) — add `group_payments_by_person()` helper; call it in `adults_view()`, `juniors_view()`, and `payments()`; pass `raw_payments_json` to the two dashboard templates.
+- [templates/adults.html](templates/adults.html) — modal section + JS + tiny CSS for the toggle link.
+- [templates/juniors.html](templates/juniors.html) — same changes as adults.html.
+
+## Verification
+
+1. `make web-debug` and open `http://localhost:5001/adults`.
+2. Pick a member known to have multiple payments (use the existing `/payments` page as a cross-reference).
+3. Click `[i]` → modal opens, raw list is hidden, link shows `[show]`. Click the link → list appears with the raw rows; click again → hides, link returns to `[show]`.
+4. Switch to another member via keyboard (ArrowDown) — the toggle resets to hidden and the list updates to the new member's rows (no leaking).
+5. Compare the raw rows in the modal against the `/payments` page grouping for the same person — same set of rows, same `Date`/`Amount`/`Message`.
+6. Pick a row with a non-conformant message (e.g. one where `Person` was inferred to multiple people) — confirm `Person` shows the full comma-separated string and `Inferred Amount` is visible when it differs from `Amount`.
+7. Repeat the click-through on `/juniors` to confirm parity.
+8. `make test` — no backend behavior change is expected, but run to catch template/route smoke breakage.
--- a/docs/plans/2026-05-05-1717-payment-person-name-canonicalization.md
+++ b/docs/plans/2026-05-05-1717-payment-person-name-canonicalization.md
@@ -0,0 +1,135 @@
+# Tolerate diacritic / case / whitespace mismatches between `Person` column and member names
+
+## Context
+
+For "Mária Maco" there is a payment row in the payments sheet with `Purpose = 2026-04`, but the modal for that member shows neither a paid 2026-04 cell **nor** a row in payment history. Both symptoms collapse to a single root cause in [`reconcile()`](scripts/match_payments.py#L295), confirmed by reading the code:
+
+- [`scripts/match_payments.py:404`](scripts/match_payments.py#L404) — `if member_name not in ledger:` is a **byte-exact** comparison. `member_name` is the `Person` cell from the payments sheet with only `.strip()` and `[?]` markers removed ([:349-353](scripts/match_payments.py#L349-L353)). `ledger` keys are the canonical names from the attendance sheet. There is no diacritic, case, or whitespace normalization on this path. (`czech_utils.normalize` is imported and used for the `exceptions` lookup at [:282-283 / :321-322](scripts/match_payments.py#L282-L322), but **not** for member-name matching.)
+- When a row falls through that check, it is appended to `unmatched` and never reaches `ledger[member_name][m]['paid']` or `['transactions']`. The dashboard's per-month "paid" cell stays unpaid, and because the modal's payment history is built from `data.months[m].transactions` ([`templates/adults.html:772-776`](templates/adults.html#L772-L776)), the row also disappears from the modal's history list.
+- The new "Raw Payments" debug section ([`templates/adults.html:861`](templates/adults.html#L861)) uses `rawPaymentsByPerson[name]`. Its keys come from [`group_payments_by_person()` in `app.py:60-73`](app.py#L60-L73), which also stores the **literal** `Person` string (only `.strip()` and `[?]` stripped). So if the attendance-sheet name and the `Person` cell differ at the byte level, that section also returns an empty list — which is why the user does not see the row anywhere in the modal.
+
+The most likely cause for "Mária Maco" specifically: the `Person` cell was typed (or pasted) without the `á` diacritic — `Maria Maco` vs `Mária Maco`. Other plausible variants the current code silently drops: case differences (`mária maco`), trailing/embedded extra whitespace, and NBSP characters.
+
+The fix is to make the matching tolerant via the existing [`czech_utils.normalize()`](scripts/czech_utils.py#L22-L25) helper (NFKD + lowercase), with a small whitespace-collapse on top, and apply the same canonicalization in `group_payments_by_person()` so the modal's raw-payments lookup uses the canonical attendance-sheet name as the key.
+
+## Approach
+
+### 1. `scripts/match_payments.py` — tolerant `Person` → `ledger` resolution in `reconcile()`
+
+- Add a small private helper at module scope:
+
+  ```python
+  def _canonical_key(name: str) -> str:
+      return re.sub(r"\s+", " ", normalize(name)).strip()
+  ```
+
+  Uses the existing `normalize()` from `czech_utils` ([:22-25](scripts/czech_utils.py#L22-L25)) and additionally collapses whitespace runs to a single space so `"Mária  Maco"` and `"Mária Maco"` both reduce to `"maria maco"`.
+
+- Inside [`reconcile()`](scripts/match_payments.py#L295), right after `member_names` is computed ([:308](scripts/match_payments.py#L308)), build a lookup dict once:
+
+  ```python
+  canonical_by_key: dict[str, str] = {}
+  for name in member_names:
+      key = _canonical_key(name)
+      canonical_by_key.setdefault(key, name)  # first wins; ambiguity handled below
+  ```
+
+- Replace the byte-exact check at [:404](scripts/match_payments.py#L404). Resolve each `member_name` from `matched_members` to the canonical attendance-sheet name before any ledger / credits access:
+
+  ```python
+  for raw_member_name, confidence in matched_members:
+      member_name = canonical_by_key.get(_canonical_key(raw_member_name))
+      if member_name is None:
+          logger.warning(
+              "Payment matched to unknown member %r (tx: %s, %s) — adding to unmatched",
+              raw_member_name, tx.get("date", "?"), tx.get("message", "?"),
+          )
+          unmatched.append(tx)
+          continue
+      if member_name != raw_member_name:
+          logger.info(
+              "Person cell %r resolved to canonical member %r — consider fixing the sheet",
+              raw_member_name, member_name,
+          )
+      # ... rest of the loop body unchanged: ledger[member_name], credits[member_name], …
+  ```
+
+  The `logger.info` line lets the user see (in `make web-debug` logs) which sheet rows have a non-canonical `Person` value, so they can clean them up at their own pace — without breaking allocation in the meantime.
+
+- Leave the rest of the function untouched. Once `member_name` is the canonical name, every downstream key (`ledger[member_name]`, `credits[member_name]`, `other_ledger[member_name]`, the `tx["person"]` echo into `transactions`) is already correct.
+
+### 2. `app.py` — canonicalize the raw-payments grouping key
+
+- The current [`group_payments_by_person()`](app.py#L60-L73) cannot canonicalize on its own because it does not know the attendance-sheet member list. Extend its signature to accept the member list and reuse `_canonical_key`:
+
+  ```python
+  from match_payments import _canonical_key  # or re-export via a tiny public name
+
+  def group_payments_by_person(transactions, member_names=None):
+      canonical_by_key = (
+          {_canonical_key(n): n for n in member_names} if member_names else {}
+      )
+      grouped = {}
+      for tx in transactions:
+          person = str(tx.get("person", "")).strip()
+          if not person:
+              continue
+          for p in person.split(","):
+              p = re.sub(r"\[\?\]\s*", "", p).strip()
+              if not p:
+                  continue
+              key = canonical_by_key.get(_canonical_key(p), p)  # fallback: keep raw
+              grouped.setdefault(key, []).append(tx)
+      for rows in grouped.values():
+          rows.sort(key=lambda t: str(t.get("date", "")), reverse=True)
+      return grouped
+  ```
+
+- Update the three call sites to pass `member_names`:
+  - `adults_view()` around [`app.py:333`](app.py#L333) — `members` is already in scope; pass `[name for name, _, _ in members]`.
+  - `juniors_view()` around [`app.py:539`](app.py#L539) — same.
+  - `payments()` around [`app.py:549`](app.py#L549) — same; needs the adult+junior member names so the `/payments` per-person grouping is consistent.
+
+- Naming: `_canonical_key` starts with an underscore inside `match_payments.py`. To avoid leaking a private symbol, expose it as `canonical_member_key` (no underscore) in `match_payments.py` and import that name from `app.py`.
+
+### 3. Why not also touch `infer_payments.py`
+
+`infer_payments.py` already writes canonical attendance-sheet names into the `Person` column (it picks from `member_names`). The bug only manifests when the cell was filled in **manually** by a human (typed without diacritics, different case) or was written by an older inference that has since drifted from a renamed attendance row. Making `reconcile()` tolerant fixes the symptom for both cases without changing inference. The `logger.info` line is sufficient signal for the user to clean up the sheet on their own schedule.
+
+### 4. Tests
+
+**4a. Delete obsolete route tests in [tests/test_app.py](tests/test_app.py).** Four tests target Flask routes that no longer exist (the old fee/reconcile pages were merged into `/adults` and `/juniors`); they currently fail with 404. Their coverage is already provided by `test_adults_route`, `test_juniors_route`, and `test_payments_route`. Delete:
+
+- `test_fees_route` ([tests/test_app.py:22-35](tests/test_app.py#L22-L35)) — hits `/fees`
+- `test_fees_juniors_route` ([tests/test_app.py:37-55](tests/test_app.py#L37-L55)) — hits `/fees-juniors`
+- `test_reconcile_route` ([tests/test_app.py:57-81](tests/test_app.py#L57-L81)) — hits `/reconcile`; also asserts a literal `OK` string the merged dashboard no longer renders
+- `test_reconcile_juniors_route` ([tests/test_app.py:101-131](tests/test_app.py#L101-L131)) — hits `/reconcile-juniors`; same `OK` assertion mismatch
+
+The two tests that reference junior-only formatting (`? / 1 (J)` and `500 CZK / 4 (1A+3J)`) are testing a retired template, not the live `/juniors` page — no need to migrate those assertions; the live `/juniors` format is already covered by `test_juniors_route`.
+
+**4b. Add `tests/test_match_payments.py`** (new file) covering the resolution helper and `reconcile()` end-to-end for the canonicalization fix:
+
+- `_canonical_key("Mária  Maco") == _canonical_key("maria maco")`
+- `reconcile()` with member `"Mária Maco"` and a tx `{person: "Maria Maco", purpose: "2026-04", amount: 750, ...}` produces:
+  - `result['members']['Mária Maco']['months']['2026-04']['paid'] == 750`
+  - the tx appears in `result['members']['Mária Maco']['months']['2026-04']['transactions']`
+  - `result['unmatched']` is empty
+- `reconcile()` with `Person = "Někdo Neznámý"` (no match in members) still routes to `unmatched`.
+
+## Critical files
+
+- [scripts/match_payments.py](scripts/match_payments.py) — add `canonical_member_key()` helper; build `canonical_by_key` once in `reconcile()`; resolve `raw_member_name` → `member_name` before ledger access at [:404](scripts/match_payments.py#L404).
+- [app.py](app.py) — extend `group_payments_by_person()` to accept `member_names` and key the grouped dict by canonical attendance-sheet name; update three call sites.
+- [tests/test_app.py](tests/test_app.py) — delete the four obsolete route tests listed in §4a.
+- [tests/test_match_payments.py](tests/test_match_payments.py) — add the cases above (create the file if missing).
+- [docs/plans/](docs/plans/) — per project [CLAUDE.md](CLAUDE.md), move this plan file to `docs/plans/2026-05-05-1640-payment-person-name-canonicalization.md` once execution starts (the plan-mode harness writes to `~/.claude/plans/` by default).
+
+## Verification
+
+1. **Reproduce first.** Before touching code, open `/adults`, click `[i]` next to "Mária Maco", and confirm both: 2026-04 is unpaid and the payment is missing from history. Inspect the actual `Person` cell value in the payments sheet for the 2026-04 row — confirm it differs from `"Mária Maco"` (likely missing the `á`). Record the exact string for the test case.
+2. `make test` — new tests pass; existing tests still green.
+3. `make web-debug` and reload `/adults`. The 2026-04 cell for "Mária Maco" turns green (`cell-ok`); the modal's payment history shows the row; the "Raw Payments" section also shows the row. Server log emits `Person cell 'Maria Maco' resolved to canonical member 'Mária Maco' — consider fixing the sheet`.
+4. Cross-check `/payments` — the row appears under the `Mária Maco` group (canonical key), not under a separate `Maria Maco` group.
+5. Spot-check one member with the conventionally-correct `Person` value (e.g. one of the recent payers visible on the dashboard) — paid cells and history are unchanged, no spurious resolution log line.
+6. Confirm a payment with a genuinely unknown `Person` (typo of a non-member) still ends up in the dashboard's `Unmatched` block and emits the existing `Payment matched to unknown member …` warning.
+7. Append a `CHANGELOG.md` entry per [CLAUDE.md](CLAUDE.md) once the user confirms the fix works.
--- a/docs/plans/2026-05-05-2144-branch-per-feature-workflow.md
+++ b/docs/plans/2026-05-05-2144-branch-per-feature-workflow.md
@@ -0,0 +1,83 @@
+# Branch-per-feature + Gitea MR workflow
+
+## Context
+
+Until now, Claude has been committing feature work directly to `main`
+(see recent history: `feat: Lower adult monthly fee…`, `feat: Go rewrite M1…`,
+all on `main`). The user wants to switch to a branch-per-feature flow with
+review via a Gitea merge request, so that:
+
+- Feature work is reviewable as a self-contained diff before it lands.
+- `main` stays releasable.
+- The change history shows reviewed merges, not unsupervised pushes.
+
+The remote is Gitea (`https://gitea.home.hrajfrisbee.cz/kacerr/fuj-management.git`),
+which supports the standard pull/merge-request flow.
+
+This plan only modifies `CLAUDE.md`. No code changes.
+
+## Scope clarification (from user)
+
+- **MR creation method:** Claude pushes the branch and prints the Gitea
+  "compare" URL. The user opens / merges the MR in the browser. No `tea` CLI,
+  no API calls.
+- **When the flow applies:** Features only. Small bug fixes and hotfixes can
+  still be committed straight to `main`. Claude decides feature-vs-fix based
+  on scope; when uncertain, ask.
+- **Branch naming:** `feat/<slug>` for features, `fix/<slug>` for the
+  occasional bug-fix branch the user explicitly requests. `<slug>` is
+  kebab-case, short, descriptive.
+
+## Change
+
+Add a new top-level section to `CLAUDE.md` titled **"Branching & merge requests"**,
+placed immediately before the existing `## Git Commits` section so the workflow
+context appears before the commit-message convention.
+
+### Proposed section content
+
+```markdown
+## Branching & merge requests
+
+The remote is Gitea (`gitea.home.hrajfrisbee.cz/kacerr/fuj-management`).
+For **features**, do not commit to `main` directly. Use a branch + merge
+request flow:
+
+1. **Create a branch off `main`** before starting work:
+   - `feat/<slug>` for features (e.g. `feat/qr-code-overlay`)
+   - `fix/<slug>` for bug-fix branches the user explicitly asks for
+   - `<slug>` is short kebab-case
+2. **Commit on the branch** following the existing commit conventions
+   (Co-Authored-By trailer, etc.).
+3. **Push the branch** to `origin` with `-u` so it tracks.
+4. **Print the Gitea compare URL** so the user can open the MR in the
+   browser:
+   `https://gitea.home.hrajfrisbee.cz/kacerr/fuj-management/compare/main...<branch>`
+   Do **not** use `tea`, `gh`, or call the Gitea API — the user opens and
+   merges the MR themselves.
+5. **Do not merge or delete the branch** from the CLI. The user does that
+   in Gitea.
+
+**Exceptions — when committing straight to `main` is fine:**
+- Small bug fixes / hotfixes the user describes as such.
+- Typo / comment / formatting tweaks.
+- Edits the user explicitly says to push to `main`.
+
+When uncertain whether something is "feature" or "small fix", ask before
+committing.
+```
+
+## Files to modify
+
+- [CLAUDE.md](CLAUDE.md) — insert the new `## Branching & merge requests`
+  section just above the existing `## Git Commits` section (around line 95).
+
+## Verification
+
+- Re-read `CLAUDE.md` and confirm the new section is well-placed and the
+  existing structure (`## Git Commits`, `## Changelog`, `## Plans`) is intact.
+- `git diff CLAUDE.md` should show only an additive change.
+- No code, tests, or runtime behavior changes — nothing else to test.
+- Behavior verification happens on the **next** feature request: Claude
+  should create a `feat/<slug>` branch, commit there, push, and print the
+  compare URL instead of committing on `main`.
--- a/docs/plans/2026-05-05-2204-go-rewrite-m2-1-czech-normalize.md
+++ b/docs/plans/2026-05-05-2204-go-rewrite-m2-1-czech-normalize.md
@@ -0,0 +1,154 @@
+# Plan: Go rewrite — M2.1 `domain/czech.Normalize`
+
+## Context
+
+The Go rewrite finished M1 (skeleton, tooling, hello server) in commit
+`cf0f176` on 2026-05-04. The next milestone, **M2 — Pure-domain helpers**,
+is current per [progress tracker](2026-05-03-2349-go-backend-rewrite-progress.md)
+but has no work landed yet (all 12 sub-tasks unchecked).
+
+This plan covers only the **first** M2 task: porting Python's
+`normalize` from [scripts/czech_utils.py](../../scripts/czech_utils.py)
+to Go as `internal/domain/czech.Normalize`. It is the lowest-level helper
+in the domain — `parse_month_references`, `_build_name_variants`,
+`match_members`, exception keys, and `reconcile` all transitively depend
+on it. Getting it byte-equivalent first removes a class of "why does my
+match not fire" failures from every later M2 task.
+
+**Decision (confirmed in plan-mode Q):** start with hand-written Go unit
+tests for fresh Czech edge cases. Defer parity-fixture wiring until
+M3.1/M3.2 land (separate task); add the parity test for `Normalize`
+retroactively at that point.
+
+## Scope
+
+- New package `go/internal/domain/czech/` with `Normalize` and unit tests.
+- Add `golang.org/x/text` dependency to `go/go.mod` (currently zero deps).
+- **Out of scope:** `ParseMonthReferences` (M2.2), fixture tooling
+  (M3.1/M3.2), CLI subcommand wiring (M2.11/M2.12), parity test runner.
+
+## Recommended approach
+
+### Python contract to match
+
+```python
+def normalize(text: str) -> str:
+    nfkd = unicodedata.normalize("NFKD", text)
+    return "".join(c for c in nfkd if not unicodedata.combining(c)).lower()
+```
+
+Three semantic operations:
+1. NFKD decompose
+2. Drop characters where `unicodedata.combining(c)` is non-zero
+3. Lowercase
+
+### Go implementation
+
+`go/internal/domain/czech/normalize.go`:
+
+```go
+package czech
+
+import (
+    "strings"
+    "unicode"
+    "golang.org/x/text/unicode/norm"
+)
+
+func Normalize(s string) string {
+    decomposed := norm.NFKD.String(s)
+    var b strings.Builder
+    b.Grow(len(decomposed))
+    for _, r := range decomposed {
+        if unicode.In(r, unicode.Mn) {
+            continue
+        }
+        b.WriteRune(r)
+    }
+    return strings.ToLower(b.String())
+}
+```
+
+**Two precision points worth flagging:**
+
+1. **`unicode.Mn` not `unicode.IsMark`.** The plan's library-choices
+   table mentions `unicode.IsMark`, but that covers Mn + Mc + Me. Python
+   `unicodedata.combining()` returns 0 for Mc/Me (their canonical
+   combining class is 0), so it effectively filters only Mn. Use
+   `unicode.In(r, unicode.Mn)` for byte-equivalence with Python. Cite
+   this in a one-line code comment; it's the kind of thing a future
+   reader will second-guess.
+2. **`strings.ToLower` vs Go's locale-aware tools.** Python's `.lower()`
+   on already-decomposed Latin is straight ASCII lowercase for Czech.
+   Stdlib `strings.ToLower` matches; do not pull in `golang.org/x/text/cases`.
+
+### Tests
+
+`go/internal/domain/czech/normalize_test.go` — table-driven, covers:
+
+- ASCII passthrough: `"Honza" → "honza"`
+- Czech lowercase diacritics: `"žluťoučký" → "zlutoucky"`
+- Mixed case + diacritics: `"Příliš" → "prilis"`
+- Czech caron + ring: `"Dvořák" → "dvorak"`, `"Růžena" → "ruzena"`
+- Hard letters: `"Čeněk" → "cenek"`, `"Kačer" → "kacer"`
+- Empty string: `"" → ""`
+- Already-normalized: `"prilis" → "prilis"` (idempotence)
+- Pre-composed vs decomposed input both produce the same output (NFC
+  `"é"` and `"é"` both → `"e"`)
+- Whitespace preserved: `"Jan Novák" → "jan novak"`
+
+Run a one-shot cross-check against the live Python implementation for
+each test input before locking the table:
+```
+PYTHONPATH=scripts:. python -c \
+  'from czech_utils import normalize; print(repr(normalize("Dvořák")))'
+```
+This is the manual stand-in for the M3 parity fixtures.
+
+### Wire-up
+
+- `go get golang.org/x/text@latest` (run from `go/`); `go mod tidy`.
+- No CLI changes — `cmd/fuj` already stubs `fees`/`reconcile` with
+  exit code 2; no need to touch dispatcher for this task. `Normalize`
+  is consumed by other domain code, not by users directly.
+
+## Critical files
+
+- New: [go/internal/domain/czech/normalize.go](../../go/internal/domain/czech/normalize.go)
+- New: [go/internal/domain/czech/normalize_test.go](../../go/internal/domain/czech/normalize_test.go)
+- Modified: [go/go.mod](../../go/go.mod), `go/go.sum` (new)
+- Reference (read-only): [scripts/czech_utils.py](../../scripts/czech_utils.py) — the porting source
+- Reference (read-only): [docs/plans/2026-05-03-2349-go-backend-rewrite.md](2026-05-03-2349-go-backend-rewrite.md) — risk #3 (NFKD edge cases)
+
+## Verification
+
+End-to-end checks before marking M2.1 done:
+
+1. `cd go && go build ./...` — clean compile.
+2. `cd go && go test ./internal/domain/czech/...` — all table cases green.
+3. `cd go && go test -race ./...` — race-clean.
+4. `cd go && golangci-lint run` (or `make go-lint` from repo root) — clean.
+5. **Spot parity** (manual, will be automated in M3): for each Go test
+   input, run the Python `normalize` via `PYTHONPATH=scripts:. python -c
+   '...'` and confirm bytes match. Capture the diff in the commit
+   message if anything surprises.
+6. `make go-build && make go-test && make go-lint` from repo root — proves
+   the existing M1 gate still passes.
+
+## Branching & follow-up
+
+Per [CLAUDE.md](../../CLAUDE.md), this is feature work → branch + Gitea MR:
+
+- Branch: `feat/m2-1-czech-normalize` off `main`.
+- Single commit, Co-Authored-By trailer.
+- Push with `-u`, print compare URL
+  `https://gitea.home.hrajfrisbee.cz/kacerr/fuj-management/compare/main...feat/m2-1-czech-normalize`
+- User opens/merges the MR.
+- After merge: tick `M2.1` in the progress tracker with the commit SHA;
+  add a one-line CHANGELOG entry; record any porting surprise in the
+  tracker's "Notes & decisions" section (e.g. the `Mn`-vs-`IsMark`
+  precision point if it bears noting).
+
+Next task after this lands is **M2.2 `ParseMonthReferences`** — the
+larger, edge-case-heavier sibling. Whether to start it before or after
+M3.1/M3.2 is a separate decision the user can make then.
--- a/go/go.mod
+++ b/go/go.mod
@@ -1,3 +1,5 @@
 module fuj-management/go

 go 1.26.1
+
+require golang.org/x/text v0.36.0
--- a/go/go.sum
+++ b/go/go.sum
@@ -0,0 +1,2 @@
+golang.org/x/text v0.36.0 h1:JfKh3XmcRPqZPKevfXVpI1wXPTqbkE5f7JA92a55Yxg=
+golang.org/x/text v0.36.0/go.mod h1:NIdBknypM8iqVmPiuco0Dh6P5Jcdk8lJL0CUebqK164=
--- a/go/internal/domain/czech/normalize.go
+++ b/go/internal/domain/czech/normalize.go
@@ -0,0 +1,26 @@
+package czech
+
+import (
+	"strings"
+	"unicode"
+
+	"golang.org/x/text/unicode/norm"
+)
+
+// Normalize strips diacritics and lowercases s.
+//
+// Matches Python: unicodedata.normalize("NFKD", s) then filter out
+// combining characters (unicode.Mn only — not Mc/Me, which have
+// combining class 0 in Python's unicodedata.combining()).
+func Normalize(s string) string {
+	decomposed := norm.NFKD.String(s)
+	var b strings.Builder
+	b.Grow(len(decomposed))
+	for _, r := range decomposed {
+		if unicode.In(r, unicode.Mn) {
+			continue
+		}
+		b.WriteRune(r)
+	}
+	return strings.ToLower(b.String())
+}
--- a/go/internal/domain/czech/normalize_test.go
+++ b/go/internal/domain/czech/normalize_test.go
@@ -0,0 +1,31 @@
+package czech
+
+import "testing"
+
+func TestNormalize(t *testing.T) {
+	cases := []struct {
+		in   string
+		want string
+	}{
+		{"Honza", "honza"},
+		{"žluťoučký", "zlutoucky"},
+		{"Příliš", "prilis"},
+		{"Dvořák", "dvorak"},
+		{"Růžena", "ruzena"},
+		{"Čeněk", "cenek"},
+		{"Kačer", "kacer"},
+		{"", ""},
+		{"prilis", "prilis"},                     // idempotent
+		{"Jan Novák", "jan novak"},               // whitespace preserved
+		{"é", "e"},                               // precomposed é (NFC)
+		{"é", "e"},                              // decomposed e + combining acute
+		{"Ondřej Procházka", "ondrej prochazka"}, // realistic full name
+	}
+
+	for _, tc := range cases {
+		got := Normalize(tc.in)
+		if got != tc.want {
+			t.Errorf("Normalize(%q) = %q, want %q", tc.in, got, tc.want)
+		}
+	}
+}
--- a/scripts/match_payments.py
+++ b/scripts/match_payments.py
@@ -17,6 +17,15 @@ from czech_utils import normalize, parse_month_references
 from sync_fio_to_sheets import get_sheets_service, DEFAULT_SPREADSHEET_ID


+def canonical_member_key(name: str) -> str:
+    """Diacritic-, case-, and whitespace-insensitive key for member-name matching.
+
+    Used to resolve `Person`-column values from the payments sheet to canonical
+    attendance-sheet names, tolerating cells like "Maria Maco" vs "Mária Maco".
+    """
+    return re.sub(r"\s+", " ", normalize(name)).strip()
+
+
 # ---------------------------------------------------------------------------
 # Name matching
 # ---------------------------------------------------------------------------
@@ -309,6 +318,12 @@ def reconcile(
    member_tiers = {name: tier for name, tier, _ in members}
    member_fees = {name: fees for name, _, fees in members}

+    # Map canonical key → first attendance-sheet name with that key, so a
+    # `Person` cell that drifts in diacritics/case/whitespace still resolves.
+    canonical_by_key: dict[str, str] = {}
+    for name in member_names:
+        canonical_by_key.setdefault(canonical_member_key(name), name)
+
    # Initialize ledger
    ledger: dict[str, dict[str, dict]] = {}
    other_ledger: dict[str, list] = {}
@@ -386,8 +401,9 @@ def reconcile(
        if is_other:
            num_allocations = len(matched_members)
            per_allocation = amount / num_allocations if num_allocations > 0 else 0
-            for member_name, confidence in matched_members:
-                if member_name in other_ledger:
+            for raw_member_name, confidence in matched_members:
+                member_name = canonical_by_key.get(canonical_member_key(raw_member_name))
+                if member_name is not None:
                    other_ledger[member_name].append({
                        "amount": per_allocation,
                        "date": tx["date"],
@@ -400,14 +416,20 @@ def reconcile(

        member_share = amount / len(matched_members) if matched_members else 0

-        for member_name, confidence in matched_members:
-            if member_name not in ledger:
+        for raw_member_name, confidence in matched_members:
+            member_name = canonical_by_key.get(canonical_member_key(raw_member_name))
+            if member_name is None:
                logger.warning(
                    "Payment matched to unknown member %r (tx: %s, %s) — adding to unmatched",
-                    member_name, tx.get("date", "?"), tx.get("message", "?"),
+                    raw_member_name, tx.get("date", "?"), tx.get("message", "?"),
                )
                unmatched.append(tx)
                continue
+            if member_name != raw_member_name:
+                logger.info(
+                    "Person cell %r resolved to canonical member %r — consider fixing the sheet",
+                    raw_member_name, member_name,
+                )

            in_window = [(m, ledger[member_name][m]["expected"]) for m in matched_months if m in ledger[member_name]]
            out_of_window = [m for m in matched_months if m not in ledger[member_name]]
--- a/templates/adults.html
+++ b/templates/adults.html
@@ -365,6 +365,19 @@
            border-bottom: 1px dashed #222;
        }

+        .raw-toggle {
+            color: #333;
+            font-size: 9px;
+            text-transform: lowercase;
+            margin-left: 8px;
+            text-decoration: none;
+            letter-spacing: 0;
+        }
+
+        .raw-toggle:hover {
+            color: #666;
+        }
+
        .modal-table {
            width: 100%;
            border-collapse: collapse;
@@ -680,6 +693,16 @@
                    <!-- Filled by JS -->
                </div>
            </div>
+
+            <div class="modal-section">
+                <div class="modal-section-title">
+                    Raw Payments
+                    <a href="#" id="rawPaymentsToggle" class="raw-toggle" onclick="toggleRawPayments(event)">[show]</a>
+                </div>
+                <div id="modalRawList" class="tx-list" style="display: none;">
+                    <!-- Filled by JS -->
+                </div>
+            </div>
        </div>
    </div>

@@ -696,6 +719,7 @@
        const memberData = {{ member_data| safe }};
        const sortedMonths = {{ raw_months| tojson }};
        const monthLabels = {{ month_labels_json| safe }};
+        const rawPaymentsByPerson = {{ raw_payments_json| safe }};
        let currentMemberName = null;

        function showMemberDetails(name) {
@@ -828,9 +852,49 @@
                });
            }

+            // Raw payments (debug) — hidden by default, reset toggle on each open
+            const rawList = document.getElementById('modalRawList');
+            const rawToggle = document.getElementById('rawPaymentsToggle');
+            rawList.style.display = 'none';
+            rawToggle.textContent = '[show]';
+            rawList.innerHTML = '';
+            const rawRows = rawPaymentsByPerson[name] || [];
+            if (rawRows.length === 0) {
+                rawList.innerHTML = '<div style="color: #444; font-style: italic; padding: 10px 0;">No raw payments tied to this member.</div>';
+            } else {
+                rawRows.forEach(tx => {
+                    const inferredNote = tx.inferred_amount && tx.inferred_amount !== '' && tx.inferred_amount != tx.amount
+                        ? ` <span style="color:#888;">(inferred: ${tx.inferred_amount})</span>`
+                        : '';
+                    const manualNote = tx.manual_fix ? ' <span style="color:#ffaa00;">[manual fix]</span>' : '';
+                    const bankIdNote = tx.bank_id ? `<span style="color:#444;"> · bank_id: ${tx.bank_id}</span>` : '';
+                    const item = document.createElement('div');
+                    item.className = 'tx-item';
+                    item.innerHTML = `
+                        <div class="tx-meta">${tx.date} | purpose: ${tx.purpose || '—'}${manualNote}</div>
+                        <div class="tx-main">
+                            <span class="tx-amount">${tx.amount} CZK${inferredNote}</span>
+                            <span class="tx-sender">${tx.sender || ''}</span>
+                        </div>
+                        <div class="tx-msg">${tx.message || ''}</div>
+                        <div class="tx-meta">${tx.person || ''}${bankIdNote}</div>
+                    `;
+                    rawList.appendChild(item);
+                });
+            }
+
            document.getElementById('memberModal').classList.add('active');
        }

+        function toggleRawPayments(ev) {
+            ev.preventDefault();
+            const list = document.getElementById('modalRawList');
+            const link = document.getElementById('rawPaymentsToggle');
+            const hidden = list.style.display === 'none';
+            list.style.display = hidden ? 'block' : 'none';
+            link.textContent = hidden ? '[hide]' : '[show]';
+        }
+
        function closeModal(id) {
            if (id) {
                document.getElementById(id).style.display = 'none';
--- a/templates/juniors.html
+++ b/templates/juniors.html
@@ -365,6 +365,19 @@
            border-bottom: 1px dashed #222;
        }

+        .raw-toggle {
+            color: #333;
+            font-size: 9px;
+            text-transform: lowercase;
+            margin-left: 8px;
+            text-decoration: none;
+            letter-spacing: 0;
+        }
+
+        .raw-toggle:hover {
+            color: #666;
+        }
+
        .modal-table {
            width: 100%;
            border-collapse: collapse;
@@ -661,6 +674,16 @@
                    <!-- Filled by JS -->
                </div>
            </div>
+
+            <div class="modal-section">
+                <div class="modal-section-title">
+                    Raw Payments
+                    <a href="#" id="rawPaymentsToggle" class="raw-toggle" onclick="toggleRawPayments(event)">[show]</a>
+                </div>
+                <div id="modalRawList" class="tx-list" style="display: none;">
+                    <!-- Filled by JS -->
+                </div>
+            </div>
        </div>
    </div>

@@ -677,6 +700,7 @@
        const memberData = {{ member_data| safe }};
        const sortedMonths = {{ raw_months| tojson }};
        const monthLabels = {{ month_labels_json| safe }};
+        const rawPaymentsByPerson = {{ raw_payments_json| safe }};
        let currentMemberName = null;

        function showMemberDetails(name) {
@@ -809,9 +833,49 @@
                });
            }

+            // Raw payments (debug) — hidden by default, reset toggle on each open
+            const rawList = document.getElementById('modalRawList');
+            const rawToggle = document.getElementById('rawPaymentsToggle');
+            rawList.style.display = 'none';
+            rawToggle.textContent = '[show]';
+            rawList.innerHTML = '';
+            const rawRows = rawPaymentsByPerson[name] || [];
+            if (rawRows.length === 0) {
+                rawList.innerHTML = '<div style="color: #444; font-style: italic; padding: 10px 0;">No raw payments tied to this member.</div>';
+            } else {
+                rawRows.forEach(tx => {
+                    const inferredNote = tx.inferred_amount && tx.inferred_amount !== '' && tx.inferred_amount != tx.amount
+                        ? ` <span style="color:#888;">(inferred: ${tx.inferred_amount})</span>`
+                        : '';
+                    const manualNote = tx.manual_fix ? ' <span style="color:#ffaa00;">[manual fix]</span>' : '';
+                    const bankIdNote = tx.bank_id ? `<span style="color:#444;"> · bank_id: ${tx.bank_id}</span>` : '';
+                    const item = document.createElement('div');
+                    item.className = 'tx-item';
+                    item.innerHTML = `
+                        <div class="tx-meta">${tx.date} | purpose: ${tx.purpose || '—'}${manualNote}</div>
+                        <div class="tx-main">
+                            <span class="tx-amount">${tx.amount} CZK${inferredNote}</span>
+                            <span class="tx-sender">${tx.sender || ''}</span>
+                        </div>
+                        <div class="tx-msg">${tx.message || ''}</div>
+                        <div class="tx-meta">${tx.person || ''}${bankIdNote}</div>
+                    `;
+                    rawList.appendChild(item);
+                });
+            }
+
            document.getElementById('memberModal').classList.add('active');
        }

+        function toggleRawPayments(ev) {
+            ev.preventDefault();
+            const list = document.getElementById('modalRawList');
+            const link = document.getElementById('rawPaymentsToggle');
+            const hidden = list.style.display === 'none';
+            list.style.display = hidden ? 'block' : 'none';
+            link.textContent = hidden ? '[hide]' : '[show]';
+        }
+
        function closeModal(id) {
            if (id) {
                document.getElementById(id).style.display = 'none';
--- a/tests/test_app.py
+++ b/tests/test_app.py
@@ -19,67 +19,6 @@ class TestWebApp(unittest.TestCase):
        self.assertEqual(response.status_code, 200)
        self.assertIn(b'url=/adults', response.data)

-    @patch('app.get_cached_data', side_effect=_bypass_cache)
-    @patch('app.get_members_with_fees')
-    @patch('app.fetch_exceptions', return_value={})
-    def test_fees_route(self, mock_exceptions, mock_get_members, mock_cache):
-        """Test that /fees returns 200 and renders the dashboard"""
-        mock_get_members.return_value = (
-            [('Test Member', 'A', {'2026-01': (750, 4)})],
-            ['2026-01']
-        )
-
-        response = self.client.get('/fees')
-        self.assertEqual(response.status_code, 200)
-        self.assertIn(b'FUJ Fees Dashboard', response.data)
-        self.assertIn(b'Test Member', response.data)
-
-    @patch('app.get_cached_data', side_effect=_bypass_cache)
-    @patch('app.get_junior_members_with_fees')
-    @patch('app.fetch_exceptions', return_value={})
-    def test_fees_juniors_route(self, mock_exceptions, mock_get_junior_members, mock_cache):
-        """Test that /fees-juniors returns 200 and renders the junior dashboard"""
-        mock_get_junior_members.return_value = (
-            [
-                ('Test Junior 1', 'J', {'2026-01': ('?', 1, 0, 1)}),
-                ('Test Junior 2', 'J', {'2026-01': (500, 4, 1, 3)})
-            ],
-            ['2026-01']
-        )
-
-        response = self.client.get('/fees-juniors')
-        self.assertEqual(response.status_code, 200)
-        self.assertIn(b'FUJ Junior Fees Dashboard', response.data)
-        self.assertIn(b'Test Junior 1', response.data)
-        self.assertIn(b'? / 1 (J)', response.data)
-        self.assertIn(b'500 CZK / 4 (1A+3J)', response.data)
-
-    @patch('app.get_cached_data', side_effect=_bypass_cache)
-    @patch('app.fetch_sheet_data')
-    @patch('app.fetch_exceptions', return_value={})
-    @patch('app.get_members_with_fees')
-    def test_reconcile_route(self, mock_get_members, mock_exceptions, mock_fetch_sheet, mock_cache):
-        """Test that /reconcile returns 200 and shows matches"""
-        mock_get_members.return_value = (
-            [('Test Member', 'A', {'2026-01': (750, 4)})],
-            ['2026-01']
-        )
-        mock_fetch_sheet.return_value = [{
-            'date': '2026-01-01',
-            'amount': 750,
-            'person': 'Test Member',
-            'purpose': '2026-01',
-            'message': 'test payment',
-            'sender': 'External Bank User',
-            'inferred_amount': 750
-        }]
-
-        response = self.client.get('/reconcile')
-        self.assertEqual(response.status_code, 200)
-        self.assertIn(b'Payment Reconciliation', response.data)
-        self.assertIn(b'Test Member', response.data)
-        self.assertIn(b'OK', response.data)
-
    @patch('app.get_cached_data', side_effect=_bypass_cache)
    @patch('app.fetch_sheet_data')
    def test_payments_route(self, mock_fetch_sheet, mock_cache):
@@ -98,38 +37,6 @@ class TestWebApp(unittest.TestCase):
        self.assertIn(b'Test Member', response.data)
        self.assertIn(b'Direct Member Payment', response.data)

-    @patch('app.get_cached_data', side_effect=_bypass_cache)
-    @patch('app.fetch_sheet_data')
-    @patch('app.fetch_exceptions')
-    @patch('app.get_junior_members_with_fees')
-    def test_reconcile_juniors_route(self, mock_get_junior, mock_exceptions, mock_transactions, mock_cache):
-        """Test that /reconcile-juniors correctly computes balances for juniors."""
-        mock_get_junior.return_value = (
-            [
-                ('Junior One', 'J', {'2026-01': (500, 4, 2, 2)}),
-                ('Junior Two', 'X', {'2026-01': ('?', 1, 0, 1)})
-            ],
-            ['2026-01']
-        )
-        mock_exceptions.return_value = {}
-        mock_transactions.return_value = [{
-            'date': '2026-01-15',
-            'amount': 500,
-            'person': 'Junior One',
-            'purpose': '2026-01',
-            'message': '',
-            'sender': 'Parent',
-            'inferred_amount': 500
-        }]
-
-        response = self.client.get('/reconcile-juniors')
-        self.assertEqual(response.status_code, 200)
-        self.assertIn(b'Junior Payment Reconciliation', response.data)
-        self.assertIn(b'Junior One', response.data)
-        self.assertIn(b'Junior Two', response.data)
-        self.assertIn(b'OK', response.data)
-        self.assertIn(b'?', response.data)
-
    @patch('app.get_cached_data', side_effect=_bypass_cache)
    @patch('app.fetch_sheet_data')
    @patch('app.fetch_exceptions', return_value={})
--- a/tests/test_match_payments.py
+++ b/tests/test_match_payments.py
@@ -0,0 +1,69 @@
+import unittest
+
+from scripts.match_payments import canonical_member_key, reconcile
+
+
+class TestCanonicalMemberKey(unittest.TestCase):
+    def test_diacritics_and_case_collapse(self):
+        self.assertEqual(canonical_member_key("Mária Maco"), "maria maco")
+        self.assertEqual(canonical_member_key("MARIA MACO"), "maria maco")
+        self.assertEqual(canonical_member_key("maria maco"), "maria maco")
+
+    def test_whitespace_runs_collapse(self):
+        self.assertEqual(canonical_member_key("Mária  Maco"), "maria maco")
+        self.assertEqual(canonical_member_key("  Mária Maco  "), "maria maco")
+
+    def test_unknown_name_passes_through_normalized(self):
+        # Two genuinely different names must not collide.
+        self.assertNotEqual(
+            canonical_member_key("Mária Maco"),
+            canonical_member_key("Marek Maco"),
+        )
+
+
+class TestReconcileTolerantPersonMatching(unittest.TestCase):
+    def _members(self):
+        return [("Mária Maco", "A", {"2026-04": (750, 4)})]
+
+    def _tx(self, person):
+        return {
+            "date": "2026-04-15",
+            "amount": 750,
+            "person": person,
+            "purpose": "2026-04",
+            "inferred_amount": 750,
+            "sender": "Maco Family",
+            "message": "fee",
+        }
+
+    def test_person_without_diacritics_matches(self):
+        result = reconcile(self._members(), ["2026-04"], [self._tx("Maria Maco")], {})
+
+        member = result["members"]["Mária Maco"]
+        self.assertEqual(member["months"]["2026-04"]["paid"], 750)
+        self.assertEqual(len(member["months"]["2026-04"]["transactions"]), 1)
+        self.assertEqual(result["unmatched"], [])
+
+    def test_person_with_extra_whitespace_matches(self):
+        result = reconcile(self._members(), ["2026-04"], [self._tx("Mária  Maco")], {})
+
+        self.assertEqual(result["members"]["Mária Maco"]["months"]["2026-04"]["paid"], 750)
+        self.assertEqual(result["unmatched"], [])
+
+    def test_person_lowercase_matches(self):
+        result = reconcile(self._members(), ["2026-04"], [self._tx("mária maco")], {})
+
+        self.assertEqual(result["members"]["Mária Maco"]["months"]["2026-04"]["paid"], 750)
+        self.assertEqual(result["unmatched"], [])
+
+    def test_truly_unknown_person_still_unmatched(self):
+        result = reconcile(
+            self._members(), ["2026-04"], [self._tx("Někdo Neznámý")], {}
+        )
+
+        self.assertEqual(result["members"]["Mária Maco"]["months"]["2026-04"]["paid"], 0)
+        self.assertEqual(len(result["unmatched"]), 1)
+
+
+if __name__ == "__main__":
+    unittest.main()