chore(changelog): add entry for fee rate update 2026-05 through 2026-08

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

.gitignore

@@ -7,3 +7,4 @@ tmp/
 
 # go build output
 bin/
+go/parity

CHANGELOG.md

@@ -1,10 +1,40 @@
 # Changelog
 
+## 2026-05-24 21:58 CEST — feat(fees): update adult monthly rates for 2026-05 through 2026-08
+
+- 2026-05: 700 → 450 CZK; 2026-06/07/08: 600 CZK (new months added).
+- Mirrored in both `scripts/attendance.py` and `go/internal/domain/fees/fees.go`.
+
+## 2026-05-24 21:42 CEST — feat: multi-account Fio sync + switch QR default to 2502035405/2010
+
+- Added second bank account `2502035405/2010` (IBAN `CZ0820100000002502035405`) to sync.
+- Both accounts are fetched on every sync; dedup by existing sync_id keeps the payments sheet clean.
+- QR codes now default to the new account (`CZ0820100000002502035405`).
+- Go: `config.go` gains hardcoded `Accounts`/`LoadedAccount` slice; `Config.BankAccount` renamed to `Config.QRAccount`; `FioAPIToken` removed (tokens are per-account via `FIO_API_TOKEN_NEW` / `FIO_API_TOKEN_OLD`).
+- Go: `SyncToSheets` now accepts `[]fio.Client`; new `TestSyncToSheets_MultiAccount` test.
+- Python: `config.py` gains `ACCOUNTS` / `LOADED_ACCOUNTS`; `fio_utils.py` adds `fetch_transactions_for` and `fetch_transactions_all`; `sync_fio_to_sheets.py` uses `fetch_transactions_all`.
+- Key files: `go/internal/config/config.go`, `go/internal/services/banksync/sync.go`, `go/cmd/fuj/main.go`, `scripts/config.py`, `scripts/fio_utils.py`, `scripts/sync_fio_to_sheets.py`.
+
+## 2026-05-11 23:58 CEST — fix(reconcile): fill earliest month deficit first in multi-month allocations
+
+- Multi-month payment allocation now fills the earliest in-window deficit first and spills
+  any remainder to later months, accounting for prior transactions' contributions to each month.
+  Previously a single transaction was split proportionally to each month's total expected fee,
+  ignoring what earlier transactions had already paid — surfaced by Matyáš Thér's 200+550 case
+  showing 566/183 instead of 500/250.
+- Files: `scripts/match_payments.py`, `go/internal/domain/reconcile/reconcile.go`, tests, parity fixtures.
+
 ## 2026-05-11 22:56 CEST — fix(python): parse Fio 2-digit-year dates + add `make sync-debug` dry-run tool
 
 - Fix: `scripts/fio_utils.py` `parse_czech_date` now accepts `DD.MM.YY` / `D.M.YY` in addition to the 4-digit-year variants. Fio's transparent page now mixes both forms in the same response; the 2-digit rows were being silently dropped, which caused `make sync-2026` to miss every recent transfer. Mirrors the Go-side fix from 2026-05-07 (CHANGELOG entry below).
 - Added `--dry-run` and `--print-fio-table` flags to `scripts/sync_fio_to_sheets.py`, plus a `make sync-debug [DAYS=N]` Makefile target. Mirrors `make go-sync-debug`: fetches from Fio and dedupes against the sheet, prints `STATUS=NEW/DUP` per transaction, and prints per-row `Dry run: would append …` lines + `would sort by date` instead of touching the sheet.
 - Added always-on stderr diagnostics in `scripts/fio_utils.py`: which fetcher was selected (authenticated API vs. transparent-page scraper with `FIO_API_TOKEN`-unset warning), and raw-vs-after-filter transaction counts on both paths — so this class of "scraper drops everything" bug surfaces immediately.
+## 2026-05-08 15:24 CEST — feat(go): M6.7 — single-binary embed verification
+
+- Confirmed `embed.FS` wiring is complete: templates parsed via `template.ParseFS(templateFS, ...)`, static assets served via `http.FileServerFS(fs.Sub(staticFS, "static"))`.
+- Added `go/internal/web/assets_test.go` with two tests: `TestEmbedCompleteness` (walks disk vs embed.FS to catch forgotten files) and `TestStaticAssetsServed` (hits `/static/css/app.css` and all JS files through the mux, asserts 200 + Content-Type + non-empty body + 404 for unknown paths).
+- Closes M6; single binary confirmed self-contained with no adjacent `templates/` or `static/` required at runtime.
+- Key files: `go/internal/web/assets_test.go` (new).
 
 ## 2026-05-08 14:55 CEST — feat(go): M6.6.1 — Pay-button QR popup modal
 

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

@@ -117,7 +117,7 @@ Goal: feature-equivalent UX on the Go side, designed cleanly. Not a Jinja port.
 - [x] **M6.5** Modal JS module (`static/js/member-detail.js`): fetches `/api/adults` (or juniors), renders status/exceptions/transactions on row click; keyboard nav (Esc, ↑/↓) — `e53e238`
 - [x] **M6.6** `/qr`, `/sync-bank`, `/flush-cache`, `/version` pages — `f6ba85b`
 - [x] **M6.6.1** Pay-button QR popup modal (`payment-qr.js`); restores Python `showPayQR` UX lost in M6.6 — `4276d7b`
-- [ ] **M6.7** Wire `embed.FS` into handlers; verify single-binary deployment includes all assets
+- [ ] **M6.7** Wire `embed.FS` into handlers; verify single-binary deployment includes all assets — (pending merge)
 
 **Gate:** Browser smoke on :8080: all pages render, name+month filters work, modal opens with correct data, QR loads, sync/flush work end-to-end.
 

docs/plans/2026-05-08-1457-go-m6-7-single-binary-embed-verify.md

