Merge pull request 'feat(go/M2.10): port domain/reconcile.Reconcile' (#10) from feat/m2-10-reconcile-domain into main

Reviewed-on: #10

CHANGELOG.md

@@ -1,5 +1,24 @@
 # Changelog
 
+## 2026-05-06 16:38 CEST — fix: include juniors in payment-inference roster
+
+- `scripts/infer_payments.py`: union adults + junior rosters so junior-only members are visible to the matcher.
+- Root cause: `get_members_with_fees()` reads only the adults sheet; junior-only kids like Jáchym Kubík were absent from `member_names`, causing the exact-match short-circuit to never fire and a different adult sharing the first name to win via fuzzy review.
+- Two regression tests added to `tests/test_match_members.py`.
+## 2026-05-06 16:05 CEST — feat(go/M2.10): port domain/reconcile.Reconcile
+
+- New `go/internal/domain/reconcile` package porting the three-phase payment allocation from `scripts/match_payments.py reconcile()`.
+- 12 unit tests covering all Python test cases plus Go-only extras (diacritics tolerance, `[?]` stripping, `other:` purpose, out-of-window credit, inference fallback, unmatched, no-transaction guard).
+
+## 2026-05-06 13:18 CEST — feat(go/M2.7-2.9): port domain/matching package
+
+- New `go/internal/domain/matching` package porting three helpers from `scripts/match_payments.py`.
+- `BuildNameVariants` — extracts normalized ASCII search variants from a member name, including nickname (from parens) and separate first/last; filters variants shorter than 3 chars; `variants[0]` is always the full normalized base name.
+- `MatchMembers` — finds members in free text with `"auto"` or `"review"` confidence; exact-name short-circuit prevents nickname substrings (e.g. `tov`) from matching inside surnames (e.g. `ottova`).
+- `FormatDate` — normalizes Google Sheets date values: handles nil, empty, int/float64 serial-days since 1899-12-30 (supports fractional serials), pre-formatted `YYYY-MM-DD` strings, and garbage input — never errors.
+- `InferTransactionDetails` — composes name + month matching over sender/message/user_id; falls back to sender-only member match and date-derived month when text gives no signal.
+- 21 table-driven tests; all expected values verified against live Python on 2026-05-06.
+
 ## 2026-05-06 12:43 CEST — feat(go/M2.6): port domain/synch.GenerateSyncID
 
 - New `go/internal/domain/synch` package with `GenerateSyncID(Transaction) string` ported from `scripts/sync_fio_to_sheets.py` `generate_sync_id`.

docs/plans/2026-05-03-2349-go-backend-rewrite-progress.md

@@ -50,10 +50,10 @@ Each task: port the function, write Go unit tests for fresh cases, hook into the
 - [x] **M2.4** `domain/fees.CalculateJuniorFee` — port `calculate_junior_fee` with `Expected{Value int; Unknown bool}` for the `"?"` sentinel — `0fc3b6d`
 - [x] **M2.5** `domain/money.ParseCZK` — port [infer_payments.py](scripts/infer_payments.py) `parse_czk_amount` (Czech locale: comma decimal, dot/space thousand separators) — `d24d205`
 - [x] **M2.6** `domain/synch.GenerateSyncID` — port [sync_fio_to_sheets.py](scripts/sync_fio_to_sheets.py) `generate_sync_id` (SHA-256, byte-stable hash; verify float string format against real sheet rows)
-- [ ] **M2.7** `domain/matching.BuildNameVariants` + `MatchMembers` — port `_build_name_variants` and `match_members` from [match_payments.py](scripts/match_payments.py) (auto vs review confidence, common-surname filter)
-- [ ] **M2.8** `domain/matching.InferTransactionDetails` — port `infer_transaction_details` (composes name + month parsing)
-- [ ] **M2.9** `domain/matching.FormatDate` — port `format_date` (handles Google Sheets serial-day numbers since 1899-12-30)
-- [ ] **M2.10** `domain/reconcile.Reconcile` — port `reconcile` (three-phase allocation: greedy / proportional with float-remainder absorption / even-split fallback). The single most load-bearing function; budget extra time.
+- [x] **M2.7** `domain/matching.BuildNameVariants` + `MatchMembers` — port `_build_name_variants` and `match_members` from [match_payments.py](scripts/match_payments.py) (auto vs review confidence, common-surname filter) — `e596f00`
+- [x] **M2.8** `domain/matching.InferTransactionDetails` — port `infer_transaction_details` (composes name + month parsing) — `e596f00`
+- [x] **M2.9** `domain/matching.FormatDate` — port `format_date` (handles Google Sheets serial-day numbers since 1899-12-30) — `e596f00`
+- [x] **M2.10** `domain/reconcile.Reconcile` — port `reconcile` (three-phase allocation: greedy / proportional with float-remainder absorption / even-split fallback). The single most load-bearing function; budget extra time. — `c53bf5a`
 - [ ] **M2.11** `fuj fees` subcommand wired up via `domain/fees` + (M4-stub) attendance loader — fail gracefully on missing IO until M4 lands
 - [ ] **M2.12** `fuj reconcile` subcommand similarly stubbed
 

docs/plans/2026-05-06-1305-go-m2-7-2-9-matching.md

@@ -0,0 +1,126 @@
+# M2.7 + M2.8 + M2.9 — Port `matching` package to Go
+
+> On approval: copy this plan to `docs/plans/2026-05-06-1305-go-m2-7-2-9-matching.md` per [CLAUDE.md](../../srv/personal/fuj-management/CLAUDE.md) plan-location convention.
+
+## Context
+
+The Go rewrite (tracked in [docs/plans/2026-05-03-2349-go-backend-rewrite-progress.md](../../srv/personal/fuj-management/docs/plans/2026-05-03-2349-go-backend-rewrite-progress.md)) is in milestone M2 — porting pure-domain helpers leaf-first from Python to Go. M2.1 through M2.6 are complete (`czech.Normalize`, `czech.ParseMonthReferences`, `fees.CalculateFee`, `fees.CalculateJuniorFee`, `money.ParseCZK`, `synch.GenerateSyncID`).
+
+M2.7, M2.8, and M2.9 cover three helpers from [scripts/match_payments.py](../../srv/personal/fuj-management/scripts/match_payments.py) that form a tight chain: `InferTransactionDetails` calls `MatchMembers` which calls `BuildNameVariants` and the same Sheets-serial date logic that `FormatDate` uses. The user requested they be done together because the dependency graph makes per-milestone commits awkward — `MatchMembers` would either reference an unexported helper not yet committed or commit dead code.
+
+This unblocks M2.10 (`reconcile`, the load-bearing function) and M5 parity tests, since reconciliation consumes `InferTransactionDetails` output.
+
+## Approach
+
+**One commit, one branch, one MR.** Branch: `feat/m2-7-2-9-matching-package`. The three milestone checkboxes get ticked together on merge.
+
+### Package layout
+
+New package `go/internal/domain/matching/` mirroring the existing `go/internal/domain/{czech,fees,money,synch}` convention (one file per public symbol, tests alongside as `*_test.go`):
+
+| File | Contents |
+|---|---|
+| `doc.go` | `// Package matching ports name/member matching from scripts/match_payments.py.` |
+| `name_variants.go` | `BuildNameVariants` + unexported `wordIn` helper (mirrors Python's `_word_in` co-location at [match_payments.py:60-62](../../srv/personal/fuj-management/scripts/match_payments.py#L60)) |
+| `match_members.go` | `Confidence` typed string + constants, `Match` struct, `MatchMembers` |
+| `infer.go` | `Transaction`, `InferredDetails`, `InferTransactionDetails` |
+| `format_date.go` | `FormatDate` |
+| `name_variants_test.go`, `match_members_test.go`, `infer_test.go`, `format_date_test.go` | table-driven tests, each with a top-of-file comment quoting the live Python one-liner used to verify expected values (mirrors [synch_test.go:7-20](../../srv/personal/fuj-management/go/internal/domain/synch/synch_test.go#L7)) |
+
+### Public API
+
+```go
+type Confidence string
+const (
+    ConfidenceAuto   Confidence = "auto"
+    ConfidenceReview Confidence = "review"
+)
+type Match struct {
+    Name       string
+    Confidence Confidence
+}
+
+func BuildNameVariants(name string) []string
+func MatchMembers(text string, memberNames []string) []Match
+
+type Transaction struct {
+    Sender  string
+    Message string
+    UserID  string
+    Date    any // string | int | float64 — see "Parity concerns"
+}
+type InferredDetails struct {
+    Members    []Match
+    Months     []string
+    SearchText string // matches Python's "search_text" key, not the misleading "matched_text" docstring
+}
+func InferTransactionDetails(tx Transaction, memberNames []string, defaultYear int) InferredDetails
+
+func FormatDate(val any) string
+```
+
+### Algorithms (port verbatim — these are the load-bearing details)
+
+**`BuildNameVariants`** ([match_payments.py:33-57](../../srv/personal/fuj-management/scripts/match_payments.py#L33)): extract `(nickname)` regex, strip parens for `base`, normalize via `czech.Normalize`, append last + first when ≥2 parts, **filter <3 chars**. `variants[0]` must always be the full normalized base — `MatchMembers` relies on this.
+
+**`MatchMembers`** ([match_payments.py:65-137](../../srv/personal/fuj-management/scripts/match_payments.py#L65)):
+1. **Exact short-circuit** ([:77-84](../../srv/personal/fuj-management/scripts/match_payments.py#L77)): if any member's `variants[0]` whole-word matches in `Normalize(text)`, return ONLY those `(name, auto)`. Prevents nickname `tov` matching inside `ottova`.
+2. Otherwise per-member first-match-wins: full-name substring → `\b first \b` AND `\b last \b` (any order) → `\b nickname \b` — each yields `auto` and continues.
+3. **Review tier** ([:113-129](../../srv/personal/fuj-management/scripts/match_payments.py#L113)): ≥2-part names → last name `len ≥ 4` AND not in `{"novak","novakova","prach"}` → review; else first name `len ≥ 3` → review. 1-part names → `len ≥ 4` → review.
+4. **Final filter** ([:131-137](../../srv/personal/fuj-management/scripts/match_payments.py#L131)): if ANY auto exists, drop ALL review. Two-pass — don't try to fuse with the loop.
+
+**`InferTransactionDetails`** ([match_payments.py:144-184](../../srv/personal/fuj-management/scripts/match_payments.py#L144)): `search_text = sender + " " + message + " " + user_id`; month parse uses `message + " " + user_id` (excludes sender); fallback 1 retries members on sender alone; fallback 2 derives months from `tx.Date` (Sheets serial or `YYYY-MM-DD`).
+
+**`FormatDate`** ([match_payments.py:187-206](../../srv/personal/fuj-management/scripts/match_payments.py#L187)): nil/empty → `""`; int/float → Sheets serial since 1899-12-30 formatted `YYYY-MM-DD`; pre-formatted `YYYY-MM-DD` (length 10, dashes at idx 4/7) → as-is; else `strings.TrimSpace(fmt.Sprint(v))`. **No raise on bad input** — parity contract.
+
+## Parity concerns
+
+- **RE2 `\b`**: Equivalent to Python `\b` on ASCII-folded input (`Normalize` strips diacritics + lowercases). Use `regexp.QuoteMeta` for `re.escape`.
+- **Sheets epoch**: 1899-12-30 (NOT 1900-01-01). `time.Date(1899, 12, 30, 0, 0, 0, 0, time.UTC)`.
+- **Fractional serials**: Python `timedelta(days=44197.5)` adds 12 hours, then `.strftime("%Y-%m-%d")` discards time. To match exactly use `base.Add(time.Duration(val * 24 * float64(time.Hour)))` then `Format("2006-01-02")`. **Do NOT** use `base.AddDate(0, 0, int(val))` — that silently drops fractional days from real Sheets exports of timestamped cells.
+- **`Transaction.Date any`**: Python `tx["date"]` accepts int/float/string transparently. Sheets API returns serial dates as `float64` from JSON; FIO scraper returns `string`. `any` is the faithful port; type-switch inside `FormatDate` and the date fallback in `InferTransactionDetails`.
+- **`SearchText` vs `MatchedText`**: Python docstring says `matched_text`, code returns `"search_text"`. Port the code, not the docstring.
+- **Default year plumbing**: Go's `czech.ParseMonthReferences(text, defaultYear)` requires explicit year. Python defaults to 2026. Plumb `defaultYear` as the third arg to `InferTransactionDetails`.
+- **Empty slices not nil**: Python `match_members` returns `[]` when nothing matches; ensure Go returns `[]Match{}` not `nil` so consumers don't have to nil-check (matches `synch` package style).
+
+## Tests
+
+Port all 6 cases from [tests/test_match_members.py](../../srv/personal/fuj-management/tests/test_match_members.py) verbatim into `match_members_test.go` as one table-driven `TestMatchMembers`. Each row: `name`, `text`, `wantContains []string`, `wantExcludes []string`, `wantAllAuto bool`.
+
+Add table cases for:
+- `BuildNameVariants` — docstring example `František Vrbík (Štrúdl)` → 4 variants; nickname filtered (len<3); single-part name; whitespace inside parens
+- `FormatDate` — `nil` → `""`, `""` → `""`, `int(44197)` → `"2020-12-31"`, `float64(44197.5)` → `"2020-12-31"`, `"2026-04-15"` → `"2026-04-15"`, `"garbage"` → `"garbage"`, `"  2026-04-15  "` → `"2026-04-15"`
+- `InferTransactionDetails` — members from search_text, members from sender fallback, months from date-string fallback, months from serial-date fallback, both-paths-fail returns empty slices
+
+Verify expectations against live Python and quote the one-liner in a top-of-file comment, e.g.:
+
+```
+PYTHONPATH=scripts:. python -c '
+from match_payments import format_date
+for v in [None, "", 44197, 44197.5, "2026-04-15", "garbage", "  2026-04-15  "]: print(repr(format_date(v)))
+'
+```
+
+## Critical files
+
+- **Read for parity** — [scripts/match_payments.py:33-206](../../srv/personal/fuj-management/scripts/match_payments.py#L33), [tests/test_match_members.py](../../srv/personal/fuj-management/tests/test_match_members.py)
+- **Reuse** — `czech.Normalize` ([go/internal/domain/czech/normalize.go](../../srv/personal/fuj-management/go/internal/domain/czech/normalize.go#L15)), `czech.ParseMonthReferences` ([parse_month_references.go:61](../../srv/personal/fuj-management/go/internal/domain/czech/parse_month_references.go#L61))
+- **Mirror conventions** — [go/internal/domain/synch/synch.go](../../srv/personal/fuj-management/go/internal/domain/synch/synch.go), [go/internal/domain/synch/synch_test.go](../../srv/personal/fuj-management/go/internal/domain/synch/synch_test.go)
+- **New** — `go/internal/domain/matching/{doc,name_variants,match_members,infer,format_date}.go` + `*_test.go`
+
+## Out of scope (M2.10 / M4 territory — DO NOT touch)
+
+- `canonical_member_key` ([match_payments.py:20](../../srv/personal/fuj-management/scripts/match_payments.py#L20))
+- `reconcile`, `fetch_sheet_data`, `fetch_exceptions` — M2.10 / M4
+- Sheets/Drive/FIO I/O glue
+- Fixture capture (`tests/fixtures/pure/`) — M3.3 separately
+
+## Verification
+
+1. `cd go && make go-build` — clean build.
+2. `cd go && make go-test ./internal/domain/matching/...` — all table tests green.
+3. `cd go && make go-lint` — clean (govet, staticcheck, errcheck, gofumpt, unused).
+4. Spot-check: pick 2–3 random non-trivial cases (e.g. `MatchMembers` with mixed auto/review, `FormatDate(44197.5)`) and run the live Python one-liner from each test's comment block to confirm bytes match.
+5. Append CHANGELOG entry per [CLAUDE.md](../../srv/personal/fuj-management/CLAUDE.md) (timestamp via `date "+%Y-%m-%d %H:%M %Z"`).
+6. Tick M2.7, M2.8, M2.9 in [docs/plans/2026-05-03-2349-go-backend-rewrite-progress.md](../../srv/personal/fuj-management/docs/plans/2026-05-03-2349-go-backend-rewrite-progress.md) with the merge SHA.
+7. Push branch, open MR via `tea pr create --title "feat(go): port matching helpers (M2.7-2.9)" --base main --head feat/m2-7-2-9-matching-package`, print URL, leave merge to user.

docs/plans/2026-05-06-1626-infer-payments-junior-roster.md

@@ -0,0 +1,129 @@
+# Include junior members in payment inference roster
+
+## Context
+
+A bank payment from sender `JIŘÍ KUBÍK` with the message
+`Jáchym Kubík: 01/2026+03/2026+04/2026` is being inferred as
+`[?] Jáchym Hrušák (G)` instead of the obvious `Jáchym Kubík`, even though
+the message contains his exact full name.
+
+**Root cause** (confirmed with the user): `Jáchym Kubík` is in the **junior**
+attendance sheet only — he does not appear on the main/adults sheet. But
+[scripts/infer_payments.py:101-102](scripts/infer_payments.py#L101-L102)
+builds `member_names` by calling `get_members_with_fees()`
+([scripts/attendance.py:170](scripts/attendance.py#L170)), which reads only
+`EXPORT_URL` (the adults sheet). Junior-only members are therefore invisible
+to the matcher.
+
+With Kubík absent from `member_names`, the matcher in
+[scripts/match_payments.py:65](scripts/match_payments.py#L65) processes the
+combined text `jiri kubik jachym kubik: 01/2026+03/2026+04/2026` against an
+adults-only roster:
+
+- The exact-full-name short-circuit (`match_payments.py:75-84`) finds nothing —
+  no adult's full name is in the text.
+- Hrušák `(G)` is the only adult with first name `Jáchym`. He fails the
+  auto-rules (his surname isn't in the text) but hits the partial-first-name
+  review rule (`match_payments.py:123-125`) → returned as `("Jáchym Hrušák (G)",
+  "review")`, rendered as `[?] Jáchym Hrušák (G)`.
+
+The user's original framing — "exact match in message should win over
+everything" — is already implemented for any candidate that **is** in the
+roster (the May-04 short-circuit). The bug is upstream: the right candidate
+was never even considered.
+
+**Goal:** make `infer_payments` consider junior members as candidates, so
+junior-only names like `Jáchym Kubík` get matched correctly.
+
+## Approach
+
+Single-file change in [scripts/infer_payments.py](scripts/infer_payments.py).
+
+Replace the adults-only roster lookup with a union of the adult and junior
+rosters. `attendance.py` already exposes both:
+[`get_members_with_fees()`](scripts/attendance.py#L170) for adults (and tier-J
+juniors who train with adults) and
+[`get_junior_members_with_fees()`](scripts/attendance.py#L208) for everyone in
+the junior sheet.
+
+### Edit at [scripts/infer_payments.py:15](scripts/infer_payments.py#L15)
+
+```python
+from attendance import get_members_with_fees, get_junior_members_with_fees
+```
+
+### Edit at [scripts/infer_payments.py:99-102](scripts/infer_payments.py#L99-L102)
+
+```python
+print("Fetching member list for matching...")
+adult_members, _ = get_members_with_fees()
+junior_members, _ = get_junior_members_with_fees()
+
+# Union rosters, preserving first-seen order, deduping by canonical key
+seen: set[str] = set()
+member_names: list[str] = []
+for m in adult_members + junior_members:
+    name = m[0]
+    key = canonical_member_key(name)
+    if key in seen:
+        continue
+    seen.add(key)
+    member_names.append(name)
+```
+
+`canonical_member_key` already lives in
+[scripts/match_payments.py:20](scripts/match_payments.py#L20) — import it
+alongside `infer_transaction_details`. It normalizes diacritics/case/whitespace,
+so `"Maria Maco"` and `"Mária Maco"` collapse to the same key.
+
+### Why downstream reconciliation still works
+
+`reconcile()` is invoked twice per page — once with the adults roster
+([app.py:200](app.py#L200)) and once with the juniors roster
+([app.py:384](app.py#L384)). Each call resolves the `Person` cell against its
+own roster; a junior name resolves cleanly in the juniors call and lands in
+"unmatched" in the adults call. That's already the existing behavior for any
+junior payment manually entered into the `Person` column, so no further
+changes are needed.
+
+### Files to modify
+
+- [scripts/infer_payments.py](scripts/infer_payments.py) — only the
+  import + roster construction. ~10-line change.
+
+### Files to read for confidence (no edits)
+
+- [scripts/attendance.py:208-289](scripts/attendance.py#L208-L289) —
+  `get_junior_members_with_fees` returns `(name, tier, …)` tuples just like
+  the adults version, so `m[0]` works for both.
+- [scripts/match_payments.py:65-137](scripts/match_payments.py#L65-L137) —
+  `match_members` already handles the precedence the user wants (exact full-name
+  short-circuit), so once Kubík is in `member_names`, the case will be auto-matched
+  with no `[?]`.
+
+## Verification
+
+1. **Manual sanity** — re-run inference on the offending row:
+   - Clear `Person`/`Purpose` for the Kubík row in the payments sheet.
+   - `make infer`.
+   - Expect `Person = Jáchym Kubík`, `Purpose = 2026-01, 2026-03, 2026-04`,
+     no `[?]`.
+
+2. **Unit test** — extend
+   [tests/test_match_members.py](tests/test_match_members.py) (or add a small
+   `tests/test_infer_payments.py`) to assert that, given a roster that
+   includes `Jáchym Hrušák (G)` and `Jáchym Kubík`, the message
+   `Jáchym Kubík: 01/2026+03/2026+04/2026` resolves to
+   `[("Jáchym Kubík", "auto")]` only. This is really a regression test for
+   the May-04 short-circuit — the new behavior under test is just that
+   `infer_payments` now feeds in juniors.
+
+3. **Run the suite**: `make test`.
+
+4. **Dashboard smoke** — `make web`, open `/payments`, confirm the row now
+   shows the correct member; open `/juniors`, confirm the payment is
+   credited to Kubík for the three months listed.
+
+5. **Changelog** — once the user confirms the fix, append an entry to
+   [CHANGELOG.md](CHANGELOG.md) per [CLAUDE.md](CLAUDE.md):
+   `## YYYY-MM-DD HH:MM TZ — fix: include juniors in payment-inference roster`.

go/internal/domain/matching/doc.go

@@ -0,0 +1,2 @@
+// Package matching ports name/member matching from scripts/match_payments.py.
+package matching

go/internal/domain/matching/format_date.go

@@ -0,0 +1,41 @@
+package matching
+
+import (
+	"fmt"
+	"strings"
+	"time"
+)
+
+var sheetsEpoch = time.Date(1899, 12, 30, 0, 0, 0, 0, time.UTC)
+
+// FormatDate normalizes a date value from Google Sheets.
+//
+// Accepts nil, empty string, int/float64 Sheets serial days since 1899-12-30,
+// a pre-formatted "YYYY-MM-DD" string (returned as-is), or any other value
+// (returned as fmt.Sprint(v).TrimSpace). Never returns an error.
+//
+// Ports scripts/match_payments.py format_date.
+func FormatDate(val any) string {
+	if val == nil {
+		return ""
+	}
+	switch v := val.(type) {
+	case int:
+		return sheetsEpoch.Add(time.Duration(float64(v) * 24 * float64(time.Hour))).Format("2006-01-02")
+	case int64:
+		return sheetsEpoch.Add(time.Duration(float64(v) * 24 * float64(time.Hour))).Format("2006-01-02")
+	case float64:
+		return sheetsEpoch.Add(time.Duration(v * 24 * float64(time.Hour))).Format("2006-01-02")
+	case string:
+		s := strings.TrimSpace(v)
+		if s == "" {
+			return ""
+		}
+		if len(s) == 10 && s[4] == '-' && s[7] == '-' {
+			return s
+		}
+		return s
+	default:
+		return strings.TrimSpace(fmt.Sprint(v))
+	}
+}

go/internal/domain/matching/format_date_test.go

@@ -0,0 +1,49 @@
+package matching
+
+// Expected values verified against scripts/match_payments.py on 2026-05-06:
+//
+//	PYTHONPATH=scripts:. python3 -c '
+//	from match_payments import format_date
+//	for v in [None, "", 44197, 44197.5, "2026-04-15", "garbage", "  2026-04-15  "]:
+//	    print(repr(format_date(v)))
+//	'
+//
+// Output:
+//
+//	''
+//	''
+//	'2021-01-01'
+//	'2021-01-01'
+//	'2026-04-15'
+//	'garbage'
+//	'2026-04-15'
+
+import "testing"
+
+func TestFormatDate(t *testing.T) {
+	t.Parallel()
+
+	cases := []struct {
+		name  string
+		input any
+		want  string
+	}{
+		{name: "nil", input: nil, want: ""},
+		{name: "empty string", input: "", want: ""},
+		{name: "serial int", input: int(44197), want: "2021-01-01"},
+		{name: "serial float fractional", input: float64(44197.5), want: "2021-01-01"},
+		{name: "already formatted", input: "2026-04-15", want: "2026-04-15"},
+		{name: "garbage string", input: "garbage", want: "garbage"},
+		{name: "padded date string trimmed", input: "  2026-04-15  ", want: "2026-04-15"},
+	}
+
+	for _, tc := range cases {
+		t.Run(tc.name, func(t *testing.T) {
+			t.Parallel()
+			got := FormatDate(tc.input)
+			if got != tc.want {
+				t.Errorf("FormatDate(%v) = %q, want %q", tc.input, got, tc.want)
+			}
+		})
+	}
+}

go/internal/domain/matching/infer.go

@@ -0,0 +1,89 @@
+package matching
+
+import (
+	"fmt"
+	"fuj-management/go/internal/domain/czech"
+	"time"
+)
+
+// Transaction is the subset of a payment row used by InferTransactionDetails.
+// Date accepts string ("YYYY-MM-DD"), float64 (Sheets serial), or int — matching
+// the heterogeneous types returned by the Sheets API and the FIO scraper.
+type Transaction struct {
+	Sender  string
+	Message string
+	UserID  string
+	Date    any
+}
+
+// InferredDetails is the result of InferTransactionDetails.
+type InferredDetails struct {
+	Members    []Match
+	Months     []string
+	SearchText string
+}
+
+// InferTransactionDetails infers which member(s) and month(s) a transaction belongs to.
+//
+// Search text for member matching: sender + message + user_id.
+// Month search text: message + user_id only (sender excluded, matching Python).
+// Fallback 1: if no members found, retry match on sender alone.
+// Fallback 2: if no months found, derive from tx.Date (Sheets serial or YYYY-MM-DD).
+//
+// defaultYear seeds czech.ParseMonthReferences (Python defaulted to the current year;
+// callers should pass time.Now().Year() or a fixed year for deterministic tests).
+//
+// Ports scripts/match_payments.py infer_transaction_details.
+func InferTransactionDetails(tx Transaction, memberNames []string, defaultYear int) InferredDetails {
+	searchText := fmt.Sprintf("%s %s %s", tx.Sender, tx.Message, tx.UserID)
+
+	members := MatchMembers(searchText, memberNames)
+	months := czech.ParseMonthReferences(tx.Message+" "+tx.UserID, defaultYear)
+
+	if len(members) == 0 {
+		members = MatchMembers(tx.Sender, memberNames)
+	}
+
+	if len(months) == 0 && tx.Date != nil && tx.Date != "" {
+		if ym := inferMonthFromDate(tx.Date); ym != "" {
+			months = []string{ym}
+		}
+	}
+
+	if months == nil {
+		months = []string{}
+	}
+
+	return InferredDetails{
+		Members:    members,
+		Months:     months,
+		SearchText: searchText,
+	}
+}
+
+// inferMonthFromDate converts a date value to "YYYY-MM" for the month fallback.
+// Returns "" on any error, matching Python's bare except pass.
+func inferMonthFromDate(val any) string {
+	switch v := val.(type) {
+	case int:
+		dt := sheetsEpoch.Add(time.Duration(float64(v) * 24 * float64(time.Hour)))
+		return dt.Format("2006-01")
+	case int64:
+		dt := sheetsEpoch.Add(time.Duration(float64(v) * 24 * float64(time.Hour)))
+		return dt.Format("2006-01")
+	case float64:
+		dt := sheetsEpoch.Add(time.Duration(v * 24 * float64(time.Hour)))
+		return dt.Format("2006-01")
+	case string:
+		if v == "" {
+			return ""
+		}
+		dt, err := time.Parse("2006-01-02", v)
+		if err != nil {
+			return ""
+		}
+		return dt.Format("2006-01")
+	default:
+		return ""
+	}
+}

go/internal/domain/matching/infer_test.go

@@ -0,0 +1,108 @@
+package matching
+
+// Expected values verified against scripts/match_payments.py on 2026-05-06:
+//
+//	PYTHONPATH=scripts:. python3 << 'EOF'
+//	from match_payments import infer_transaction_details
+//	MEMBERS = ["Tomáš Němeček (Tov)", "Jana Nováková"]
+//	cases = [
+//	    ({"sender":"Tomas Nemecek","message":"clenske 04/2026","user_id":"","date":"2026-04-15"}, "full match"),
+//	    ({"sender":"Tomas Nemecek","message":"","user_id":"","date":"2026-04-15"}, "sender fallback month"),
+//	    ({"sender":"Jana Novakova","message":"","user_id":"","date":44197}, "serial int date"),
+//	    ({"sender":"neznamy","message":"","user_id":"","date":""}, "no match"),
+//	    ({"sender":"Tomas Nemecek","message":"","user_id":"","date":44197.5}, "serial float date"),
+//	]
+//	for tx, label in cases:
+//	    r = infer_transaction_details(tx, MEMBERS)
+//	    print(label + ": members=" + repr(r["members"]) + " months=" + repr(r["months"]) + " search_text=" + repr(r["search_text"]))
+//	EOF
+//
+// Output:
+//
+//	full match: members=[('Tomáš Němeček (Tov)', 'auto')] months=['2026-04'] search_text='Tomas Nemecek clenske 04/2026 '
+//	sender fallback month: members=[('Tomáš Němeček (Tov)', 'auto')] months=['2026-04'] search_text='Tomas Nemecek  '
+//	serial int date: members=[('Jana Nováková', 'auto')] months=['2021-01'] search_text='Jana Novakova  '
+//	no match: members=[] months=[] search_text='neznamy  '
+//	serial float date: members=[('Tomáš Němeček (Tov)', 'auto')] months=['2021-01'] search_text='Tomas Nemecek  '
+
+import (
+	"reflect"
+	"testing"
+)
+
+var inferMembers = []string{"Tomáš Němeček (Tov)", "Jana Nováková"}
+
+func TestInferTransactionDetails(t *testing.T) {
+	t.Parallel()
+
+	cases := []struct {
+		name           string
+		tx             Transaction
+		defaultYear    int
+		wantMembers    []Match
+		wantMonths     []string
+		wantSearchText string
+	}{
+		{
+			name:        "full match — members and months from search text",
+			tx:          Transaction{Sender: "Tomas Nemecek", Message: "clenske 04/2026", UserID: "", Date: "2026-04-15"},
+			defaultYear: 2026,
+			wantMembers: []Match{{Name: "Tomáš Němeček (Tov)", Confidence: ConfidenceAuto}},
+			wantMonths:  []string{"2026-04"},
+			// Python: sender + " " + message + " " + user_id (no trim)
+			wantSearchText: "Tomas Nemecek clenske 04/2026 ",
+		},
+		{
+			// months not in message → fall back to date string
+			name:           "months fall back to date string",
+			tx:             Transaction{Sender: "Tomas Nemecek", Message: "", UserID: "", Date: "2026-04-15"},
+			defaultYear:    2026,
+			wantMembers:    []Match{{Name: "Tomáš Němeček (Tov)", Confidence: ConfidenceAuto}},
+			wantMonths:     []string{"2026-04"},
+			wantSearchText: "Tomas Nemecek  ",
+		},
+		{
+			// months fall back to Sheets serial int date
+			name:           "months fall back to serial int date",
+			tx:             Transaction{Sender: "Jana Novakova", Message: "", UserID: "", Date: int(44197)},
+			defaultYear:    2026,
+			wantMembers:    []Match{{Name: "Jana Nováková", Confidence: ConfidenceAuto}},
+			wantMonths:     []string{"2021-01"},
+			wantSearchText: "Jana Novakova  ",
+		},
+		{
+			// months fall back to Sheets serial float64 date
+			name:           "months fall back to serial float date",
+			tx:             Transaction{Sender: "Tomas Nemecek", Message: "", UserID: "", Date: float64(44197.5)},
+			defaultYear:    2026,
+			wantMembers:    []Match{{Name: "Tomáš Němeček (Tov)", Confidence: ConfidenceAuto}},
+			wantMonths:     []string{"2021-01"},
+			wantSearchText: "Tomas Nemecek  ",
+		},
+		{
+			name:           "no match — both slices empty not nil",
+			tx:             Transaction{Sender: "neznamy", Message: "", UserID: "", Date: ""},
+			defaultYear:    2026,
+			wantMembers:    []Match{},
+			wantMonths:     []string{},
+			wantSearchText: "neznamy  ",
+		},
+	}
+
+	for _, tc := range cases {
+		t.Run(tc.name, func(t *testing.T) {
+			t.Parallel()
+			got := InferTransactionDetails(tc.tx, inferMembers, tc.defaultYear)
+
+			if !reflect.DeepEqual(got.Members, tc.wantMembers) {
+				t.Errorf("Members\n got  %v\n want %v", got.Members, tc.wantMembers)
+			}
+			if !reflect.DeepEqual(got.Months, tc.wantMonths) {
+				t.Errorf("Months\n got  %v\n want %v", got.Months, tc.wantMonths)
+			}
+			if got.SearchText != tc.wantSearchText {
+				t.Errorf("SearchText\n got  %q\n want %q", got.SearchText, tc.wantSearchText)
+			}
+		})
+	}
+}

go/internal/domain/matching/match_members.go

@@ -0,0 +1,131 @@
+package matching
+
+import (
+	"fuj-management/go/internal/domain/czech"
+	"strings"
+)
+
+// Confidence indicates how certain a member match is.
+type Confidence string
+
+const (
+	ConfidenceAuto   Confidence = "auto"
+	ConfidenceReview Confidence = "review"
+)
+
+// Match pairs a canonical member name with the confidence of the match.
+type Match struct {
+	Name       string
+	Confidence Confidence
+}
+
+var commonSurnames = map[string]bool{
+	"novak":    true,
+	"novakova": true,
+	"prach":    true,
+}
+
+// MatchMembers finds members mentioned in text and returns them with a
+// confidence level of "auto" (reliable) or "review" (needs human verification).
+//
+// Algorithm (ported verbatim from scripts/match_payments.py match_members):
+//  1. Exact short-circuit: if any member's full normalized name appears as whole
+//     words in normalize(text), return ONLY those matches as auto. This prevents
+//     nickname "tov" from matching inside surname "ottova".
+//  2. Per-member first-match-wins: full-name substring → first+last both present
+//     (any order) → nickname whole-word. Each yields auto.
+//  3. Review tier: last name (len≥4, not a common surname) → first name (len≥3)
+//     → single-part name (len≥4). Each yields review.
+//  4. Final filter: if any auto exists, drop all review.
+func MatchMembers(text string, memberNames []string) []Match {
+	normalizedText := czech.Normalize(text)
+
+	// Pass 1: exact short-circuit
+	var exactMatches []Match
+	for _, name := range memberNames {
+		variants := BuildNameVariants(name)
+		if len(variants) == 0 {
+			continue
+		}
+		fullName := variants[0]
+		if fullName != "" && wordIn(fullName, normalizedText) {
+			exactMatches = append(exactMatches, Match{Name: name, Confidence: ConfidenceAuto})
+		}
+	}
+	if len(exactMatches) > 0 {
+		return exactMatches
+	}
+
+	// Pass 2 + 3: fuzzy matching
+	var matches []Match
+	for _, name := range memberNames {
+		variants := BuildNameVariants(name)
+		fullName := ""
+		if len(variants) > 0 {
+			fullName = variants[0]
+		}
+		parts := strings.Fields(fullName)
+
+		// Auto tier
+		if fullName != "" && strings.Contains(normalizedText, fullName) {
+			matches = append(matches, Match{Name: name, Confidence: ConfidenceAuto})
+			continue
+		}
+		if len(parts) >= 2 {
+			if wordIn(parts[0], normalizedText) && wordIn(parts[len(parts)-1], normalizedText) {
+				matches = append(matches, Match{Name: name, Confidence: ConfidenceAuto})
+				continue
+			}
+		}
+		// Nickname check
+		if m := nicknameRe.FindStringSubmatch(name); m != nil {
+			nick := czech.Normalize(m[1])
+			if nick != "" && wordIn(nick, normalizedText) {
+				matches = append(matches, Match{Name: name, Confidence: ConfidenceAuto})
+				continue
+			}
+		}
+
+		// Review tier
+		if len(parts) >= 2 {
+			lastName := parts[len(parts)-1]
+			firstName := parts[0]
+			if len(lastName) >= 4 && !commonSurnames[lastName] && wordIn(lastName, normalizedText) {
+				matches = append(matches, Match{Name: name, Confidence: ConfidenceReview})
+				continue
+			}
+			if len(firstName) >= 3 && wordIn(firstName, normalizedText) {
+				matches = append(matches, Match{Name: name, Confidence: ConfidenceReview})
+				continue
+			}
+		} else if len(parts) == 1 {
+			if len(parts[0]) >= 4 && wordIn(parts[0], normalizedText) {
+				matches = append(matches, Match{Name: name, Confidence: ConfidenceReview})
+				continue
+			}
+		}
+	}
+
+	// Final filter: drop review if any auto exists
+	hasAuto := false
+	for _, m := range matches {
+		if m.Confidence == ConfidenceAuto {
+			hasAuto = true
+			break
+		}
+	}
+	if hasAuto {
+		filtered := matches[:0]
+		for _, m := range matches {
+			if m.Confidence == ConfidenceAuto {
+				filtered = append(filtered, m)
+			}
+		}
+		return filtered
+	}
+
+	if matches == nil {
+		return []Match{}
+	}
+	return matches
+}

go/internal/domain/matching/match_members_test.go

@@ -0,0 +1,156 @@
+package matching
+
+// Expected values verified against scripts/match_payments.py and
+// tests/test_match_members.py on 2026-05-06:
+//
+//	PYTHONPATH=scripts:. python3 -c '
+//	from match_payments import match_members
+//	MEMBERS = ["Henrietta Ottová", "Tomáš Němeček (Tov)", "František Vrbík (Štrúdl)", "Jana Nováková"]
+//	cases = [
+//	    ("Henrietta Ottová (Heny): 04/2026", "full name guard"),
+//	    ("platba ottova 04/2026", "ottova surname"),
+//	    ("Henrietta Ottová a Tomáš Němeček 04/2026", "two full names"),
+//	    ("Tov platba 04/2026", "nickname alone"),
+//	    ("Henrietta Ottova 04/2026", "no diacritics"),
+//	    ("Platba od Nemeček Tomas 04/2026", "reversed first+last"),
+//	    ("vrbik clenske", "last name only review"),
+//	    ("jana platba", "first name review"),
+//	    ("neznamy platebce", "no match"),
+//	]
+//	for text, label in cases: print(label + ":", match_members(text, MEMBERS))
+//	'
+//
+// Output:
+//
+//	full name guard: [('Henrietta Ottová', 'auto')]
+//	ottova surname: [('Henrietta Ottová', 'review')]
+//	two full names: [('Henrietta Ottová', 'auto'), ('Tomáš Němeček (Tov)', 'auto')]
+//	nickname alone: [('Tomáš Němeček (Tov)', 'auto')]
+//	no diacritics: [('Henrietta Ottová', 'auto')]
+//	reversed first+last: [('Tomáš Němeček (Tov)', 'auto')]
+//	last name only review: [('František Vrbík (Štrúdl)', 'review')]
+//	first name review: [('Jana Nováková', 'review')]
+//	no match: []
+
+import (
+	"testing"
+)
+
+var testMembers = []string{
+	"Henrietta Ottová",
+	"Tomáš Němeček (Tov)",
+	"František Vrbík (Štrúdl)",
+	"Jana Nováková",
+}
+
+func TestMatchMembers(t *testing.T) {
+	t.Parallel()
+
+	cases := []struct {
+		name         string
+		text         string
+		wantContains []string
+		wantExcludes []string
+		wantAllAuto  bool
+	}{
+		{
+			// Short-circuit: full name matches → "tov" inside "ottova" must NOT fire
+			name:         "full name in message returns only that member",
+			text:         "Henrietta Ottová (Heny): 04/2026",
+			wantContains: []string{"Henrietta Ottová"},
+			wantExcludes: []string{"Tomáš Němeček (Tov)"},
+			wantAllAuto:  true,
+		},
+		{
+			// "tov" is a substring of "ottova" — nickname must not match inside a surname
+			name:         "nickname tov not matched inside ottova",
+			text:         "platba ottova 04/2026",
+			wantExcludes: []string{"Tomáš Němeček (Tov)"},
+			wantAllAuto:  false,
+		},
+		{
+			name:         "two full names both auto",
+			text:         "Henrietta Ottová a Tomáš Němeček 04/2026",
+			wantContains: []string{"Henrietta Ottová", "Tomáš Němeček (Tov)"},
+			wantAllAuto:  true,
+		},
+		{
+			name:         "nickname alone matches correctly",
+			text:         "Tov platba 04/2026",
+			wantContains: []string{"Tomáš Němeček (Tov)"},
+			wantAllAuto:  true,
+		},
+		{
+			name:         "full name without diacritics auto",
+			text:         "Henrietta Ottova 04/2026",
+			wantContains: []string{"Henrietta Ottová"},
+			wantExcludes: []string{"Tomáš Němeček (Tov)"},
+			wantAllAuto:  true,
+		},
+		{
+			name:         "first and last name reversed auto",
+			text:         "Platba od Nemeček Tomas 04/2026",
+			wantContains: []string{"Tomáš Němeček (Tov)"},
+			wantAllAuto:  true,
+		},
+		{
+			// Last name alone (len≥4, not a common surname) → review confidence
+			name:         "last name only yields review",
+			text:         "vrbik clenske",
+			wantContains: []string{"František Vrbík (Štrúdl)"},
+			wantAllAuto:  false,
+		},
+		{
+			// First name alone (len≥3) → review confidence
+			name:         "first name only yields review",
+			text:         "jana platba",
+			wantContains: []string{"Jana Nováková"},
+			wantAllAuto:  false,
+		},
+		{
+			name:         "no match returns empty slice",
+			text:         "neznamy platebce",
+			wantContains: nil,
+			wantAllAuto:  false,
+		},
+	}
+
+	for _, tc := range cases {
+		t.Run(tc.name, func(t *testing.T) {
+			t.Parallel()
+			got := MatchMembers(tc.text, testMembers)
+
+			// Check required members are present
+			for _, want := range tc.wantContains {
+				found := false
+				for _, m := range got {
+					if m.Name == want {
+						found = true
+						break
+					}
+				}
+				if !found {
+					t.Errorf("MatchMembers(%q): want %q in result, got %v", tc.text, want, got)
+				}
+			}
+
+			// Check excluded members are absent
+			for _, exclude := range tc.wantExcludes {
+				for _, m := range got {
+					if m.Name == exclude {
+						t.Errorf("MatchMembers(%q): %q should not be in result, got %v", tc.text, exclude, got)
+					}
+				}
+			}
+
+			// Check all-auto constraint
+			if tc.wantAllAuto {
+				for _, m := range got {
+					if m.Confidence != ConfidenceAuto {
+						t.Errorf("MatchMembers(%q): expected all auto, got %v", tc.text, got)
+					}
+				}
+			}
+		})
+	}
+}

go/internal/domain/matching/name_variants.go

@@ -0,0 +1,59 @@
+package matching
+
+import (
+	"fuj-management/go/internal/domain/czech"
+	"regexp"
+	"strings"
+)
+
+var (
+	nicknameRe      = regexp.MustCompile(`\(([^)]+)\)`)
+	nicknameStripRe = regexp.MustCompile(`\s*\([^)]*\)\s*`)
+)
+
+// BuildNameVariants returns searchable lowercase ASCII variants of a member name.
+//
+// Example: "František Vrbík (Štrúdl)" → ["frantisek vrbik", "strudl", "vrbik", "frantisek"]
+//
+// variants[0] is always the full normalized base name (no nickname). MatchMembers relies on
+// this invariant for the exact short-circuit pass. Variants shorter than 3 characters are
+// dropped.
+//
+// Ports scripts/match_payments.py _build_name_variants.
+func BuildNameVariants(name string) []string {
+	var nickname string
+	if m := nicknameRe.FindStringSubmatch(name); m != nil {
+		nickname = m[1]
+	}
+
+	base := strings.TrimSpace(nicknameStripRe.ReplaceAllString(name, " "))
+	normalizedBase := czech.Normalize(base)
+	normalizedNick := czech.Normalize(nickname)
+
+	variants := []string{normalizedBase}
+	if normalizedNick != "" {
+		variants = append(variants, normalizedNick)
+	}
+
+	parts := strings.Fields(normalizedBase)
+	if len(parts) >= 2 {
+		variants = append(variants, parts[len(parts)-1]) // last name
+		variants = append(variants, parts[0])            // first name
+	}
+
+	filtered := variants[:0]
+	for _, v := range variants {
+		if len(v) >= 3 {
+			filtered = append(filtered, v)
+		}
+	}
+	return filtered
+}
+
+// wordIn returns true if needle appears as a whole word in haystack.
+// Both needle and haystack must already be ASCII-folded (via czech.Normalize).
+func wordIn(needle, haystack string) bool {
+	pattern := `\b` + regexp.QuoteMeta(needle) + `\b`
+	matched, _ := regexp.MatchString(pattern, haystack)
+	return matched
+}

go/internal/domain/matching/name_variants_test.go

@@ -0,0 +1,62 @@
+package matching
+
+// Expected values verified against scripts/match_payments.py on 2026-05-06:
+//
+//	PYTHONPATH=scripts:. python3 -c '
+//	from match_payments import _build_name_variants
+//	for n in ["František Vrbík (Štrúdl)", "Tov (St)", "Jana", "  Petr  Novák  ( Jenda ) "]:
+//	    print(repr(n), "->", _build_name_variants(n))
+//	'
+//
+// Output:
+//
+//	'František Vrbík (Štrúdl)' -> ['frantisek vrbik', 'strudl', 'vrbik', 'frantisek']
+//	'Tov (St)' -> ['tov']
+//	'Jana' -> ['jana']
+//	'  Petr  Novák  ( Jenda ) ' -> ['petr  novak', ' jenda ', 'novak', 'petr']
+
+import (
+	"reflect"
+	"testing"
+)
+
+func TestBuildNameVariants(t *testing.T) {
+	t.Parallel()
+
+	cases := []struct {
+		name  string
+		input string
+		want  []string
+	}{
+		{
+			name:  "full name with nickname",
+			input: "František Vrbík (Štrúdl)",
+			want:  []string{"frantisek vrbik", "strudl", "vrbik", "frantisek"},
+		},
+		{
+			name:  "nickname too short filtered out",
+			input: "Tov (St)",
+			want:  []string{"tov"},
+		},
+		{
+			name:  "single-part name no nickname",
+			input: "Jana",
+			want:  []string{"jana"},
+		},
+		{
+			name:  "extra whitespace inside parens preserved by normalize",
+			input: "  Petr  Novák  ( Jenda ) ",
+			want:  []string{"petr  novak", " jenda ", "novak", "petr"},
+		},
+	}
+
+	for _, tc := range cases {
+		t.Run(tc.name, func(t *testing.T) {
+			t.Parallel()
+			got := BuildNameVariants(tc.input)
+			if !reflect.DeepEqual(got, tc.want) {
+				t.Errorf("BuildNameVariants(%q)\n got  %q\n want %q", tc.input, got, tc.want)
+			}
+		})
+	}
+}

go/internal/domain/reconcile/reconcile.go

@@ -0,0 +1,393 @@
+// Package reconcile ports the three-phase payment reconciliation from scripts/match_payments.py.
+package reconcile
+
+import (
+	"fuj-management/go/internal/domain/czech"
+	"fuj-management/go/internal/domain/matching"
+	"regexp"
+	"strings"
+)
+
+// ExceptionKey identifies a fee override by normalized member name and period.
+type ExceptionKey struct {
+	Name   string // czech.Normalize(memberName)
+	Period string // czech.Normalize("YYYY-MM")
+}
+
+// Exception is a manual fee override for one member in one period.
+type Exception struct {
+	Amount int
+	Note   string
+}
+
+// FeeData holds the expected fee and attendance count for one member in one month.
+type FeeData struct {
+	Expected   int
+	Attendance int
+}
+
+// Member is one row from the attendance sheet.
+type Member struct {
+	Name string
+	Tier string
+	Fees map[string]FeeData // month ("YYYY-MM") → fee data
+}
+
+// Transaction is one payment row from the payments sheet.
+// Date must already be a "YYYY-MM-DD" string (convert with matching.FormatDate before calling).
+// InferredAmount, when non-nil, replaces Amount when person and purpose are pre-matched.
+type Transaction struct {
+	Date           string
+	Amount         float64
+	Person         string   // comma-separated canonical names (empty → use inference)
+	Purpose        string   // comma-separated "YYYY-MM" or "other:…" (empty → use inference)
+	InferredAmount *float64 // nil → fall back to Amount
+	Sender         string
+	Message        string
+	UserID         string
+}
+
+// TxEntry is the portion of a payment allocated to a single member+month.
+type TxEntry struct {
+	Amount     float64
+	Date       string
+	Sender     string
+	Message    string
+	Confidence string
+}
+
+// OtherEntry is a payment with purpose "other:…" allocated to a member.
+type OtherEntry struct {
+	Amount     float64
+	Date       string
+	Sender     string
+	Message    string
+	Purpose    string
+	Confidence string
+}
+
+// MonthData is the ledger state for one member in one month.
+type MonthData struct {
+	Expected         int
+	OriginalExpected int
+	AttendanceCount  int
+	Exception        *Exception
+	Paid             float64
+	Transactions     []TxEntry
+}
+
+// MemberResult is the reconciled ledger for one member.
+type MemberResult struct {
+	Tier              string
+	Months            map[string]MonthData
+	OtherTransactions []OtherEntry
+	TotalBalance      int
+}
+
+// Result is the top-level output of Reconcile.
+type Result struct {
+	Members   map[string]MemberResult
+	Unmatched []Transaction
+	Credits   map[string]int // final balance for every member (may be negative)
+}
+
+var questionMarkRe = regexp.MustCompile(`\[\?\]\s*`)
+
+// canonicalMemberKey returns a diacritic-, case-, and whitespace-insensitive key
+// used to resolve Person-column values that drift from canonical attendance-sheet names.
+// Ports scripts/match_payments.py canonical_member_key.
+func canonicalMemberKey(name string) string {
+	return strings.Join(strings.Fields(czech.Normalize(name)), " ")
+}
+
+type monthExpected struct {
+	month    string
+	expected int
+}
+
+// Reconcile matches transactions to members and months using three allocation phases:
+//  1. Greedy: payment ≥ total expected → fill each month exactly; overflow → credit.
+//  2. Proportional: payment < total → distribute by each month's share; last absorbs float remainder.
+//  3. Even-split fallback: all expected fees are 0 (prepayment) → divide equally.
+//
+// defaultYear seeds czech.ParseMonthReferences in the inference fallback.
+// Pass time.Now().Year() in production; pass a fixed year in tests.
+//
+// Ports scripts/match_payments.py reconcile.
+func Reconcile(
+	members []Member,
+	sortedMonths []string,
+	transactions []Transaction,
+	exceptions map[ExceptionKey]Exception,
+	defaultYear int,
+) Result {
+	memberNames := make([]string, len(members))
+	memberTiers := make(map[string]string, len(members))
+	memberFees := make(map[string]map[string]FeeData, len(members))
+
+	for i, m := range members {
+		memberNames[i] = m.Name
+		memberTiers[m.Name] = m.Tier
+		memberFees[m.Name] = m.Fees
+	}
+
+	// Map canonical key → first attendance-sheet name with that key, so Person cells
+	// that drift in diacritics/case/whitespace still resolve to the canonical name.
+	canonicalByKey := make(map[string]string, len(memberNames))
+	for _, name := range memberNames {
+		key := canonicalMemberKey(name)
+		if _, exists := canonicalByKey[key]; !exists {
+			canonicalByKey[key] = name
+		}
+	}
+
+	if exceptions == nil {
+		exceptions = map[ExceptionKey]Exception{}
+	}
+
+	// Initialise ledger
+	ledger := make(map[string]map[string]MonthData, len(memberNames))
+	otherLedger := make(map[string][]OtherEntry, len(memberNames))
+
+	for _, name := range memberNames {
+		ledger[name] = make(map[string]MonthData, len(sortedMonths))
+		otherLedger[name] = []OtherEntry{}
+		for _, m := range sortedMonths {
+			fd := memberFees[name][m]
+			originalExpected := fd.Expected
+			attendanceCount := fd.Attendance
+
+			var expected int
+			var exInfo *Exception
+			exKey := ExceptionKey{
+				Name:   czech.Normalize(name),
+				Period: czech.Normalize(m),
+			}
+			if ex, ok := exceptions[exKey]; ok {
+				expected = ex.Amount
+				exCopy := ex
+				exInfo = &exCopy
+			} else {
+				expected = originalExpected
+			}
+
+			ledger[name][m] = MonthData{
+				Expected:         expected,
+				OriginalExpected: originalExpected,
+				AttendanceCount:  attendanceCount,
+				Exception:        exInfo,
+				Paid:             0,
+				Transactions:     []TxEntry{},
+			}
+		}
+	}
+
+	var unmatched []Transaction
+	credits := make(map[string]int, len(memberNames))
+
+	for _, tx := range transactions {
+		personStr := strings.TrimSpace(tx.Person)
+		purposeStr := strings.TrimSpace(tx.Purpose)
+		personStr = questionMarkRe.ReplaceAllString(personStr, "")
+		isOther := strings.HasPrefix(strings.ToLower(purposeStr), "other:")
+
+		var matchedMembers []matching.Match
+		var matchedMonths []string
+		var amount float64
+
+		if personStr != "" && purposeStr != "" {
+			for p := range strings.SplitSeq(personStr, ",") {
+				p = strings.TrimSpace(p)
+				if p != "" {
+					matchedMembers = append(matchedMembers, matching.Match{
+						Name:       p,
+						Confidence: matching.ConfidenceAuto,
+					})
+				}
+			}
+			if isOther {
+				matchedMonths = []string{purposeStr}
+			} else {
+				for m := range strings.SplitSeq(purposeStr, ",") {
+					m = strings.TrimSpace(m)
+					if m != "" {
+						matchedMonths = append(matchedMonths, m)
+					}
+				}
+			}
+			if tx.InferredAmount != nil {
+				amount = *tx.InferredAmount
+			} else {
+				amount = tx.Amount
+			}
+		} else {
+			// Inference fallback for rows not yet processed by infer_payments.py
+			inferred := matching.InferTransactionDetails(
+				matching.Transaction{
+					Sender:  tx.Sender,
+					Message: tx.Message,
+					UserID:  tx.UserID,
+					Date:    tx.Date,
+				},
+				memberNames,
+				defaultYear,
+			)
+			matchedMembers = inferred.Members
+			matchedMonths = inferred.Months
+			amount = tx.Amount
+		}
+
+		if len(matchedMembers) == 0 || len(matchedMonths) == 0 {
+			unmatched = append(unmatched, tx)
+			continue
+		}
+
+		if isOther {
+			nAlloc := len(matchedMembers)
+			perAlloc := 0.0
+			if nAlloc > 0 {
+				perAlloc = amount / float64(nAlloc)
+			}
+			for _, m := range matchedMembers {
+				memberName := canonicalByKey[canonicalMemberKey(m.Name)]
+				if memberName != "" {
+					otherLedger[memberName] = append(otherLedger[memberName], OtherEntry{
+						Amount:     perAlloc,
+						Date:       tx.Date,
+						Sender:     tx.Sender,
+						Message:    tx.Message,
+						Purpose:    purposeStr,
+						Confidence: string(m.Confidence),
+					})
+				}
+			}
+			continue
+		}
+
+		memberShare := 0.0
+		if len(matchedMembers) > 0 {
+			memberShare = amount / float64(len(matchedMembers))
+		}
+
+		for _, m := range matchedMembers {
+			memberName := canonicalByKey[canonicalMemberKey(m.Name)]
+			if memberName == "" {
+				unmatched = append(unmatched, tx)
+				continue
+			}
+
+			var inWindow []monthExpected
+			outCount := 0
+			for _, month := range matchedMonths {
+				if md, ok := ledger[memberName][month]; ok {
+					inWindow = append(inWindow, monthExpected{month: month, expected: md.Expected})
+				} else {
+					outCount++
+				}
+			}
+
+			nTotal := len(matchedMonths)
+			outCredit := 0.0
+			if outCount > 0 && nTotal > 0 {
+				outCredit = memberShare / float64(nTotal) * float64(outCount)
+				credits[memberName] += int(outCredit)
+			}
+
+			inWindowShare := memberShare - outCredit
+
+			if len(inWindow) == 0 {
+				continue
+			}
+
+			totalExpected := 0
+			for _, mw := range inWindow {
+				totalExpected += mw.expected
+			}
+
+			if totalExpected > 0 && inWindowShare >= float64(totalExpected) {
+				// Greedy: payment covers all expected fees; overflow → credit
+				credits[memberName] += int(inWindowShare - float64(totalExpected))
+				for _, mw := range inWindow {
+					alloc := float64(mw.expected)
+					md := ledger[memberName][mw.month]
+					md.Paid += alloc
+					md.Transactions = append(md.Transactions, TxEntry{
+						Amount:     alloc,
+						Date:       tx.Date,
+						Sender:     tx.Sender,
+						Message:    tx.Message,
+						Confidence: string(m.Confidence),
+					})
+					ledger[memberName][mw.month] = md
+				}
+			} else if totalExpected > 0 {
+				// Proportional: distribute by each month's share; last month absorbs float remainder
+				remaining := inWindowShare
+				for i, mw := range inWindow {
+					var alloc float64
+					if i == len(inWindow)-1 {
+						alloc = remaining
+					} else {
+						alloc = inWindowShare * float64(mw.expected) / float64(totalExpected)
+					}
+					remaining -= alloc
+					md := ledger[memberName][mw.month]
+					md.Paid += alloc
+					md.Transactions = append(md.Transactions, TxEntry{
+						Amount:     alloc,
+						Date:       tx.Date,
+						Sender:     tx.Sender,
+						Message:    tx.Message,
+						Confidence: string(m.Confidence),
+					})
+					ledger[memberName][mw.month] = md
+				}
+			} else {
+				// Even-split fallback: prepayment before attendance recorded
+				perMonth := inWindowShare / float64(len(inWindow))
+				for _, mw := range inWindow {
+					md := ledger[memberName][mw.month]
+					md.Paid += perMonth
+					md.Transactions = append(md.Transactions, TxEntry{
+						Amount:     perMonth,
+						Date:       tx.Date,
+						Sender:     tx.Sender,
+						Message:    tx.Message,
+						Confidence: string(m.Confidence),
+					})
+					ledger[memberName][mw.month] = md
+				}
+			}
+		}
+	}
+
+	// Final total balances: window balance + out-of-window credits accumulated above
+	finalBalances := make(map[string]int, len(memberNames))
+	for _, name := range memberNames {
+		windowBalance := 0
+		for _, mdata := range ledger[name] {
+			windowBalance += int(mdata.Paid) - mdata.Expected
+		}
+		finalBalances[name] = windowBalance + credits[name]
+	}
+
+	membersResult := make(map[string]MemberResult, len(memberNames))
+	for _, name := range memberNames {
+		membersResult[name] = MemberResult{
+			Tier:              memberTiers[name],
+			Months:            ledger[name],
+			OtherTransactions: otherLedger[name],
+			TotalBalance:      finalBalances[name],
+		}
+	}
+
+	if unmatched == nil {
+		unmatched = []Transaction{}
+	}
+
+	return Result{
+		Members:   membersResult,
+		Unmatched: unmatched,
+		Credits:   finalBalances,
+	}
+}

go/internal/domain/reconcile/reconcile_test.go

@@ -0,0 +1,376 @@
+package reconcile
+
+// Expected values verified against scripts/match_payments.py on 2026-05-06:
+//
+//	PYTHONPATH=scripts:. python3 -m unittest tests.test_reconcile_exceptions tests.test_match_payments -v
+//
+// All Python test cases are ported below. Additional Go-only cases are marked with [Go].
+
+import (
+	"math"
+	"testing"
+)
+
+const defaultYear = 2026
+
+// tx builds a pre-matched Transaction (person+purpose already filled in).
+// InferredAmount is left nil so Amount is used directly, matching the Python
+// _tx helper where inferred_amount == amount.
+func tx(person, purpose string, amount float64) Transaction {
+	return Transaction{
+		Date:    "2026-01-01",
+		Amount:  amount,
+		Person:  person,
+		Purpose: purpose,
+		Sender:  "Sender",
+		Message: "fee",
+	}
+}
+
+func TestReconcileExceptionOverride(t *testing.T) {
+	t.Parallel()
+	members := []Member{{Name: "Alice", Tier: "A", Fees: map[string]FeeData{"2026-01": {750, 4}}}}
+	exceptions := map[ExceptionKey]Exception{
+		{Name: "alice", Period: "2026-01"}: {Amount: 400, Note: "Test exception"},
+	}
+	txs := []Transaction{{
+		Date: "2026-01-05", Amount: 400,
+		Person: "Alice", Purpose: "2026-01", Sender: "Alice Sender", Message: "fee",
+	}}
+
+	result := Reconcile(members, []string{"2026-01"}, txs, exceptions, defaultYear)
+
+	jan := result.Members["Alice"].Months["2026-01"]
+	if jan.Expected != 400 {
+		t.Errorf("Expected override to 400, got %d", jan.Expected)
+	}
+	if jan.Paid != 400 {
+		t.Errorf("Paid want 400, got %f", jan.Paid)
+	}
+	if result.Members["Alice"].TotalBalance != 0 {
+		t.Errorf("TotalBalance want 0, got %d", result.Members["Alice"].TotalBalance)
+	}
+}
+
+func TestReconcileFallbackToAttendance(t *testing.T) {
+	t.Parallel()
+	members := []Member{{Name: "Alice", Tier: "A", Fees: map[string]FeeData{"2026-01": {750, 4}}}}
+
+	result := Reconcile(members, []string{"2026-01"}, nil, nil, defaultYear)
+
+	if result.Members["Alice"].Months["2026-01"].Expected != 750 {
+		t.Errorf("Expected 750 when no exception, got %d", result.Members["Alice"].Months["2026-01"].Expected)
+	}
+}
+
+func TestReconcileGreedyExactMatch(t *testing.T) {
+	t.Parallel()
+	members := []Member{{
+		Name: "Alice", Tier: "A",
+		Fees: map[string]FeeData{
+			"2026-02": {750, 3},
+			"2026-03": {350, 3},
+			"2026-04": {150, 2},
+		},
+	}}
+	sortedMonths := []string{"2026-02", "2026-03", "2026-04"}
+
+	result := Reconcile(members, sortedMonths, []Transaction{tx("Alice", "2026-02, 2026-03, 2026-04", 1250)}, nil, defaultYear)
+
+	months := result.Members["Alice"].Months
+	if int(months["2026-02"].Paid) != 750 {
+		t.Errorf("2026-02 paid want 750, got %f", months["2026-02"].Paid)
+	}
+	if int(months["2026-03"].Paid) != 350 {
+		t.Errorf("2026-03 paid want 350, got %f", months["2026-03"].Paid)
+	}
+	if int(months["2026-04"].Paid) != 150 {
+		t.Errorf("2026-04 paid want 150, got %f", months["2026-04"].Paid)
+	}
+}
+
+func TestReconcileGreedyOverpaymentGoesToCredit(t *testing.T) {
+	t.Parallel()
+	members := []Member{{
+		Name: "Alice", Tier: "A",
+		Fees: map[string]FeeData{"2026-01": {750, 3}, "2026-02": {750, 3}},
+	}}
+	sortedMonths := []string{"2026-01", "2026-02"}
+
+	result := Reconcile(members, sortedMonths, []Transaction{tx("Alice", "2026-01, 2026-02", 2000)}, nil, defaultYear)
+
+	months := result.Members["Alice"].Months
+	if int(months["2026-01"].Paid) != 750 {
+		t.Errorf("2026-01 paid want 750, got %f", months["2026-01"].Paid)
+	}
+	if int(months["2026-02"].Paid) != 750 {
+		t.Errorf("2026-02 paid want 750, got %f", months["2026-02"].Paid)
+	}
+	if result.Credits["Alice"] != 500 {
+		t.Errorf("credits want 500, got %d", result.Credits["Alice"])
+	}
+}
+
+func TestReconcileProportionalUnderpayment(t *testing.T) {
+	t.Parallel()
+	members := []Member{{
+		Name: "Alice", Tier: "A",
+		Fees: map[string]FeeData{"2026-02": {750, 3}, "2026-03": {350, 3}, "2026-04": {750, 3}},
+	}}
+	sortedMonths := []string{"2026-02", "2026-03", "2026-04"}
+	amount := 1250.0
+
+	result := Reconcile(members, sortedMonths, []Transaction{tx("Alice", "2026-02, 2026-03, 2026-04", amount)}, nil, defaultYear)
+
+	months := result.Members["Alice"].Months
+	paid02 := months["2026-02"].Paid
+	paid03 := months["2026-03"].Paid
+	paid04 := months["2026-04"].Paid
+
+	if paid02 >= 750 {
+		t.Errorf("2026-02 should be underpaid, got %f", paid02)
+	}
+	if paid03 >= 350 {
+		t.Errorf("2026-03 should be underpaid, got %f", paid03)
+	}
+	if paid04 >= 750 {
+		t.Errorf("2026-04 should be underpaid, got %f", paid04)
+	}
+	if math.Abs(paid02+paid03+paid04-amount) > 0.01 {
+		t.Errorf("sum of paid want %f, got %f", amount, paid02+paid03+paid04)
+	}
+	if math.Abs(paid02-paid04) > 0.01 {
+		t.Errorf("02 and 04 have equal expected, want equal paid: %f vs %f", paid02, paid04)
+	}
+}
+
+func TestReconcileSingleMonthUnchanged(t *testing.T) {
+	t.Parallel()
+	members := []Member{{Name: "Alice", Tier: "A", Fees: map[string]FeeData{"2026-01": {750, 3}}}}
+
+	result := Reconcile(members, []string{"2026-01"}, []Transaction{tx("Alice", "2026-01", 750)}, nil, defaultYear)
+
+	if math.Abs(result.Members["Alice"].Months["2026-01"].Paid-750) > 0.01 {
+		t.Errorf("single month want 750, got %f", result.Members["Alice"].Months["2026-01"].Paid)
+	}
+}
+
+func TestReconcileTwoMembersMultiMonth(t *testing.T) {
+	t.Parallel()
+	members := []Member{
+		{Name: "Alice", Tier: "A", Fees: map[string]FeeData{"2026-01": {750, 3}, "2026-02": {350, 3}}},
+		{Name: "Bob", Tier: "A", Fees: map[string]FeeData{"2026-01": {750, 3}, "2026-02": {350, 3}}},
+	}
+	sortedMonths := []string{"2026-01", "2026-02"}
+
+	result := Reconcile(members, sortedMonths, []Transaction{tx("Alice, Bob", "2026-01, 2026-02", 2200)}, nil, defaultYear)
+
+	for _, name := range []string{"Alice", "Bob"} {
+		months := result.Members[name].Months
+		if math.Abs(months["2026-01"].Paid-750) > 0.01 {
+			t.Errorf("%s 2026-01 paid want 750, got %f", name, months["2026-01"].Paid)
+		}
+		if math.Abs(months["2026-02"].Paid-350) > 0.01 {
+			t.Errorf("%s 2026-02 paid want 350, got %f", name, months["2026-02"].Paid)
+		}
+	}
+}
+
+func TestReconcileEvenSplitFallbackWhenNoExpected(t *testing.T) {
+	t.Parallel()
+	members := []Member{{
+		Name: "Alice", Tier: "A",
+		Fees: map[string]FeeData{"2026-01": {0, 0}, "2026-02": {0, 0}},
+	}}
+	sortedMonths := []string{"2026-01", "2026-02"}
+
+	result := Reconcile(members, sortedMonths, []Transaction{tx("Alice", "2026-01, 2026-02", 300)}, nil, defaultYear)
+
+	months := result.Members["Alice"].Months
+	if math.Abs(months["2026-01"].Paid-150) > 0.01 {
+		t.Errorf("2026-01 paid want 150, got %f", months["2026-01"].Paid)
+	}
+	if math.Abs(months["2026-02"].Paid-150) > 0.01 {
+		t.Errorf("2026-02 paid want 150, got %f", months["2026-02"].Paid)
+	}
+}
+
+func TestReconcileDiacriticsTolerantPersonMatching(t *testing.T) {
+	t.Parallel()
+	members := []Member{{Name: "Mária Maco", Tier: "A", Fees: map[string]FeeData{"2026-04": {750, 4}}}}
+	txFn := func(person string) Transaction {
+		return Transaction{
+			Date: "2026-04-15", Amount: 750, Person: person, Purpose: "2026-04",
+			Sender: "Maco Family", Message: "fee",
+		}
+	}
+
+	cases := []struct {
+		name   string
+		person string
+	}{
+		{"without diacritics", "Maria Maco"},
+		{"extra whitespace", "Mária  Maco"},
+		{"lowercase", "mária maco"},
+	}
+
+	for _, tc := range cases {
+		t.Run(tc.name, func(t *testing.T) {
+			t.Parallel()
+			result := Reconcile(members, []string{"2026-04"}, []Transaction{txFn(tc.person)}, nil, defaultYear)
+
+			paid := result.Members["Mária Maco"].Months["2026-04"].Paid
+			if paid != 750 {
+				t.Errorf("%s: paid want 750, got %f", tc.name, paid)
+			}
+			if len(result.Unmatched) != 0 {
+				t.Errorf("%s: want no unmatched, got %v", tc.name, result.Unmatched)
+			}
+		})
+	}
+}
+
+func TestReconcileTrulyUnknownPersonIsUnmatched(t *testing.T) {
+	t.Parallel()
+	members := []Member{{Name: "Mária Maco", Tier: "A", Fees: map[string]FeeData{"2026-04": {750, 4}}}}
+	txs := []Transaction{{
+		Date: "2026-04-15", Amount: 750,
+		Person: "Někdo Neznámý", Purpose: "2026-04",
+		Sender: "Neznámý", Message: "fee",
+	}}
+
+	result := Reconcile(members, []string{"2026-04"}, txs, nil, defaultYear)
+
+	if result.Members["Mária Maco"].Months["2026-04"].Paid != 0 {
+		t.Errorf("unknown person must not credit the member")
+	}
+	if len(result.Unmatched) != 1 {
+		t.Errorf("want 1 unmatched, got %d", len(result.Unmatched))
+	}
+}
+
+// [Go] Test that [?] markers are stripped from the Person field before lookup.
+func TestReconcileQuestionMarkMarkerStripped(t *testing.T) {
+	t.Parallel()
+	members := []Member{{Name: "Alice", Tier: "A", Fees: map[string]FeeData{"2026-01": {750, 3}}}}
+	txs := []Transaction{{
+		Date: "2026-01-01", Amount: 750,
+		Person: "[?] Alice", Purpose: "2026-01",
+		Sender: "Bank", Message: "fee",
+	}}
+
+	result := Reconcile(members, []string{"2026-01"}, txs, nil, defaultYear)
+
+	if result.Members["Alice"].Months["2026-01"].Paid != 750 {
+		t.Errorf("[?] stripping: want 750 paid, got %f", result.Members["Alice"].Months["2026-01"].Paid)
+	}
+}
+
+// [Go] Purpose "other:shirt" puts payment in OtherTransactions, not in month ledger.
+func TestReconcileOtherPurpose(t *testing.T) {
+	t.Parallel()
+	members := []Member{{Name: "Alice", Tier: "A", Fees: map[string]FeeData{"2026-01": {750, 3}}}}
+	txs := []Transaction{{
+		Date: "2026-01-01", Amount: 300,
+		Person: "Alice", Purpose: "other:shirt",
+		Sender: "Bank", Message: "shirt order",
+	}}
+
+	result := Reconcile(members, []string{"2026-01"}, txs, nil, defaultYear)
+
+	if result.Members["Alice"].Months["2026-01"].Paid != 0 {
+		t.Errorf("other: purpose must not touch month ledger")
+	}
+	others := result.Members["Alice"].OtherTransactions
+	if len(others) != 1 {
+		t.Fatalf("want 1 OtherTransaction, got %d", len(others))
+	}
+	if math.Abs(others[0].Amount-300) > 0.01 {
+		t.Errorf("OtherEntry.Amount want 300, got %f", others[0].Amount)
+	}
+	if others[0].Purpose != "other:shirt" {
+		t.Errorf("OtherEntry.Purpose want %q, got %q", "other:shirt", others[0].Purpose)
+	}
+}
+
+// [Go] Months outside sortedMonths go to credit, not to the window ledger.
+func TestReconcileOutOfWindowGoesToCredit(t *testing.T) {
+	t.Parallel()
+	// Window shows only 2026-01. Transaction references 2026-01 (in) and 2026-02 (out).
+	members := []Member{{Name: "Alice", Tier: "A", Fees: map[string]FeeData{"2026-01": {600, 3}}}}
+	txs := []Transaction{{
+		Date: "2026-01-01", Amount: 1200,
+		Person: "Alice", Purpose: "2026-01, 2026-02",
+		Sender: "Bank", Message: "Q1",
+	}}
+
+	result := Reconcile(members, []string{"2026-01"}, txs, nil, defaultYear)
+
+	// member_share = 1200 (one member)
+	// out_credit = 1200 / 2 * 1 = 600
+	// in_window_share = 600
+	// in_window = [(2026-01, 600)], total_expected = 600 → greedy: paid = 600, no overflow
+	if math.Abs(result.Members["Alice"].Months["2026-01"].Paid-600) > 0.01 {
+		t.Errorf("in-window paid want 600, got %f", result.Members["Alice"].Months["2026-01"].Paid)
+	}
+	// total_balance = int(600) - 600 (window) + 600 (out credit) = 600
+	if result.Members["Alice"].TotalBalance != 600 {
+		t.Errorf("TotalBalance want 600, got %d", result.Members["Alice"].TotalBalance)
+	}
+}
+
+// [Go] No person/purpose → inference fallback resolves sender name and date month.
+func TestReconcileInferenceFallback(t *testing.T) {
+	t.Parallel()
+	members := []Member{{Name: "Tomáš Němeček", Tier: "A", Fees: map[string]FeeData{"2026-04": {750, 3}}}}
+	txs := []Transaction{{
+		Date: "2026-04-15", Amount: 750,
+		// Person and Purpose are empty → inference path
+		Sender:  "Tomas Nemecek",
+		Message: "clenske 04/2026",
+	}}
+
+	result := Reconcile(members, []string{"2026-04"}, txs, nil, defaultYear)
+
+	if math.Abs(result.Members["Tomáš Němeček"].Months["2026-04"].Paid-750) > 0.01 {
+		t.Errorf("inference fallback: want 750 paid, got %f", result.Members["Tomáš Němeček"].Months["2026-04"].Paid)
+	}
+}
+
+// [Go] Transaction with no match at all ends up in Unmatched; ledger unchanged.
+func TestReconcileNoMatchGoesToUnmatched(t *testing.T) {
+	t.Parallel()
+	members := []Member{{Name: "Alice", Tier: "A", Fees: map[string]FeeData{"2026-01": {750, 3}}}}
+	txs := []Transaction{{
+		Date: "2026-01-01", Amount: 500,
+		// empty person+purpose and sender name not matching any member
+		Sender: "Unknown Corp", Message: "invoice",
+	}}
+
+	result := Reconcile(members, []string{"2026-01"}, txs, nil, defaultYear)
+
+	if len(result.Unmatched) != 1 {
+		t.Errorf("want 1 unmatched, got %d", len(result.Unmatched))
+	}
+	if result.Members["Alice"].Months["2026-01"].Paid != 0 {
+		t.Errorf("unmatched tx must not touch ledger")
+	}
+}
+
+// [Go] Empty transaction list leaves every month at paid=0 and balance=–expected.
+func TestReconcileNoTransactionsAllUnpaid(t *testing.T) {
+	t.Parallel()
+	members := []Member{{Name: "Alice", Tier: "A", Fees: map[string]FeeData{"2026-01": {750, 3}}}}
+
+	result := Reconcile(members, []string{"2026-01"}, nil, nil, defaultYear)
+
+	if result.Members["Alice"].Months["2026-01"].Paid != 0 {
+		t.Errorf("no txs: want paid=0, got %f", result.Members["Alice"].Months["2026-01"].Paid)
+	}
+	if result.Members["Alice"].TotalBalance != -750 {
+		t.Errorf("no txs: want balance -750, got %d", result.Members["Alice"].TotalBalance)
+	}
+	if len(result.Unmatched) != 0 {
+		t.Errorf("no txs: want empty unmatched, got %v", result.Unmatched)
+	}
+}

scripts/infer_payments.py

@@ -11,8 +11,8 @@ sys.path.append(os.path.dirname(os.path.abspath(__file__)))
 
 from googleapiclient.discovery import build
 from sync_fio_to_sheets import get_sheets_service, DEFAULT_SPREADSHEET_ID
-from match_payments import infer_transaction_details
-from attendance import get_members_with_fees
+from match_payments import infer_transaction_details, canonical_member_key
+from attendance import get_members_with_fees, get_junior_members_with_fees
 
 def parse_czk_amount(val) -> float:
     """Parse Czech currency string or handle raw numeric value."""
@@ -96,10 +96,19 @@ def infer_payments(spreadsheet_id: str, credentials_path: str, dry_run: bool = F
         print(f"Current header: {header}")
         return
 
-    # 2. Fetch members for matching
+    # 2. Fetch members for matching — union adults + juniors so junior-only
+    # members (e.g. kids not on the adult sheet) are visible to the matcher.
     print("Fetching member list for matching...")
-    members_data, _ = get_members_with_fees()
-    member_names = [m[0] for m in members_data]
+    adult_members, _ = get_members_with_fees()
+    junior_members, _ = get_junior_members_with_fees()
+
+    seen: set[str] = set()
+    member_names: list[str] = []
+    for m in adult_members + junior_members:
+        key = canonical_member_key(m[0])
+        if key not in seen:
+            seen.add(key)
+            member_names.append(m[0])
 
     # 3. Process rows
     print("Inferring details for empty rows...")

tests/test_match_members.py

@@ -48,6 +48,25 @@ class TestMatchMembersExact(unittest.TestCase):
         names = [r[0] for r in result]
         self.assertIn("Tomáš Němeček (Tov)", names)
 
+    def test_shared_first_name_junior_in_roster_wins_exact(self):
+        # Regression: two members share first name "Jáchym"; message has full name
+        # of the junior-only member → exact match must win, no [?] on the adult.
+        roster = ["Jáchym Hrušák (G)", "Jáchym Kubík"]
+        result = match_members(
+            "JIŘÍ KUBÍK Jáchym Kubík: 01/2026+03/2026+04/2026", roster
+        )
+        self.assertEqual(result, [("Jáchym Kubík", "auto")])
+
+    def test_shared_first_name_without_junior_in_roster_falls_back(self):
+        # Without Kubík in the roster (old behaviour), Hrušák wins via first-name
+        # partial match — confirms the roster-expansion fix is the real solution.
+        roster = ["Jáchym Hrušák (G)"]
+        result = match_members(
+            "JIŘÍ KUBÍK Jáchym Kubík: 01/2026+03/2026+04/2026", roster
+        )
+        names = [r[0] for r in result]
+        self.assertIn("Jáchym Hrušák (G)", names)
+
 
 if __name__ == "__main__":
     unittest.main()