@@ -0,0 +1,184 @@
+# M6.7 — Single-binary embed verification
+
+## Context
+
+M6.7 is the final task in M6 (Go-native HTML frontend). Per the
+[progress tracker](2026-05-03-2349-go-backend-rewrite-progress.md): "Wire
+`embed.FS` into handlers; verify single-binary deployment includes all
+assets."
+
+The wiring is **already in place** from M6.1 onward:
+
+- [go/internal/web/assets.go](../../go/internal/web/assets.go) declares
+  `//go:embed templates` → `templateFS` and `//go:embed static` → `staticFS`.
+- [go/internal/web/render.go:66](../../go/internal/web/render.go#L66)
+  parses every page template via `template.New(...).ParseFS(templateFS, ...)`.
+- [go/internal/web/server.go:48-68](../../go/internal/web/server.go#L48-L68)
+  serves `/static/*` via `http.FileServerFS(fs.Sub(staticFS, "static"))`.
+- [go/build/Dockerfile](../../go/build/Dockerfile) copies only the compiled
+  binary into the `alpine:3` runtime image — no `templates/` or `static/`
+  directory ever lands beside it.
+
+What is missing is **proof** the embed is complete and stays complete:
+
+1. Nothing fails the build/test if a contributor adds a new file under
+   `internal/web/templates/` or `internal/web/static/` that isn't matched
+   by an `//go:embed` glob (or, more realistically, adds a sibling
+   directory like `static/img/` and the glob still picks it up — but a
+   typo'd directive would silently drop it).
+2. No automated test exercises the `/static/*` route against the embedded
+   FS — current tests in
+   [html_handler_test.go](../../go/internal/web/html_handler_test.go)
+   render templates (which proves `templateFS` is good) but never hit a
+   static URL through the mux.
+3. The "single binary, no working-dir assets" property is undocumented —
+   if it ever broke, no one would notice until the Docker image started
+   500'ing in prod.
+
+The intended outcome: a small test file plus a documented manual
+verification step, after which M6.7 can be ticked and M6 closed.
+
+## Plan
+
+### 1. Add `go/internal/web/assets_test.go`
+
+One new file, two tests, no production code changes.
+
+**Test A — embed completeness regression guard.** Walks the on-disk
+`templates/` and `static/` directories and asserts every regular file is
+also present in the corresponding embedded FS. Catches:
+
+- A new template added without updating the `//go:embed` directive
+  (current globs are `templates` and `static` — recursive by default for
+  directories, so this is a low-probability regression, but the test
+  doubles as living documentation of the contract).
+- A typo in the directive (e.g. someone renames `static` → `assets` in
+  one place but not the other).
+
+Implementation sketch:
+
+```go
+func TestEmbedCompleteness(t *testing.T) {
+    cases := []struct {
+        name   string
+        diskFS fs.FS         // os.DirFS("templates") / os.DirFS("static")
+        embed  fs.FS         // exported helper or via internal test in package web
+        root   string
+    }{...}
+    for _, tc := range cases {
+        _ = fs.WalkDir(tc.diskFS, ".", func(path string, d fs.DirEntry, err error) error {
+            if err != nil || d.IsDir() { return err }
+            embPath := tc.root + "/" + path
+            if _, err := fs.Stat(tc.embed, embPath); err != nil {
+                t.Errorf("file %q on disk but missing in embed.FS: %v", embPath, err)
+            }
+            return nil
+        })
+    }
+}
+```
+
+Because `templateFS` and `staticFS` are unexported package vars, this
+test lives in `package web` (not `web_test`) — sibling to
+[assets.go](../../go/internal/web/assets.go). All the existing handler
+tests are in `package web_test`; that's fine, this one is internal.
+
+**Test B — `/static/*` end-to-end via the mux.** Builds an `http.ServeMux`
+with the same wiring as
+[server.go:68](../../go/internal/web/server.go#L68), fires httptest
+requests, asserts:
+
+- `GET /static/css/app.css` → 200, `Content-Type: text/css; charset=utf-8`,
+  body contains a known string from app.css (e.g. a CSS selector).
+- `GET /static/js/member-detail.js` → 200, `Content-Type` starts with
+  `text/javascript` or `application/javascript`, body non-empty.
+- `GET /static/js/payment-qr.js` → 200, body non-empty.
+- `GET /static/css/missing.css` → 404 (sanity: the file server actually
+  rejects unknown paths instead of returning some default).
+
+Rather than duplicate the mux assembly, factor a tiny helper (or test the
+existing mux). The cleanest move: extract `staticHandler()` from
+[server.go:48-50,68](../../go/internal/web/server.go#L48-L68) into a small
+exported-from-package function or just `staticFS` / `fs.Sub` helper, and
+have the test call it. Smallest delta: keep production code unchanged and
+replicate the two-line wiring inside the test file (acceptable — it's
+two lines and the test exists precisely to lock that contract).
+
+### 2. Manual / one-shot verification (no code; documented in plan only)
+
+Run once locally and tick M6.7. Command transcript:
+
+```bash
+make go-build                  # → ./bin/fuj
+cp bin/fuj /tmp/fuj-standalone
+cd /tmp                        # working dir has no templates/ or static/
+./fuj-standalone server &
+SERVER_PID=$!
+sleep 1
+curl -sf http://localhost:8080/adults | grep -q "Adults Dashboard"
+curl -sf http://localhost:8080/juniors | grep -q "Juniors"
+curl -sf http://localhost:8080/payments | grep -q "Payments Ledger"
+curl -sf -o /tmp/app.css http://localhost:8080/static/css/app.css \
+  && test -s /tmp/app.css
+curl -sf -o /tmp/qr.js http://localhost:8080/static/js/payment-qr.js \
+  && test -s /tmp/qr.js
+kill $SERVER_PID
+```
+
+`fuj server` will fail to talk to Sheets without credentials, so the
+`/adults` etc. pages will render with the `Error` field set — that's
+fine; the assertion is that the **template + static asset pipeline** is
+self-contained, not that data loads. Each curl above only checks for
+markup present in every render path (header text and stylesheet body).
+
+### 3. Tracker + changelog
+
+- Tick `M6.7` in
+  [docs/plans/2026-05-03-2349-go-backend-rewrite-progress.md:120](2026-05-03-2349-go-backend-rewrite-progress.md#L120),
+  append the merge SHA on the line.
+- Mark "Last updated" date and bump milestone status: M6 complete, next is
+  M7.
+- Append a `CHANGELOG.md` entry per CLAUDE.md convention (`date "+%Y-%m-%d %H:%M %Z"`).
+
+## Files touched
+
+| File | Change |
+| --- | --- |
+| [go/internal/web/assets_test.go](../../go/internal/web/assets_test.go) | **new** — two tests (embed completeness + `/static/*` mux) |
+| [docs/plans/2026-05-03-2349-go-backend-rewrite-progress.md](2026-05-03-2349-go-backend-rewrite-progress.md) | tick M6.7, bump "last updated" |
+| [CHANGELOG.md](../../CHANGELOG.md) | new top entry |
+
+No production source files change. (If extracting the static handler
+reads cleaner, a 4-line refactor in
+[server.go](../../go/internal/web/server.go) is acceptable but optional.)
+
+## Branch + MR
+
+Per project convention this is a feature, so:
+
+```bash
+git checkout -b feat/go-m6-7-embed-verify
+# … commits …
+git push -u origin feat/go-m6-7-embed-verify
+tea pr create --title "feat(go): M6.7 — single-binary embed verification" \
+  --description "<short body referencing M6.7>" --base main \
+  --head feat/go-m6-7-embed-verify
+```
+
+## Verification
+
+After implementation:
+
+1. `make go-test` → green (new `TestEmbedCompleteness` and `TestStaticAssetsServed` pass).
+2. `make go-lint` → clean.
+3. Run the manual transcript in §2 above — all curls succeed, no
+   "template not found" or 404 on static assets.
+4. `make go-build && docker build -f go/build/Dockerfile -t fuj-go:m6-7 go/` →
+   succeeds; `docker run --rm -p 8080:8080 fuj-go:m6-7` serves `/adults`
+   with stylesheet attached (visual smoke test in browser).
+
+## Out of scope
+
+- Re-architecting how templates are parsed or served.
+- Compressing / fingerprinting static assets (a separate concern).
+- Live integration test with real Sheets data — covered later in M7.

docs/plans/2026-05-11-2353-fill-first-multi-month-allocation.md

@@ -0,0 +1,184 @@
+# Fill-first multi-month payment allocation
+
+## Context
+
+Matyáš Thér paid in two transactions:
+
+| # | Amount | Purpose             |
+|---|--------|---------------------|
+| 1 | 200    | `2026-02`           |
+| 2 | 550    | `2026-02, 2026-03`  |
+
+Total 750 = his expected fee for the two months (likely 2026-02 = 500, 2026-03 = 250 — junior tier or exception-adjusted). The app currently shows 2026-02 = **566** paid, 2026-03 = **183** paid. The user wants:
+
+> First use the second payment for the rest of 2026-02 (no more, no less), then put the remainder toward 2026-03.
+
+Both Python ([scripts/match_payments.py](scripts/match_payments.py)) and Go ([go/internal/domain/reconcile/reconcile.go](go/internal/domain/reconcile/reconcile.go)) have the same bug: when a single transaction's `in_window_share` is less than the sum of in-window expected fees, both fall into a **proportional** branch that splits the new transaction across months in proportion to each month's *total* expected fee — never consulting what prior transactions already paid into earlier months.
+
+Trace for txn 2:
+
+- `in_window = [(2026-02, 500), (2026-03, 250)]`, `total_expected = 750`, `in_window_share = 550`.
+- `550 < 750` → proportional:
+  - 02 alloc = `550 × 500 / 750 = 366.67`
+  - 03 alloc = `550 − 366.67 = 183.33`
+- Combined with txn 1's 200 → 02 = 566.67, 03 = 183.33 → display `566 / 183`. ✓ matches reported numbers.
+
+The fix: replace the greedy + proportional branches with a single **fill-first** loop that iterates `in_window` in user-supplied order (already chronological by convention from [scripts/infer_payments.py:151](scripts/infer_payments.py#L151)) and allocates `min(remaining, max(0, expected − paid_so_far))` to each month, with any final surplus going to the credit bucket. This collapses three cases (greedy / proportional / pure overflow) into one and naturally consults the ledger's `paid` field which is already updated by prior transactions in the same reconcile pass.
+
+The even-split branch (`total_expected == 0`, prepayment before fees known) stays untouched — different semantic, folding it in would silently change behavior.
+
+## Changes
+
+### Python — [scripts/match_payments.py:471-498](scripts/match_payments.py#L471-L498)
+
+Replace both `total_expected > 0` branches (current lines 471–498) with a single unified loop. Keep lines 466–469 above and the even-split fallback below (lines 499–510) as-is.
+
+```python
+            if total_expected > 0:
+                # Fill-first: iterate in_window in matched_months order (chronological by
+                # convention), allocate min(remaining, deficit) to each month, where
+                # deficit accounts for prior transactions already credited to that month.
+                # Any surplus after all in-window deficits are covered → credit bucket.
+                remaining = in_window_share
+                for m, exp in in_window:
+                    paid_so_far = ledger[member_name][m]["paid"]
+                    deficit = max(0.0, float(exp) - paid_so_far)
+                    alloc = min(remaining, deficit)
+                    if alloc <= 0:
+                        continue
+                    ledger[member_name][m]["paid"] += alloc
+                    ledger[member_name][m]["transactions"].append({
+                        "amount": alloc,
+                        "date": tx["date"],
+                        "sender": tx["sender"],
+                        "message": tx["message"],
+                        "confidence": confidence,
+                    })
+                    remaining -= alloc
+                if remaining > 0:
+                    credits[member_name] = credits.get(member_name, 0) + int(remaining)
+            else:
+                # … existing even-split branch (lines 499–510) unchanged …
+```
+
+Note: skipping the `transactions.append` when `alloc <= 0` (e.g. month already fully paid by a prior txn) avoids zero-amount ghost rows in the per-month transaction list. This is a small UI-visible side effect; before committing, grep tests for assertions on `len(transactions)` per month to confirm nothing relies on the current "one row per (txn, month) regardless of alloc" behavior.
+
+### Go — [go/internal/domain/reconcile/reconcile.go:320-357](go/internal/domain/reconcile/reconcile.go#L320-L357)
+
+Same shape — replace both `totalExpected > 0` branches. Even-split branch (lines 358–372) stays.
+
+```go
+            if totalExpected > 0 {
+                // Fill-first; see Python reconcile() for rationale.
+                remaining := inWindowShare
+                for _, mw := range inWindow {
+                    md := ledger[memberName][mw.month]
+                    deficit := float64(mw.expected) - md.Paid
+                    if deficit < 0 {
+                        deficit = 0
+                    }
+                    alloc := remaining
+                    if deficit < alloc {
+                        alloc = deficit
+                    }
+                    if alloc <= 0 {
+                        continue
+                    }
+                    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
+                    remaining -= alloc
+                }
+                if remaining > 0 {
+                    credits[memberName] += int(remaining)
+                }
+            } else {
+                // … existing even-split branch (lines 358–372) unchanged …
+            }
+```
+
+### Tests
+
+#### Python — [tests/test_reconcile_exceptions.py](tests/test_reconcile_exceptions.py)
+
+1. **Rewrite `test_proportional_underpayment`** ([line 96](tests/test_reconcile_exceptions.py#L96)) — its current assertions (`paid_02 < 750`, `paid_03 < 350`, `paid_04 < 750`, and 02/04 equal allocation) are incompatible with fill-first. Under fill-first with the same fixture (1250 across `02:750, 03:350, 04:750`):
+   - 02: `min(1250, 750) = 750` (full) → remaining 500
+   - 03: `min(500, 350) = 350` (full) → remaining 150
+   - 04: `min(150, 750) = 150` (partial) → remaining 0
+   
+   Replace assertions with these exact expected values, rename to `test_underpayment_fills_earliest_first`.
+
+2. **Add `test_fill_first_across_two_transactions`** — the Matyáš regression:
+
+   ```python
+   def test_fill_first_across_two_transactions(self):
+       """Prior txn fills 02 partially; later txn finishes 02 then spills to 03."""
+       members = [('Matyáš', 'A', {'2026-02': (500, 2), '2026-03': (250, 1)})]
+       sorted_months = ['2026-02', '2026-03']
+       tx1 = _tx('Matyáš', '2026-02', 200)
+       tx2 = _tx('Matyáš', '2026-02, 2026-03', 550)
+
+       result = reconcile(members, sorted_months, [tx1, tx2])
+       months = result['members']['Matyáš']['months']
+
+       self.assertAlmostEqual(months['2026-02']['paid'], 500, places=2)
+       self.assertAlmostEqual(months['2026-03']['paid'], 250, places=2)
+   ```
+
+3. `test_greedy_exact_match`, `test_greedy_overpayment_goes_to_credit`, `test_single_month_unchanged`, `test_two_members_multi_month` should pass unchanged — fill-first agrees with greedy when payment ≥ total expected.
+
+#### Go — [go/internal/domain/reconcile/reconcile_test.go](go/internal/domain/reconcile/reconcile_test.go)
+
+- Add `TestUnderpaymentFillsEarliestFirst` mirroring the rewritten Python test.
+- Add `TestFillFirstAcrossTwoTransactions` mirroring the Matyáš scenario.
+
+#### Parity — [go/tests/parity/reconcile/reconcile_parity_test.go](go/tests/parity/reconcile/reconcile_parity_test.go)
+
+Add a fixture for the Matyáš two-transaction case. Since both implementations change together and Python remains canonical, existing parity fixtures should continue to pass; verify after edits.
+
+### Changelog — [CHANGELOG.md](CHANGELOG.md)
+
+Append top entry (use `date "+%Y-%m-%d %H:%M %Z"` at commit time):
+
+```markdown
+## 2026-05-11 23:55 CET — fill-first multi-month payment allocation
+
+- Multi-month payment allocation now fills the earliest in-window deficit first
+  and spills the remainder to later months, accounting for prior transactions'
+  contributions. Previously a single transaction was split proportionally to
+  each month's total expected fee, ignoring earlier payments — surfaced by
+  Matyáš Thér's two-payment 200+550 case showing 566/183 instead of 500/250.
+- scripts/match_payments.py, go/internal/domain/reconcile/reconcile.go, tests.
+```
+
+## Critical files
+
+- [scripts/match_payments.py](scripts/match_payments.py) — Python reconcile (canonical)
+- [go/internal/domain/reconcile/reconcile.go](go/internal/domain/reconcile/reconcile.go) — Go reconcile (mirrors Python)
+- [tests/test_reconcile_exceptions.py](tests/test_reconcile_exceptions.py) — rewrite `test_proportional_underpayment` + add Matyáš test
+- [go/internal/domain/reconcile/reconcile_test.go](go/internal/domain/reconcile/reconcile_test.go) — add Go tests
+- [go/tests/parity/reconcile/reconcile_parity_test.go](go/tests/parity/reconcile/reconcile_parity_test.go) — add parity fixture
+- [CHANGELOG.md](CHANGELOG.md) — top entry
+
+## Verification
+
+1. `make test` — Python unit tests including the rewritten + new fill-first tests.
+2. `cd go && go test ./internal/domain/reconcile/... ./tests/parity/reconcile/...` — Go unit + parity tests.
+3. `make web` → load `/adults` or `/juniors` (whichever lists Matyáš Thér) → his 2026-02 row should be fully paid (no shortfall), 2026-03 fully paid, no leftover credit.
+4. Spot-check one other multi-month-purpose member to make sure fully-covered cases still look right.
+
+## Branch & MR (per CLAUDE.md)
+
+1. `git checkout -b fix/fill-first-multi-month-allocation`
+2. Apply edits + tests + CHANGELOG entry.
+3. `make test && (cd go && go test ./...)` — both green.
+4. Commit: `fix(reconcile): fill earliest month deficit first in multi-month allocations` with `Co-Authored-By` trailer.
+5. `git push -u origin fix/fill-first-multi-month-allocation`
+6. `tea pr create --title "fix(reconcile): fill earliest month deficit first" --description "<body>" --base main --head fix/fill-first-multi-month-allocation`
+7. Print MR URL. Do not merge from CLI.

docs/plans/2026-05-24-2120-multi-account-bank-sync.md

@@ -0,0 +1,269 @@
+# Multi-account Fio sync + switch QR target to 2502035405/2010
+
+## Context
+
+The club is opening a second Fio transparent account, **`2502035405/2010`** (IBAN
+`CZ??...0000002502035405`). Going forward:
+
+- **Sync** must pull transactions from **both** accounts into the existing
+  payments sheet — the old `2800359168/2010` stays active so historical fees
+  paid to it still reconcile.
+- **QR codes** generated by `/qr` should default to the **new** account
+  (`2502035405/2010`), so new payers send money there.
+
+The payments sheet schema and `sync_id` hash stay **unchanged** — no
+"Source Account" column, no migration, no risk of re-appending historical rows.
+Bank-ID uniqueness from Fio plus the existing hash inputs are good enough to
+dedupe across two transparent accounts in practice.
+
+Implementation order: Go first, then port to Python. Both apps use the same
+`PaymentsSheetID`, so once Go writes from two accounts the Python code only
+needs to do the same when invoked.
+
+### Decisions locked in with the user
+- **Config style:** hardcoded list of accounts in `config.go` / `config.py`
+  (sheet IDs are already hardcoded; tokens stay env-driven).
+- **Source tagging:** no schema change, `sync_id` formula unchanged.
+- **Old account:** kept syncing in parallel; only QR target changes.
+
+---
+
+## Go implementation
+
+### 1. Config — hardcoded `Accounts` list, derived `QRAccount`
+
+[go/internal/config/config.go](../../go/internal/config/config.go)
+
+- Replace scalar `BankAccount` + `FioAPIToken` with a hardcoded slice and a
+  primary pointer. Tokens stay env-driven via per-account env names.
+
+  ```go
+  // Account describes one Fio bank account we sync from.
+  type Account struct {
+      IBAN     string // e.g. "CZ0820100000002502035405"
+      AcctNum  string // bare account number, e.g. "2502035405"
+      TokenEnv string // env var name holding the Fio API token (empty token => transparent scraper path)
+      Primary  bool   // true for the QR-code default account
+  }
+
+  var Accounts = []Account{
+      {IBAN: "CZ0820100000002502035405", AcctNum: "2502035405", TokenEnv: "FIO_API_TOKEN_NEW", Primary: true},
+      {IBAN: "CZ8520100000002800359168", AcctNum: "2800359168", TokenEnv: "FIO_API_TOKEN_OLD"},
+  }
+  ```
+  Compute the **real** IBAN check digit for `2502035405` once and bake it in
+  (replace the `85` placeholder above). The same `IBANAccountNum` helper at
+  [config.go:66](../../go/internal/config/config.go#L66) keeps producing
+  `AcctNum`, but having it on the struct avoids re-parsing at every call site.
+
+- `Config` struct:
+  - Drop `BankAccount` and `FioAPIToken` fields.
+  - Add `QRAccount string` (the IBAN of `Accounts[i].Primary == true`).
+  - Add `LoadedAccounts []LoadedAccount` where each entry pairs an `Account`
+    with the token resolved from `os.Getenv(account.TokenEnv)`.
+- `Load()` reads each `TokenEnv` and stores tokens with the account. Logs a
+  warning (info-level) if no token is set — that's the transparent-scraper
+  path, which is fine.
+
+### 2. Sync loop — one `fio.Client` per account, single dedup pass
+
+[go/internal/services/banksync/sync.go](../../go/internal/services/banksync/sync.go)
+
+Change `SyncToSheets` to accept a slice of clients instead of one:
+
+```go
+func SyncToSheets(
+    ctx context.Context,
+    spreadsheetID string,
+    fioClients []fio.Client, // was: fioClient fio.Client
+    sh sheetsWriter,
+    opts SyncOpts,
+) (int, error)
+```
+
+Inside:
+
+- Keep steps 1 (read existing IDs) and 2 (date window) as-is.
+- Step 3 (fetch) becomes a loop: call `FetchTransactions` on each client; tag
+  each `fio.Transaction` with the account it came from for logging only
+  (don't write it to the sheet). Concatenate into one slice `txns`.
+- Steps 4a–4c (sync_id calc, debug table, row build, dedup) are unchanged —
+  the combined `txns` slice flows through the same code path. Existing
+  `sync_id` collisions across accounts are dropped silently, which is the
+  desired dedup behaviour.
+- `printFioTable` (dry-run debug) should print an extra column showing the
+  source account so per-account fetches are visible — small change in
+  [fio_table.go](../../go/internal/services/banksync/fio_table.go).
+
+Logger output: log fetched count per account and the total combined count.
+
+### 3. Call sites — build clients from the config list
+
+Both entry points construct `[]fio.Client`, one per `LoadedAccount`:
+
+- [go/cmd/fuj/main.go:91](../../go/cmd/fuj/main.go#L91) — server `BankSync` action.
+- [go/cmd/fuj/main.go:200](../../go/cmd/fuj/main.go#L200) — `fuj sync` CLI.
+
+Helper to add somewhere in `cmd/fuj/main.go` or a new
+`internal/services/banksync/clients.go`:
+
+```go
+func clientsFromConfig(cfg config.Config) []fio.Client {
+    out := make([]fio.Client, 0, len(cfg.LoadedAccounts))
+    for _, a := range cfg.LoadedAccounts {
+        out = append(out, fio.New(a.Token, a.AcctNum, nil))
+    }
+    return out
+}
+```
+
+The existing factory at
+[go/internal/io/fio/client.go:35](../../go/internal/io/fio/client.go#L35)
+already routes per-account between the API path and the transparent scraper
+based on whether the token is empty — no change there.
+
+### 4. QR endpoint — default to `QRAccount`
+
+[go/internal/web/html_handler.go:129](../../go/internal/web/html_handler.go#L129)
+and [html_handler.go:135](../../go/internal/web/html_handler.go#L135):
+swap `h.apiHandler.Config.BankAccount` → `h.apiHandler.Config.QRAccount`.
+
+API DTOs that surface the payment account in JSON:
+[build_adults.go:141](../../go/internal/web/api/build_adults.go#L141) and
+[build_juniors.go:137](../../go/internal/web/api/build_juniors.go#L137) — same
+swap.
+
+The fields on the API structs at
+[adults.go:40](../../go/internal/web/api/adults.go#L40) and
+[juniors.go:39](../../go/internal/web/api/juniors.go#L39) keep their JSON
+names so the Python parity binary doesn't see a schema diff.
+
+### 5. Tests
+
+- **New** [go/internal/services/banksync/sync_test.go](../../go/internal/services/banksync/sync_test.go):
+  add a test `TestSyncToSheets_MultiAccount` that wires up two fake
+  `fio.Client`s (via the existing
+  [fake.go](../../go/internal/io/fio/fake.go)), one returning a txn unique to
+  it and one returning a txn that duplicates an existing sync_id. Assert:
+  rows from both accounts get appended, the duplicate is dropped.
+- **Update** [go/internal/web/html_handler_test.go:207](../../go/internal/web/html_handler_test.go#L207)
+  `TestServeQR` and [qr_test.go](../../go/internal/web/qr_test.go)
+  `TestQRBuildSPD` — expected SPD strings now contain the new IBAN by default.
+- **Update** any config tests asserting `cfg.BankAccount` directly to use
+  `cfg.QRAccount` and the new `LoadedAccounts` slice. (Grep for `BankAccount`
+  under `go/` after the rename.)
+- Existing fio parser tests
+  ([fio_test.go](../../go/internal/io/fio/fio_test.go)) and sync_id test
+  ([synch_test.go](../../go/internal/domain/synch/synch_test.go)) need no
+  changes — they don't know about the account list.
+
+### 6. Verification (Go)
+
+1. `cd go && go build ./... && go test ./...` — all green.
+2. `FIO_API_TOKEN_NEW="" FIO_API_TOKEN_OLD="" ./build/fuj sync --dry-run --print-fio-table --days 7`
+   — see fetched transactions from **both** accounts, with NEW/DUP status,
+   without writing.
+3. `./build/fuj server` then visit
+   `http://localhost:8080/qr?amount=700&message=test` — QR payload SPD must
+   contain the new IBAN `CZ??...2502035405`.
+4. Real sync once dry-run looks right: `./build/fuj sync --days 30` — confirm
+   in the Google sheet that rows from the old account still appear and no
+   duplicates are written.
+
+---
+
+## Python port (after Go is merged)
+
+The Python app uses the same payments sheet and the same column schema, so
+the port mirrors the Go change one-for-one. Goal: one round-trip of
+`make sync-2026` pulls from both accounts.
+
+### 1. `scripts/config.py`
+
+- Replace the scalar `BANK_ACCOUNT` constant at
+  [scripts/config.py:25](../../scripts/config.py#L25) with a hardcoded list
+  plus a derived primary:
+
+  ```python
+  ACCOUNTS = [
+      {"iban": "CZ0820100000002502035405", "acct_num": "2502035405", "token_env": "FIO_API_TOKEN_NEW", "primary": True},
+      {"iban": "CZ8520100000002800359168", "acct_num": "2800359168", "token_env": "FIO_API_TOKEN_OLD", "primary": False},
+  ]
+  BANK_ACCOUNT = next(a["iban"] for a in ACCOUNTS if a["primary"])  # QR / template default
+  ```
+  Use the real check-digit IBAN for `2502035405` (the same one baked into Go).
+
+- Resolve tokens at module load time with `os.environ.get(token_env, "")` and
+  stash them on a parallel `LOADED_ACCOUNTS` list (or attach to the dicts) so
+  other modules don't all re-read env.
+
+### 2. `scripts/fio_utils.py`
+
+- [fio_utils.py:106](../../scripts/fio_utils.py#L106) and
+  [fio_utils.py:219](../../scripts/fio_utils.py#L219): drop the hardcoded
+  `"2800359168"` default for `account_id`. Make it a required argument.
+- `fetch_transactions(date_from, date_to, *, account)` — change signature to
+  take one account dict, return that account's transactions. Internally still
+  routes via `FIO_API_TOKEN` if the account dict has a token, otherwise the
+  transparent scraper at
+  [fio_utils.py:105](../../scripts/fio_utils.py#L105).
+- Add `fetch_transactions_all(date_from, date_to, accounts=None)` that loops
+  over `accounts` (default `config.LOADED_ACCOUNTS`), calls the per-account
+  fetch, concatenates results. Logs per-account counts.
+
+### 3. `scripts/sync_fio_to_sheets.py`
+
+- Where it currently calls `fio_utils.fetch_transactions(...)`, switch to
+  `fio_utils.fetch_transactions_all(...)`. The dedup at
+  [sync_fio_to_sheets.py:62](../../scripts/sync_fio_to_sheets.py#L62) and
+  append at
+  [sync_fio_to_sheets.py:248](../../scripts/sync_fio_to_sheets.py#L248) need
+  no changes — same as in Go, the combined list flows through unchanged.
+
+### 4. `app.py` (QR + template defaults)
+
+- `/qr` at [app.py:321](../../app.py#L321) already reads `BANK_ACCOUNT` from
+  config; since the config default now points at the new IBAN, this is a
+  zero-line change in `app.py`.
+- The `BANK_ACCOUNT` passed into templates at
+  [app.py:180](../../app.py#L180), [app.py:204](../../app.py#L204),
+  [app.py:255](../../app.py#L255), [app.py:291](../../app.py#L291) likewise
+  picks up the new default automatically.
+
+### 5. Tests
+
+The Python suite has **no** existing coverage of `fio_utils`,
+`sync_fio_to_sheets`, or `/qr`. Don't add new tests — keep the port minimal
+and rely on the Go test suite + manual verification for correctness.
+
+### 6. Verification (Python)
+
+1. `make test` — existing suite stays green (the config refactor must not
+   break [tests/test_app.py](../../tests/test_app.py)).
+2. `make sync-2026` against the real sheet, dry-run first if the script
+   supports it, then real run — confirm rows from both accounts arrive.
+3. `make web-debug` → open `/qr?amount=700&message=test` → QR payload SPD
+   contains the new IBAN.
+
+---
+
+## Branching
+
+Per `CLAUDE.md`: this is a feature, so `feat/multi-account-bank-sync` off
+`main`. Two MRs:
+
+1. `feat/multi-account-bank-sync-go` — Go change end-to-end.
+2. `feat/multi-account-bank-sync-py` — Python port, opened after (1) is
+   merged.
+
+Each MR opened via `tea pr create`. CHANGELOG.md entry per MR.
+
+## Out of scope
+
+- No sheet schema migration.
+- No change to `sync_id` hash inputs at
+  [domain/synch/synch.go:14](../../go/internal/domain/synch/synch.go#L14) or
+  [sync_fio_to_sheets.py:67](../../scripts/sync_fio_to_sheets.py#L67).
+- No UI surface for switching the QR account per-request (the existing
+  `?account=` query param on `/qr` keeps working as an override).
+- No backfill / dedup pass over historical rows.

go/cmd/fuj/main.go

@@ -88,7 +88,7 @@ func serverCmd(args []string) {
 		fmt.Fprintf(os.Stderr, "fuj server: sheets client for sync: %v\n", err)
 		os.Exit(1)
 	}
-	fioCli := fio.New(cfg.FioAPIToken, config.IBANAccountNum(cfg.BankAccount), nil)
+	fioClients := buildFioClients(cfg)
 
 	actions := web.ActionHandlers{
 		BankSync: func(ctx context.Context, out io.Writer) error {
@@ -97,7 +97,7 @@ func serverCmd(args []string) {
 			to := time.Date(yr, 12, 31, 23, 59, 59, 0, time.UTC)
 
 			fmt.Fprintln(out, "=== Sync Fio Transactions ===")
-			n, err := banksync.SyncToSheets(ctx, config.PaymentsSheetID, fioCli, sheetsCli,
+			n, err := banksync.SyncToSheets(ctx, config.PaymentsSheetID, fioClients, sheetsCli,
 				banksync.SyncOpts{From: from, To: to, Sort: true})
 			if err != nil {
 				return fmt.Errorf("sync: %w", err)
@@ -197,7 +197,7 @@ func syncCmd(args []string) {
 		fmt.Fprintf(os.Stderr, "fuj sync: sheets client: %v\n", err)
 		os.Exit(1)
 	}
-	fioCli := fio.New(cfg.FioAPIToken, config.IBANAccountNum(cfg.BankAccount), nil)
+	fioClients := buildFioClients(cfg)
 
 	opts := banksync.SyncOpts{Days: *days, Sort: *sort, DryRun: *dryRun, PrintFioTable: *printFioTable}
 	if *fromStr != "" && *toStr != "" {
@@ -213,7 +213,7 @@ func syncCmd(args []string) {
 		}
 	}
 
-	n, err := banksync.SyncToSheets(ctx, config.PaymentsSheetID, fioCli, sheetsCli, opts)
+	n, err := banksync.SyncToSheets(ctx, config.PaymentsSheetID, fioClients, sheetsCli, opts)
 	if err != nil {
 		fmt.Fprintf(os.Stderr, "fuj sync: %v\n", err)
 		os.Exit(1)
@@ -274,3 +274,13 @@ Commands:
   sync        Sync Fio transactions to payments sheet
   infer       Infer payment details in payments sheet`)
 }
+
+// buildFioClients constructs one fio.Client per configured account.
+// Each client uses the account's token if available, otherwise the transparent-scraper path.
+func buildFioClients(cfg config.Config) []fio.Client {
+	clients := make([]fio.Client, 0, len(cfg.LoadedAccounts))
+	for _, a := range cfg.LoadedAccounts {
+		clients = append(clients, fio.New(a.Token, a.AcctNum, nil))
+	}
+	return clients
+}

go/internal/config/config.go

@@ -7,6 +7,28 @@ import (
 	"time"
 )
 
+// Account describes a Fio bank account.
+type Account struct {
+	IBAN     string // e.g. "CZ0820100000002502035405"
+	AcctNum  string // bare account number, e.g. "2502035405"
+	TokenEnv string // env var name holding the optional Fio API token
+	Primary  bool   // true for the account QR codes default to
+}
+
+// LoadedAccount is an Account with its token resolved from the environment.
+type LoadedAccount struct {
+	Account
+	Token string // value of os.Getenv(Account.TokenEnv); empty → transparent-scraper path
+}
+
+// Accounts is the hardcoded list of Fio bank accounts to sync from.
+// The first entry with Primary=true is used for QR codes.
+// Tokens are loaded at runtime from each account's TokenEnv.
+var Accounts = []Account{
+	{IBAN: "CZ0820100000002502035405", AcctNum: "2502035405", TokenEnv: "FIO_API_TOKEN_NEW", Primary: true},
+	{IBAN: "CZ8520100000002800359168", AcctNum: "2800359168", TokenEnv: "FIO_API_TOKEN_OLD"},
+}
+
 // Google Sheets IDs — change in code if sheets change (not from env).
 const (
 	AttendanceSheetID = "1E2e_gT_K5AwSRCDLDTa2UetZTkHmBOcz0kFbBUNUNBA"
@@ -34,28 +56,36 @@ var CacheSheetMap = map[string]string{
 // Mirrors scripts/config.py.
 type Config struct {
 	CredentialsPath  string
-	BankAccount      string
+	QRAccount        string          // IBAN of the primary account used for QR codes
+	LoadedAccounts   []LoadedAccount // all accounts to sync, tokens resolved from env
 	CacheDir         string
 	CacheTTL         time.Duration
 	CacheAPICheckTTL time.Duration
 	DriveTimeout     time.Duration
 	LogLevel         string
-	FioAPIToken      string
 	ServerAddr       string
 }
 
 // Load reads configuration from the environment, applying defaults that
 // match the Python side.
 func Load() Config {
+	loaded := make([]LoadedAccount, len(Accounts))
+	var qrAccount string
+	for i, a := range Accounts {
+		loaded[i] = LoadedAccount{Account: a, Token: os.Getenv(a.TokenEnv)}
+		if a.Primary {
+			qrAccount = a.IBAN
+		}
+	}
 	return Config{
 		CredentialsPath:  env("CREDENTIALS_PATH", ".secret/fuj-management-bot-credentials.json"),
-		BankAccount:      env("BANK_ACCOUNT", "CZ8520100000002800359168"),
+		QRAccount:        qrAccount,
+		LoadedAccounts:   loaded,
 		CacheDir:         env("CACHE_DIR", "tmp/go"),
 		CacheTTL:         envDuration("CACHE_TTL_SECONDS", 300),
 		CacheAPICheckTTL: envDuration("CACHE_API_CHECK_TTL_SECONDS", 300),
 		DriveTimeout:     envDuration("DRIVE_TIMEOUT_SECONDS", 10),
 		LogLevel:         env("LOG_LEVEL", "INFO"),
-		FioAPIToken:      env("FIO_API_TOKEN", ""),
 		ServerAddr:       env("SERVER_ADDR", ":8080"),
 	}
 }

go/internal/domain/fees/fees.go

@@ -11,7 +11,7 @@ const (
 var AdultFeeMonthlyRate = map[string]int{
 	"2025-09": 750, "2025-10": 750, "2025-11": 750, "2025-12": 750,
 	"2026-01": 750, "2026-02": 750, "2026-03": 350,
-	"2026-04": 700, "2026-05": 700,
+	"2026-04": 700, "2026-05": 450, "2026-06": 600, "2026-07": 600, "2026-08": 600,
 }
 
 // CalculateFee returns the adult fee in CZK for attendanceCount practices in

go/internal/domain/reconcile/reconcile.go

@@ -115,10 +115,11 @@ type monthExpected struct {
 	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.
+// Reconcile matches transactions to members and months using two allocation phases:
+//  1. Fill-first: iterate matched months in user-supplied order, allocating min(remaining,
+//     deficit) to each month where deficit = expected − already-paid. Surplus → credit.
+//     Handles both the "greedy" (payment covers all) and "partial" cases in one pass.
+//  2. 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.
@@ -317,34 +318,26 @@ func Reconcile(
 				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
+			if totalExpected > 0 {
+				// Fill-first: iterate inWindow in matched-months order (chronological by
+				// convention), allocating min(remaining, deficit) to each month. Deficit
+				// is net of what prior transactions already paid, so a second payment on
+				// the same months correctly fills only what remains due. Any surplus after
+				// all deficits are covered goes to the credit bucket.
 				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
+				for _, mw := range inWindow {
 					md := ledger[memberName][mw.month]
+					deficit := float64(mw.expected) - md.Paid
+					if deficit < 0 {
+						deficit = 0
+					}
+					alloc := remaining
+					if deficit < alloc {
+						alloc = deficit
+					}
+					if alloc <= 0 {
+						continue
+					}
 					md.Paid += alloc
 					md.Transactions = append(md.Transactions, TxEntry{
 						Amount:     alloc,
@@ -354,6 +347,10 @@ func Reconcile(
 						Confidence: string(m.Confidence),
 					})
 					ledger[memberName][mw.month] = md
+					remaining -= alloc
+				}
+				if remaining > 0 {
+					credits[memberName] += int(remaining)
 				}
 			} else {
 				// Even-split fallback: prepayment before attendance recorded

go/internal/domain/reconcile/reconcile_test.go

@@ -111,36 +111,26 @@ func TestReconcileGreedyOverpaymentGoesToCredit(t *testing.T) {
 	}
 }
 
-func TestReconcileProportionalUnderpayment(t *testing.T) {
+func TestReconcileUnderpaymentFillsEarliestFirst(t *testing.T) {
 	t.Parallel()
 	members := []Member{{
 		Name: "Alice", Tier: "A",
 		Fees: map[string]FeeData{"2026-02": {Expected: 750, Attendance: 3}, "2026-03": {Expected: 350, Attendance: 3}, "2026-04": {Expected: 750, Attendance: 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)
+	result := Reconcile(members, sortedMonths, []Transaction{tx("Alice", "2026-02, 2026-03, 2026-04", 1250)}, 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)
+	// 02 filled first (750), then 03 (350), then remainder 150 to 04
+	if math.Abs(months["2026-02"].Paid-750) > 0.01 {
+		t.Errorf("02: want 750, got %f", months["2026-02"].Paid)
 	}
-	if paid03 >= 350 {
-		t.Errorf("2026-03 should be underpaid, got %f", paid03)
+	if math.Abs(months["2026-03"].Paid-350) > 0.01 {
+		t.Errorf("03: want 350, got %f", months["2026-03"].Paid)
 	}
-	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)
+	if math.Abs(months["2026-04"].Paid-150) > 0.01 {
+		t.Errorf("04: want 150, got %f", months["2026-04"].Paid)
 	}
 }
 
@@ -374,3 +364,52 @@ func TestReconcileNoTransactionsAllUnpaid(t *testing.T) {
 		t.Errorf("no txs: want empty unmatched, got %v", result.Unmatched)
 	}
 }
+
+// Payment < total expected → fill earliest months first, spill remainder to later.
+func TestUnderpaymentFillsEarliestFirst(t *testing.T) {
+	t.Parallel()
+	members := []Member{{Name: "Alice", Tier: "A", Fees: map[string]FeeData{
+		"2026-02": {Expected: 750, Attendance: 3},
+		"2026-03": {Expected: 350, Attendance: 3},
+		"2026-04": {Expected: 750, Attendance: 3},
+	}}}
+	txs := []Transaction{tx("Alice", "2026-02, 2026-03, 2026-04", 1250)}
+
+	result := Reconcile(members, []string{"2026-02", "2026-03", "2026-04"}, txs, nil, defaultYear)
+	months := result.Members["Alice"].Months
+
+	// 02 filled first (750), then 03 (350), then remainder 150 to 04
+	if math.Abs(months["2026-02"].Paid-750) > 0.01 {
+		t.Errorf("02: want 750, got %f", months["2026-02"].Paid)
+	}
+	if math.Abs(months["2026-03"].Paid-350) > 0.01 {
+		t.Errorf("03: want 350, got %f", months["2026-03"].Paid)
+	}
+	if math.Abs(months["2026-04"].Paid-150) > 0.01 {
+		t.Errorf("04: want 150, got %f", months["2026-04"].Paid)
+	}
+}
+
+// Prior txn fills 02 partially; later txn finishes 02 then spills to 03.
+func TestFillFirstAcrossTwoTransactions(t *testing.T) {
+	t.Parallel()
+	members := []Member{{Name: "Matyáš", Tier: "A", Fees: map[string]FeeData{
+		"2026-02": {Expected: 500, Attendance: 2},
+		"2026-03": {Expected: 250, Attendance: 1},
+	}}}
+	sortedMonths := []string{"2026-02", "2026-03"}
+	txs := []Transaction{
+		tx("Matyáš", "2026-02", 200),
+		tx("Matyáš", "2026-02, 2026-03", 550),
+	}
+
+	result := Reconcile(members, sortedMonths, txs, nil, defaultYear)
+	months := result.Members["Matyáš"].Months
+
+	if math.Abs(months["2026-02"].Paid-500) > 0.01 {
+		t.Errorf("02: want 500, got %f", months["2026-02"].Paid)
+	}
+	if math.Abs(months["2026-03"].Paid-250) > 0.01 {
+		t.Errorf("03: want 250, got %f", months["2026-03"].Paid)
+	}
+}

go/internal/services/banksync/sync.go

@@ -35,13 +35,13 @@ type SyncOpts struct {
 	PrintFioTable bool      // with DryRun: print every fetched Fio txn with NEW/DUP status
 }
 
-// SyncToSheets fetches Fio transactions and appends new ones to the payments sheet.
-// Returns the number of rows appended.
+// SyncToSheets fetches Fio transactions from all provided clients and appends
+// new ones to the payments sheet. Returns the number of rows appended.
 // Ports scripts/sync_fio_to_sheets.py sync_to_sheets.
 func SyncToSheets(
 	ctx context.Context,
 	spreadsheetID string,
-	fioClient fio.Client,
+	fioClients []fio.Client,
 	sh sheetsWriter,
 	opts SyncOpts,
 ) (int, error) {
@@ -84,10 +84,14 @@ func SyncToSheets(
 		from = to.AddDate(0, 0, -days)
 	}
 
-	// 3. Fetch Fio transactions.
-	txns, err := fioClient.FetchTransactions(ctx, from, to)
-	if err != nil {
-		return 0, fmt.Errorf("sync: fetch fio: %w", err)
+	// 3. Fetch Fio transactions from each account and combine.
+	var txns []fio.Transaction
+	for _, client := range fioClients {
+		got, err := client.FetchTransactions(ctx, from, to)
+		if err != nil {
+			return 0, fmt.Errorf("sync: fetch fio: %w", err)
+		}
+		txns = append(txns, got...)
 	}
 	if opts.DryRun {
 		fmt.Printf("Dry run: window %s to %s, fetched %d transaction(s) from Fio\n",

go/internal/services/banksync/sync_test.go

@@ -20,7 +20,7 @@ func TestSyncToSheets_EmptySheet(t *testing.T) {
 	}}
 	fioFake := &fio.Fake{Transactions: testFioTxns}
 
-	n, err := SyncToSheets(context.Background(), "SHEETID", fioFake, sh, SyncOpts{Days: 30})
+	n, err := SyncToSheets(context.Background(), "SHEETID", []fio.Client{fioFake}, sh, SyncOpts{Days: 30})
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -51,7 +51,7 @@ func TestSyncToSheets_Dedup(t *testing.T) {
 	}}
 	fioFake := &fio.Fake{Transactions: testFioTxns}
 
-	n, err := SyncToSheets(context.Background(), "SHEETID", fioFake, sh, SyncOpts{Days: 30})
+	n, err := SyncToSheets(context.Background(), "SHEETID", []fio.Client{fioFake}, sh, SyncOpts{Days: 30})
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -72,7 +72,7 @@ func TestSyncToSheets_NoNewTxns(t *testing.T) {
 	}}
 	fioFake := &fio.Fake{Transactions: testFioTxns}
 
-	n, err := SyncToSheets(context.Background(), "SHEETID", fioFake, sh, SyncOpts{Days: 30})
+	n, err := SyncToSheets(context.Background(), "SHEETID", []fio.Client{fioFake}, sh, SyncOpts{Days: 30})
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -92,7 +92,7 @@ func TestSyncToSheets_MissingHeader(t *testing.T) {
 	}}
 	fioFake := &fio.Fake{Transactions: testFioTxns[:1]}
 
-	n, err := SyncToSheets(context.Background(), "SHEETID", fioFake, sh, SyncOpts{Days: 30})
+	n, err := SyncToSheets(context.Background(), "SHEETID", []fio.Client{fioFake}, sh, SyncOpts{Days: 30})
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -105,7 +105,7 @@ func TestSyncToSheets_Sort(t *testing.T) {
 	sh := &sheets.Fake{Values: map[string][][]any{"SHEETID/A1:K": {}}}
 	fioFake := &fio.Fake{Transactions: testFioTxns[:1]}
 
-	_, err := SyncToSheets(context.Background(), "SHEETID", fioFake, sh, SyncOpts{Days: 30, Sort: true})
+	_, err := SyncToSheets(context.Background(), "SHEETID", []fio.Client{fioFake}, sh, SyncOpts{Days: 30, Sort: true})
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -118,7 +118,7 @@ func TestSyncToSheets_ExplicitDateWindow(t *testing.T) {
 
 	from := time.Date(2026, 4, 1, 0, 0, 0, 0, time.UTC)
 	to := time.Date(2026, 4, 30, 0, 0, 0, 0, time.UTC)
-	n, err := SyncToSheets(context.Background(), "SHEETID", fioFake, sh, SyncOpts{From: from, To: to})
+	n, err := SyncToSheets(context.Background(), "SHEETID", []fio.Client{fioFake}, sh, SyncOpts{From: from, To: to})
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -131,7 +131,7 @@ func TestSyncToSheets_DryRun(t *testing.T) {
 	sh := &sheets.Fake{Values: map[string][][]any{"SHEETID/A1:K": {}}}
 	fioFake := &fio.Fake{Transactions: testFioTxns}
 
-	n, err := SyncToSheets(context.Background(), "SHEETID", fioFake, sh,
+	n, err := SyncToSheets(context.Background(), "SHEETID", []fio.Client{fioFake}, sh,
 		SyncOpts{Days: 30, Sort: true, DryRun: true})
 	if err != nil {
 		t.Fatal(err)
@@ -144,6 +144,40 @@ func TestSyncToSheets_DryRun(t *testing.T) {
 	}
 }
 
+func TestSyncToSheets_MultiAccount(t *testing.T) {
+	txnsA := []fio.Transaction{
+		{Date: "2026-04-10", Amount: 700, Sender: "Alice", Message: "april", VS: "1", BankID: "A1"},
+	}
+	txnsB := []fio.Transaction{
+		{Date: "2026-04-11", Amount: 500, Sender: "Bob", Message: "duben", VS: "2", BankID: "B1"},
+	}
+	// One transaction that duplicates the first one from account A (same sync_id).
+	dupID := syncIDFor(txnsA[0])
+	sh := &sheets.Fake{Values: map[string][][]any{
+		"SHEETID/A1:K": {
+			{"Date", "Amount", "manual fix", "Person", "Purpose", "Inferred Amount", "Sender", "VS", "Message", "Bank ID", "Sync ID"},
+			{"2026-04-10", 700.0, "", "", "", "", "Alice", "1", "april", "A1", dupID},
+		},
+	}}
+	fakeA := &fio.Fake{Transactions: txnsA}
+	fakeB := &fio.Fake{Transactions: txnsB}
+
+	n, err := SyncToSheets(context.Background(), "SHEETID", []fio.Client{fakeA, fakeB}, sh, SyncOpts{Days: 30})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if n != 1 {
+		t.Errorf("want 1 new row (B1 from account B; A1 is duplicate), got %d", n)
+	}
+	if len(sh.Appended) != 1 || len(sh.Appended[0].Rows) != 1 {
+		t.Fatalf("want exactly 1 row appended, got %v", sh.Appended)
+	}
+	row := sh.Appended[0].Rows[0]
+	if row[6] != "Bob" {
+		t.Errorf("expected Bob's row, got sender=%v", row[6])
+	}
+}
+
 // syncIDFor mirrors what SyncToSheets computes for a given fio.Transaction.
 func syncIDFor(tx fio.Transaction) string {
 	currency := tx.Currency

go/internal/web/api/build_adults.go

@@ -138,7 +138,7 @@ func buildAdultsResponse(
 		Unmatched:     unmatched,
 		AttendanceURL: "https://docs.google.com/spreadsheets/d/" + config.AttendanceSheetID + "/edit",
 		PaymentsURL:   "https://docs.google.com/spreadsheets/d/" + config.PaymentsSheetID + "/edit",
-		BankAccount:   cfg.BankAccount,
+		BankAccount:   cfg.QRAccount,
 		CurrentMonth:  currentMonth,
 	}
 }

go/internal/web/api/build_juniors.go

@@ -134,7 +134,7 @@ func buildJuniorsResponse(
 		Unmatched:     unmatched,
 		AttendanceURL: juniorURL,
 		PaymentsURL:   "https://docs.google.com/spreadsheets/d/" + config.PaymentsSheetID + "/edit",
-		BankAccount:   cfg.BankAccount,
+		BankAccount:   cfg.QRAccount,
 		CurrentMonth:  currentMonth,
 	}
 }

go/internal/web/assets_test.go

@@ -0,0 +1,93 @@
+package web
+
+import (
+	"io/fs"
+	"net/http"
+	"net/http/httptest"
+	"os"
+	"strings"
+	"testing"
+)
+
+// TestEmbedCompleteness guards against a new template or static file being
+// added to disk but missing from the embedded FS (e.g. a new directory that
+// the //go:embed glob does not match).
+func TestEmbedCompleteness(t *testing.T) {
+	cases := []struct {
+		name      string
+		diskDir   string
+		embedFS   fs.FS
+		embedRoot string
+	}{
+		{"templates", "templates", templateFS, "templates"},
+		{"static", "static", staticFS, "static"},
+	}
+
+	for _, tc := range cases {
+		t.Run(tc.name, func(t *testing.T) {
+			diskFS := os.DirFS(tc.diskDir)
+			_ = fs.WalkDir(diskFS, ".", func(path string, d fs.DirEntry, err error) error {
+				if err != nil || d.IsDir() {
+					return err
+				}
+				embPath := tc.embedRoot + "/" + path
+				if _, statErr := fs.Stat(tc.embedFS, embPath); statErr != nil {
+					t.Errorf("file %q exists on disk but is missing from embed.FS (%v)", embPath, statErr)
+				}
+				return nil
+			})
+		})
+	}
+}
+
+// TestStaticAssetsServed verifies that /static/* is served from the embedded
+// FS through the same mux wiring used in server.go, so a standalone binary
+// with no adjacent static/ directory still delivers assets.
+func TestStaticAssetsServed(t *testing.T) {
+	subFS, err := fs.Sub(staticFS, "static")
+	if err != nil {
+		t.Fatalf("fs.Sub static: %v", err)
+	}
+	mux := http.NewServeMux()
+	mux.Handle("/static/", http.StripPrefix("/static/", http.FileServerFS(subFS)))
+
+	cases := []struct {
+		path        string
+		wantCT      string
+		wantSnippet string
+	}{
+		{"/static/css/app.css", "text/css", "body {"},
+		{"/static/js/member-detail.js", "javascript", "Member-detail modal"},
+		{"/static/js/filters.js", "javascript", ""},
+		{"/static/js/payment-qr.js", "javascript", ""},
+	}
+
+	for _, tc := range cases {
+		t.Run(tc.path, func(t *testing.T) {
+			req := httptest.NewRequest(http.MethodGet, tc.path, nil)
+			w := httptest.NewRecorder()
+			mux.ServeHTTP(w, req)
+
+			if w.Code != http.StatusOK {
+				t.Fatalf("GET %s: status %d, want 200", tc.path, w.Code)
+			}
+			ct := w.Header().Get("Content-Type")
+			if !strings.Contains(ct, tc.wantCT) {
+				t.Errorf("GET %s: Content-Type %q, want it to contain %q", tc.path, ct, tc.wantCT)
+			}
+			if tc.wantSnippet != "" && !strings.Contains(w.Body.String(), tc.wantSnippet) {
+				t.Errorf("GET %s: body missing expected snippet %q", tc.path, tc.wantSnippet)
+			}
+		})
+	}
+
+	// Sanity: unknown path → 404 (file server doesn't fall through silently)
+	t.Run("missing-file", func(t *testing.T) {
+		req := httptest.NewRequest(http.MethodGet, "/static/css/nonexistent.css", nil)
+		w := httptest.NewRecorder()
+		mux.ServeHTTP(w, req)
+		if w.Code != http.StatusNotFound {
+			t.Errorf("unknown static path: status %d, want 404", w.Code)
+		}
+	})
+}

go/internal/web/html_handler.go

@@ -126,13 +126,13 @@ func (h *HTMLHandler) ServeQR(w http.ResponseWriter, r *http.Request) {
 	amount := q.Get("amount")
 	message := q.Get("message")
 	if account == "" {
-		account = h.apiHandler.Config.BankAccount
+		account = h.apiHandler.Config.QRAccount
 	}
 	if amount == "" {
 		amount = "0"
 	}
 
-	payload := BuildSPD(account, amount, message, h.apiHandler.Config.BankAccount)
+	payload := BuildSPD(account, amount, message, h.apiHandler.Config.QRAccount)
 	png, err := RenderQRCode(payload)
 	if err != nil {
 		http.Error(w, "qr encode: "+err.Error(), http.StatusInternalServerError)

go/internal/web/html_handler_test.go

@@ -50,7 +50,7 @@ func fixtureHandler(t *testing.T) *api.Handler {
 	t.Helper()
 	return &api.Handler{
 		Sources: fixtureSources{},
-		Config:  config.Config{BankAccount: "CZ0000000000000000000000"},
+		Config:  config.Config{QRAccount: "CZ0000000000000000000000"},
 	}
 }
 

go/tests/fixtures/reconcile/03_proportional_remainder.json

@@ -1,7 +1,7 @@
 {
   "case": "03_proportional_remainder",
   "func": "scripts.match_payments.reconcile",
-  "captured_at": "2026-05-06",
+  "captured_at": "2026-05-11",
   "input": {
     "members": [
       {
@@ -54,10 +54,10 @@
             "original_expected": 750,
             "attendance_count": 3,
             "exception": null,
-            "paid": 324.3243243243243,
+            "paid": 750.0,
             "transactions": [
               {
-                "amount": 324.3243243243243,
+                "amount": 750.0,
                 "date": "2026-03-10",
                 "sender": "Member_d035d9f9",
                 "message": "",
@@ -70,10 +70,10 @@
             "original_expected": 750,
             "attendance_count": 2,
             "exception": null,
-            "paid": 324.3243243243243,
+            "paid": 50.0,
             "transactions": [
               {
-                "amount": 324.3243243243243,
+                "amount": 50.0,
                 "date": "2026-03-10",
                 "sender": "Member_d035d9f9",
                 "message": "",
@@ -86,25 +86,17 @@
             "original_expected": 350,
             "attendance_count": 2,
             "exception": null,
-            "paid": 151.35135135135135,
-            "transactions": [
-              {
-                "amount": 151.35135135135135,
-                "date": "2026-03-10",
-                "sender": "Member_d035d9f9",
-                "message": "",
-                "confidence": "auto"
-              }
-            ]
+            "paid": 0,
+            "transactions": []
           }
         },
         "other_transactions": [],
-        "total_balance": -1051
+        "total_balance": -1050
       }
     },
     "unmatched": [],
     "credits": {
-      "Member_d035d9f9": -1051
+      "Member_d035d9f9": -1050
     }
   }
 }

go/tests/fixtures/reconcile/09_multiperson_multimonth.json

@@ -1,7 +1,7 @@
 {
   "case": "09_multiperson_multimonth",
   "func": "scripts.match_payments.reconcile",
-  "captured_at": "2026-05-06",
+  "captured_at": "2026-05-11",
   "input": {
     "members": [
       {
@@ -63,10 +63,10 @@
             "original_expected": 750,
             "attendance_count": 3,
             "exception": null,
-            "paid": 500.0,
+            "paid": 750.0,
             "transactions": [
               {
-                "amount": 500.0,
+                "amount": 750.0,
                 "date": "2026-02-15",
                 "sender": "Member_d035d9f9",
                 "message": "",
@@ -79,10 +79,10 @@
             "original_expected": 750,
             "attendance_count": 2,
             "exception": null,
-            "paid": 500.0,
+            "paid": 250.0,
             "transactions": [
               {
-                "amount": 500.0,
+                "amount": 250.0,
                 "date": "2026-02-15",
                 "sender": "Member_d035d9f9",
                 "message": "",
@@ -102,10 +102,10 @@
             "original_expected": 750,
             "attendance_count": 2,
             "exception": null,
-            "paid": 681.8181818181819,
+            "paid": 750.0,
             "transactions": [
               {
-                "amount": 681.8181818181819,
+                "amount": 750.0,
                 "date": "2026-02-15",
                 "sender": "Member_d035d9f9",
                 "message": "",
@@ -118,10 +118,10 @@
             "original_expected": 350,
             "attendance_count": 2,
             "exception": null,
-            "paid": 318.18181818181813,
+            "paid": 250.0,
             "transactions": [
               {
-                "amount": 318.18181818181813,
+                "amount": 250.0,
                 "date": "2026-02-15",
                 "sender": "Member_d035d9f9",
                 "message": "",
@@ -131,13 +131,13 @@
           }
         },
         "other_transactions": [],
-        "total_balance": -101
+        "total_balance": -100
       }
     },
     "unmatched": [],
     "credits": {
       "Member_d035d9f9": -500,
-      "Member_f4a93e46": -101
+      "Member_f4a93e46": -100
     }
   }
 }

scripts/attendance.py

@@ -21,7 +21,10 @@ ADULT_FEE_MONTHLY_RATE = {
     "2026-02": 750,
     "2026-03": 350,
     "2026-04": 700,
-    "2026-05": 700,
+    "2026-05": 450,
+    "2026-06": 600,
+    "2026-07": 600,
+    "2026-08": 600,
 }
 
 JUNIOR_FEE_DEFAULT = 500  # CZK for 2+ practices

scripts/config.py

@@ -21,8 +21,18 @@ PAYMENTS_SHEET_ID = "1Om0YPoDVCH5cV8BrNz5LG5eR5MMU05ypQC7UMN1xn_Y"
 # Attendance sheet tab GIDs
 JUNIOR_SHEET_GID = "1213318614"
 
-# Bank
-BANK_ACCOUNT = os.environ.get("BANK_ACCOUNT", "CZ8520100000002800359168")
+# Bank accounts — hardcoded list mirroring go/internal/config/config.go.
+# The entry with primary=True is used for QR codes and as the BANK_ACCOUNT default.
+ACCOUNTS = [
+    {"iban": "CZ0820100000002502035405", "acct_num": "2502035405", "token_env": "FIO_API_TOKEN_NEW", "primary": True},
+    {"iban": "CZ8520100000002800359168", "acct_num": "2800359168", "token_env": "FIO_API_TOKEN_OLD", "primary": False},
+]
+# Resolve API tokens from the environment once at import time.
+LOADED_ACCOUNTS = [
+    {**a, "token": os.environ.get(a["token_env"], "")}
+    for a in ACCOUNTS
+]
+BANK_ACCOUNT = next(a["iban"] for a in ACCOUNTS if a["primary"])
 
 # Cache settings
 CACHE_DIR = PROJECT_ROOT / "tmp"

scripts/fio_utils.py

@@ -103,7 +103,7 @@ def parse_czech_date(s: str) -> str | None:
 
 
 def fetch_transactions_transparent(
-    date_from: str, date_to: str, account_id: str = "2800359168"
+    date_from: str, date_to: str, account_id: str
 ) -> list[dict]:
     """Fetch transactions from Fio transparent account HTML page.
 
@@ -206,22 +206,47 @@ def fetch_transactions_api(
     return transactions
 
 
-def fetch_transactions(date_from: str, date_to: str) -> list[dict]:
-    """Fetch transactions, using API if token available, else transparent page."""
-    token = os.environ.get("FIO_API_TOKEN", "").strip()
+def fetch_transactions_for(account: dict, date_from: str, date_to: str) -> list[dict]:
+    """Fetch transactions for a single loaded account dict (from config.LOADED_ACCOUNTS).
+
+    Uses the API path if the account has a token, otherwise the transparent scraper.
+    date_from/date_to: YYYY-MM-DD.
+    """
+    token = (account.get("token") or "").strip()
+    acct_num = account["acct_num"]
     if token:
-        print(f"fio: using authenticated API, window {date_from}..{date_to}", file=sys.stderr)
+        print(f"fio: account {acct_num}: using authenticated API, window {date_from}..{date_to}", file=sys.stderr)
         return fetch_transactions_api(token, date_from, date_to)
 
     print(
-        f"fio: using transparent page (FIO_API_TOKEN unset — expect publishing lag), "
-        f"window {date_from}..{date_to}, account=2800359168",
+        f"fio: account {acct_num}: using transparent page (no token — expect publishing lag), "
+        f"window {date_from}..{date_to}",
         file=sys.stderr,
     )
-    # Convert YYYY-MM-DD to DD.MM.YYYY for the transparent page URL
     from_dt = datetime.strptime(date_from, "%Y-%m-%d")
     to_dt = datetime.strptime(date_to, "%Y-%m-%d")
     return fetch_transactions_transparent(
         from_dt.strftime("%d.%m.%Y"),
         to_dt.strftime("%d.%m.%Y"),
+        account_id=acct_num,
     )
+
+
+def fetch_transactions_all(
+    date_from: str, date_to: str, accounts: list[dict] | None = None
+) -> list[dict]:
+    """Fetch and combine transactions from all configured accounts.
+
+    accounts: list of loaded account dicts (defaults to config.LOADED_ACCOUNTS).
+    Returns a flat list of all transactions across all accounts.
+    """
+    if accounts is None:
+        from config import LOADED_ACCOUNTS
+        accounts = LOADED_ACCOUNTS
+    all_txns: list[dict] = []
+    for account in accounts:
+        txns = fetch_transactions_for(account, date_from, date_to)
+        print(f"fio: account {account['acct_num']}: {len(txns)} transaction(s)", file=sys.stderr)
+        all_txns.extend(txns)
+    print(f"fio: total {len(all_txns)} transaction(s) across {len(accounts)} account(s)", file=sys.stderr)
+    return all_txns

scripts/match_payments.py

@@ -468,26 +468,19 @@ def reconcile(
 
             total_expected = sum(e for _, e in in_window)
 
-            if total_expected > 0 and in_window_share >= total_expected:
-                # Greedy phase: payment covers all in-window fees; overflow → credit.
-                credits[member_name] = credits.get(member_name, 0) + int(in_window_share - total_expected)
-                for m, exp in in_window:
-                    alloc = float(exp)
-                    ledger[member_name][m]["paid"] += alloc
-                    ledger[member_name][m]["transactions"].append({
-                        "amount": alloc,
-                        "date": tx["date"],
-                        "sender": tx["sender"],
-                        "message": tx["message"],
-                        "confidence": confidence,
-                    })
-            elif total_expected > 0:
-                # Proportional phase: distribute in_window_share by each month's expected fee.
-                # Last month absorbs any float remainder so the sum equals in_window_share exactly.
+            if total_expected > 0:
+                # Fill-first: iterate in_window in matched_months order (chronological by
+                # convention from infer_payments.py), allocating min(remaining, deficit) to
+                # each month. Deficit is net of what prior transactions already paid, so a
+                # second payment on the same months correctly fills only what remains due.
+                # Any surplus after all deficits are covered goes to the credit bucket.
                 remaining = in_window_share
-                for i, (m, exp) in enumerate(in_window):
-                    alloc = remaining if i == len(in_window) - 1 else in_window_share * exp / total_expected
-                    remaining -= alloc
+                for m, exp in in_window:
+                    paid_so_far = ledger[member_name][m]["paid"]
+                    deficit = max(0.0, float(exp) - paid_so_far)
+                    alloc = min(remaining, deficit)
+                    if alloc <= 0:
+                        continue
                     ledger[member_name][m]["paid"] += alloc
                     ledger[member_name][m]["transactions"].append({
                         "amount": alloc,
@@ -496,6 +489,9 @@ def reconcile(
                         "message": tx["message"],
                         "confidence": confidence,
                     })
+                    remaining -= alloc
+                if remaining > 0:
+                    credits[member_name] = credits.get(member_name, 0) + int(remaining)
             else:
                 # Fallback: no expected fees (prepayment before attendance recorded); even split.
                 per_month = in_window_share / len(in_window)

scripts/sync_fio_to_sheets.py

@@ -12,7 +12,7 @@ from google_auth_oauthlib.flow import InstalledAppFlow
 from google.oauth2 import service_account
 from googleapiclient.discovery import build
 
-from fio_utils import fetch_transactions
+from fio_utils import fetch_transactions_all
 
 from config import PAYMENTS_SHEET_ID as DEFAULT_SPREADSHEET_ID
 SCOPES = ["https://www.googleapis.com/auth/spreadsheets"]
@@ -188,7 +188,7 @@ def sync_to_sheets(
         dt_str = date_to.strftime("%Y-%m-%d")
 
     print(f"Fetching Fio transactions from {df_str} to {dt_str}...")
-    transactions = fetch_transactions(df_str, dt_str)
+    transactions = fetch_transactions_all(df_str, dt_str)
     print(f"Found {len(transactions)} transactions.")
 
     if dry_run:

tests/test_reconcile_exceptions.py

@@ -93,8 +93,8 @@ class TestMultiMonthAllocation(unittest.TestCase):
         self.assertEqual(int(months['2026-02']['paid']), 750)
         self.assertEqual(result['credits'].get('Alice', 0), 500)
 
-    def test_proportional_underpayment(self):
-        """Payment < total expected → proportional split; sum of paid == payment amount."""
+    def test_underpayment_fills_earliest_first(self):
+        """Payment < total expected → fill earliest months first, spill remainder to later."""
         members = [('Alice', 'A', {'2026-02': (750, 3), '2026-03': (350, 3), '2026-04': (750, 3)})]
         sorted_months = ['2026-02', '2026-03', '2026-04']
         amount = 1250
@@ -103,18 +103,28 @@ class TestMultiMonthAllocation(unittest.TestCase):
         result = reconcile(members, sorted_months, [tx])
         months = result['members']['Alice']['months']
 
-        paid_02 = months['2026-02']['paid']
-        paid_03 = months['2026-03']['paid']
-        paid_04 = months['2026-04']['paid']
+        # 02 filled first (750), then 03 (350), then remainder 150 to 04
+        self.assertAlmostEqual(months['2026-02']['paid'], 750, places=2)
+        self.assertAlmostEqual(months['2026-03']['paid'], 350, places=2)
+        self.assertAlmostEqual(months['2026-04']['paid'], 150, places=2)
+        # No CZK lost
+        self.assertAlmostEqual(
+            months['2026-02']['paid'] + months['2026-03']['paid'] + months['2026-04']['paid'],
+            amount, places=2,
+        )
 
-        # All months should be partial (underpaid)
-        self.assertLess(paid_02, 750)
-        self.assertLess(paid_03, 350)
-        self.assertLess(paid_04, 750)
-        # Sum must equal the original payment (no CZK lost)
-        self.assertAlmostEqual(paid_02 + paid_03 + paid_04, amount, places=2)
-        # 02 and 04 have equal expected → equal allocation
-        self.assertAlmostEqual(paid_02, paid_04, places=2)
+    def test_fill_first_across_two_transactions(self):
+        """Prior txn fills 02 partially; later txn finishes 02 then spills to 03."""
+        members = [('Matyáš', 'A', {'2026-02': (500, 2), '2026-03': (250, 1)})]
+        sorted_months = ['2026-02', '2026-03']
+        tx1 = _tx('Matyáš', '2026-02', 200)
+        tx2 = _tx('Matyáš', '2026-02, 2026-03', 550)
+
+        result = reconcile(members, sorted_months, [tx1, tx2])
+        months = result['members']['Matyáš']['months']
+
+        self.assertAlmostEqual(months['2026-02']['paid'], 500, places=2)
+        self.assertAlmostEqual(months['2026-03']['paid'], 250, places=2)
 
     def test_single_month_unchanged(self):
         """Single-month payment: full amount goes to that month (regression guard)."""