Motzkin Legends — Prediction League

Private prediction game for a closed friend group. One manager (you) approves participants each round after they pay via Paybox; participants predict the score of 7 Israeli league matches per round and compete for a jackpot.

Live: https://motzkin-legends.vercel.app Repo: https://github.com/Shlitay/motzkin-legends Supabase project: teuqvtarqminvutoozsx Manager account: [email protected] (must have role = 'manager' in the users table — see below if it ever needs re-setting)

Status: real, deployed, and live-tested with real friends

This is not a mock-data demo anymore. Google login, onboarding, predictions, payment-approval requests, manager approve/reject, and both leaderboards all read and write the real Supabase database. As of this writing, 6 real participants have registered and set round 1 predictions.

The whole UI is Hebrew + RTL (converted 2026-08-21, straight replace — no language toggle exists or is planned). <html lang="he" dir="rtl"> in src/app/layout.tsx drives the mirroring; see "Design system" below for the font swap this required.

Getting started (local dev)

npm install   # if you haven't already
npm run dev

Open http://localhost:3000. Needs .env.local with NEXT_PUBLIC_SUPABASE_URL and NEXT_PUBLIC_SUPABASE_ANON_KEY (gitignored, already set up locally — values are the same as the Vercel env vars below).

NEXT_PUBLIC_SUPABASE_URL=https://teuqvtarqminvutoozsx.supabase.co
NEXT_PUBLIC_SUPABASE_ANON_KEY=sb_publishable_-f7C2NCsa3oGQxFT3aHEtw_vDxNLmyf

Deploys automatically on every push to master via Vercel's GitHub integration — no manual deploy step needed.

What's built and real

Auth

• Real Google OAuth via Supabase Auth (src/lib/supabase/{client,server,middleware}.ts, src/proxy.ts — Next.js 16 renamed middleware.ts → proxy.ts, same thing)
• src/app/auth/callback/route.ts exchanges the OAuth code, routes to /onboarding only if avatar/default-score are still unset on the profile row
• proxy.ts refreshes the session every request and gate-keeps /manager/* behind role = 'manager' — real server-side protection
• Google OAuth consent screen is published (not Testing mode) — any Google account can log in, no allow-listing needed
• rls.sql — Row Level Security on every table. Shared game data (rounds/matches/teams/scoring) is world-readable, manager-only-writable. Each user reads/writes only their own profile & predictions. A trigger blocks self-promotion to role = 'manager' through the app — that can only be set directly in SQL

Pages (src/app/), all wired to real data:

• / and /manager/login — real Google sign-in

• /onboarding — required first login: avatar + default score, writes to users

• /home — removed 2026-09-20. /predictions is now the landing page after login (callback, onboarding, middleware and the login button all point there); /home remains only as a redirect to /predictions (next.config.ts) for old bookmarks. The avatar/name header, the two stat cards and the round-comments section went with it — participants check their own stats by tapping their row on /leaderboard.

• Round approval status (RoundApprovalStatus.tsx) — self-contained (fetches its own open round + the current user's round_participation status), shown on /home, /predictions, /leaderboard, /rules (not /manager — the manager account doesn't participate). Status is color-coded: waiting = light orange (border-draw/bg-draw) with a clock icon, approved = light green (border-brand/bg-brand) with a checkmark icon, rejected = plain card with red text (not color-coded — wasn't asked for). Since 2026-09-08, /predictions' sendPrediction() is what actually puts a participant onto the manager's approval list — it upserts a round_participation row (ignoreDuplicates: true, so it only ever creates one, never overwrites an existing waiting/approved/rejected status) alongside the predictions upsert, since submitting predictions is itself proof of intent to play. This component's status === null state (no round_participation row yet) dropped its "תאשר אותי שלחתי כסף" button and the separate "לקבוצת פייבוקס" button entirely — the confirm-click it used to do is now redundant with submitting predictions, and the group-link button was redundant with the inline Paybox link already in the sentence above it. What's left is just that one line of text with the inline link.

• Round countdown (RoundCountdown.tsx) — same 4 pages as the approval card, a live days/hours/minutes/seconds countdown to the open round's deadline_at, ticking every second. The countdown math itself is plain epoch-millisecond subtraction (always correct, timezone doesn't matter for a duration). The displayed kickoff clock time underneath, and /predictions' own deadline caption, both go through () — explicit conversion, not the viewer's own device timezone, since match kickoffs are inherently Israel-local (this replaced ' old , which implicitly used the browser's local timezone — technically correct today since real participants are in Israel, but wrong if anyone ever checked from abroad).

News ticker (NewsTicker.tsx) — a scrolling marquee shown on /predictions, /leaderboard, /rules, and /manager. Since 2026-10-28 every item is automatic (the manager-editable news_strip slots and /manager's "רצועת חדשות" modal were removed; the table is left in place, unread): (1) approved participants for the current round, (2) the last finished round's rank-1 winner + payout (same pot rule as /leaderboard's crown: round_participant_count × entry fee − one entry fee), (3) the current round's match count. Each item is its own dir="rtl" span so a Latin nickname or trailing digit can't reorder against the separators. RTL note: the ticker is forced dir="ltr" — under the page's global RTL, a flex row's natural resting position anchors to its right edge and only extends leftward, so the standard duplicate-content-and-translateX(-50%) marquee trick just shrinks the visible content into a growing blank gap instead of looping. This bit twice before being caught with an isolated Playwright test (multi-frame screenshots of the animation, not just a static one) — same fix pattern as the "1X2" logo and the countdown digits.

Header (TopBar.tsx) — now has a solid white background + 1px bottom border (previously transparent, floating over content), fixed + z-40 so it stays pinned above all normal page content while scrolling. Deliberately kept below z-50, which every modal (ProfileModal, ScoringRulesModal, NewsStripModal, ParticipantModal) uses — a header above the modal layer would poke through a modal's dimmed backdrop instead of being covered by it. Three things live in it besides the logo:

• Jackpot badge (JackpotBadge.tsx) — gold gradient pill, white text, approved-participant count × a hardcoded ₪20 entry fee (ENTRY_FEE_ILS in the component — not manager-configurable, revisit if the buy-in ever changes). Hides itself if there's no open round. Has a looping shine/glint sweep (.shine-badge in globals.css, respects prefers-reduced-motion) — sized to fit the 4-item header at a 390px mobile width without pushing the manager/back link off-screen; verified with zoomed-in Playwright screenshots across the animation cycle since the effect is too subtle to confirm from a single static frame.
• Invite-friends button (InviteFriendsButton.tsx) — builds {origin}?utm_source=shareBtn&utm_medium={full_name} from the current user's Google full_name (not nickname — "the name from Google" specifically), e.g. "Itay Arad" → utm_medium=itay_arad. Uses the native share sheet (navigator.share) on mobile, falls back to clipboard copy on desktop. Changed 2026-08-23 from a bespoke ?ref={slug} param (which nothing ever read) to real utm_source/utm_medium — GA4 parses these natively into its own Acquisition reports (Session source/medium), so who-shared-what is visible in standard GA4 reports with no custom event code. Still not tied to a specific resulting app user/signup — GA4 sessions are anonymous (client_id), so this shows traffic per referrer, not a definitive "this exact account came from this exact link." A users.referred_by column + onboarding write would be needed for that; deliberately not built (asked, declined for now).
• The manager/back-action link (unchanged, existing resolvedAction prop).

Every page's <main> reserves top padding to clear this fixed header — pt-28 (112px) was calibrated to the old, shorter transparent header and never revisited after the background/badge/button additions made it taller. Measured the real rendered header height with a throwaway route + Playwright bounding-box check (77px) rather than guessing from the Tailwind classes, then set pt-20 (80px, a ~3px buffer) everywhere pt-28 appeared — cut the dead space between the header and each page's first content block without risking clipping.

Favicon (src/app/icon.svg) — Next.js's static-file convention (auto-detected, no layout.tsx metadata needed): the "1X2" mark, white on a turf-green rounded square.

Analytics — Google Analytics 4 (Measurement ID G-GX7JT1JLL4), gated behind Analytics.tsx rather than rendering <GoogleAnalytics> (from @next/third-parties/google) directly. On mount it checks auth.getUser() + the users.role column, and skips loading GA entirely when the logged-in user is the manager — excludes the manager's own usage from the numbers without relying on GA4's IP-based "internal traffic" filters (unreliable across the manager's different devices/networks). Anonymous visitors (not logged in yet, e.g. the login page) are still tracked; only a known manager session is excluded. Verified empirically with a headless-browser network check that the gtag.js request actually fires for an anonymous visitor — the manager-exclusion path itself couldn't be verified the same way (no real login available in the dev environment) but reuses the identical role-lookup pattern TopBar.tsx already uses successfully in production.

Profile (ProfileModal.tsx) — real avatar picker, real default-score editor, and a nickname field (shown instead of the Google name everywhere a name displays; falls back to the Google name when unset).

Design system — "Home Pitch" kit (turf green + trophy gold):

• Tailwind v4 theme tokens in src/app/globals.css
• Oswald (numeric displays only — scores, ranks, counts) + Heebo (body text and headings, Hebrew+Latin) via next/font/google; Caveat (handwriting) for the logo signature only. Heebo replaced Work Sans on 2026-08-21 — Work Sans has no Hebrew glyphs at all, so it silently fell back to a mismatched system font once the UI went Hebrew.
• Logo: "1X2" wordmark (plain text, no border box) + handwritten "Motzkin Legends" — Logo.tsx (large, login hero), TopBar.tsx (compact, fixed top bar, links back to /predictions on every page). Brand name stays in Latin script even in the Hebrew UI (decided during the RTL conversion) — the OneXTwoIcon SVG in icons.tsx has an explicit direction: ltr style, since SVG <text> inherits the page's dir otherwise and clips/misplaces glyphs (hit this for real during the RTL conversion — the "1" disappeared until that fix landed).
• A living style guide (3 kit alternatives) was built as a Claude Artifact during design — not part of this repo, ask if you want it re-shared

Database migrations — run in this order on a fresh Supabase project

If ever setting this up again from scratch (or double-checking the current project has everything applied), run these in the SQL editor in order:

1. schema.sql — full data model
2. rls.sql — Row Level Security policies
3. seed-round1.sql — creates the season, round 1, and its 7 matches
4. fix-default-score-nullability.sql — fixes a bug where default scores defaulted to 1 instead of null, which broke the "needs onboarding" check (already applied on the live project)
5. add-avatar-to-season-stats.sql — extends the season_stats view with avatar (already applied)
6. add-nickname.sql — adds the nickname column + extends season_stats with display_name (already applied, but worth double-checking if anything nickname-related ever errors)
7. add-round-comments.sql — creates the round_comments table + RLS for the round discussion feature, removed from the UI 2026-09-20 (table still exists, unused; already applied)
8. add-lock-expired-rounds-function.sql — creates lock_expired_rounds(), called lazily by the app (on /predictions, /leaderboard, /manager load) to lock a round and fill per-match default scores once its deadline passes. It's a no-op for any round whose deadline hasn't passed yet, so applying it doesn't touch round 1's current data (already applied)
9. add-news-strip.sql — creates the singleton news_strip table + RLS for the manager-editable news ticker (already applied)
10. add-round-comments-delete-policy.sql — adds a delete RLS policy so a participant can delete their own round comment (to free up their one-per-round slot and post a new one). Not yet applied — run this before the "Delete" button on /home comments will work.
11. add-hebrew-team-names.sql — translates teams.name and round 1's existing matches.home_team/away_team text to Hebrew, as part of the Hebrew/RTL conversion. Pure UPDATE of existing rows' text (both tables are free text, not foreign-keyed), doesn't touch predictions/round_participation at all. Applied — /predictions shows Hebrew club names and matching crests.
12. add-submit-match-result-function.sql — creates submit_match_result(), called from /manager's "תוצאות מחזור" screen once per match saved: records the score and recomputes every affected participant's //// for the whole round in one go (already applied — , which changes this function's signature).

App-side enforcement (/predictions): predictionsOpen = !predictions_open_at || now >= predictions_open_at. Feeds into the same readOnly gate as isOpenRound/submitted (score inputs, submit button), plus a new amber note card ("הגשת ניחושים למחזור X תיפתח ב-... אפשר כבר עכשיו לשלוח תשלום דרך Paybox") shown only while isOpenRound && !predictionsOpen. Like the existing deadline check, this is enforced client-side only, not at the DB/RLS level — matches rls.sql's own documented limitation ("prediction insert/update isn't deadline-checked here... enforced app-side for now"), not a new gap. 28. fix-season-stats-rounds-played.sql — real bug fix (found 2026-09-01, once round 3's new approvals started showing up before round 3 had begun): season_stats.rounds_played counted payment_status = 'approved' regardless of whether that round had actually started, so being approved for a still-open round already counted as a "played" round on /leaderboard's "הכי הרבה השתתפויות" table. create or replace view adds and r.status <> 'open' (via a new join to rounds) to both rounds_played and avg_points's filter clause — total_points/season_hits/season_towards didn't need the same fix, since an unstarted round's points/hits/towards are already 0/null. Superseded by migration 29 below. 29. fix-season-stats-rounds-played-v2.sql — migration 28 still wasn't right: it depended on current payment_status = 'approved', but /manager's "reset approved participants" action (added earlier the same session) sets payment_status back to waiting for an already-finished round to prep the next one's signups — which then silently erased rounds_played for anyone reset, even though they genuinely played and scored (their total_points/rank were never touched, only payment_status). Real fix: for a round with status <> 'open', participation is now determined by whether the user actually has rows in predictions for that round's matches (an exists subquery, immune to the reset action, since sendPrediction()/backfill_late_approval() are the only things that ever write to predictions). Not yet applied. 30. add-round-participant-count-function.sql — migration 29's fix wasn't quite enough either: 's round-winner payout still showed 0 after being updated to count distinct for the round, because that count came from a query run — fully subject to RLS for whoever's logged in. Once round 2's approvals were reset, the could lose access to for round 2, so they'd only see their own predictions, undercounting everyone else's. Adds , a SQL function (same mechanism already uses) that bypasses RLS entirely — now calls this via instead of querying directly. Also explicitly sets 's , belt-and-suspenders for migration 29's own subquery, which runs inside a view and already default to bypassing RLS via the view owner's permissions in Postgres 15+, but wasn't worth leaving to an unconfirmed default. 31. — creates round 4's 7 matches (added 2026-09-08), same shape/pattern as //. Fixture source: user-provided 365scores.com screenshot, checked 2026-09-08. All 14 teams already have entries in () — no new crests needed, every team name string re-verified byte-for-byte against the existing keys. Kickoff times converted from the screenshot's Israel-local display to UTC (−3h), same convention as round 3. Unlike round 3 (which needed a follow-up in migration 27, since the column didn't exist yet at seed time), is set directly in this seed's own — the column already exists — to the preceding Thursday 20:00 Israel time (2026-09-10 17:00 UTC), the established house rule. is the first match's kickoff (2026-09-13 17:30 UTC = 20:30 Israel time), matching the existing "deadline = first kickoff" convention. 32. — companion to ' new per-day locking (see that section above), found while implementing it: 's default-prediction backfill previously fired once, for every match in the round at once, at the exact moment the round's status flipped → (the round's very first kickoff) — which would've defaulted later-day matches (e.g. round 4's Monday/Tuesday games) the instant the first day's game started, defeating per-day locking entirely. , same signature: moves that backfill out of the transition step and into the existing loop that already seeds 0-0 into kicked-off-but-unscored matches one round at a time, gating it the same way — — so a match only gets defaulted once its own kickoff has actually passed. 33. — one-time DATA repair (found 2026-09-08 investigating showing an empty "נקודות מחזור 3" table): round 3's had despite being fully played and scored (7 matches, ) — confirmed via a diagnostic join against / counts per round (round 1: 9/9, round 2: 7/7, round 3: 7/0). Root cause not identified — nothing in this repo's migration history ever deletes from — but / (the real source of truth reads from) were intact, so this backfills one row per user with real rows for a round-3 match (, since they clearly played and got real scored results), then calls to populate //etc from the real data. This is also why the "מחזור אחרון" card was showing round 2's numbers, not round 3's — with round 3 empty for everyone, the round_number-desc sort correctly fell back to round 2, which migration adding the round-number label to that card's title (see above) made possible to actually confirm. 34. — changes the round-standings tiebreak rules (requested 2026-09-10): was points → exact-hit count → earliest submission time; now points → exact-hit count → whoever earned more points on one specific match per round the manager flags as "⭐ המשחק המרכזי" (the main event — e.g. a derby). The earliest-submission-time tiebreak is dropped entirely, since per the user prediction timing is no longer meant to matter for anything — this migration's last statement also clears round 4's (the Thursday-20:00 restriction from migration 27/31), and future scripts should just stop setting that column rather than giving it a value. New plus a partial unique index (, on where ) enforcing at most one per round. New RPC ( + gate, same pattern as ) does the whole round's flag-flip as one atomic — 's match-results screen () got a "⭐/☆ משחק מרכזי" toggle button per match that calls it (passing clears the round's main event). Surfaced to participants too: a gold-tinted badge/border on the flagged match everywhere it renders — ' /, and 's per-participant predictions list (border tint only there, given the compact one-line-per-match layout). ' 3rd tiebreak step updated to match. 35. — real gap found 2026-09-13, asked directly ("can other participants see tomorrow's predictions before they lock?"): (migration 25) gated visibility on the whole round's status (), not per match — since a round flips to the moment its match anywhere kicks off, every approved participant could already read everyone's predictions for later, still-open days too, once day 1 started. Per-day was fixed earlier this session (' ); per-day had been left round-wide. Drops and recreates the policy so it gates on the same day-based rule instead — , the SQL equivalent of — a match's predictions become visible once earliest kickoff has passed, independent of other days. No client-side change needed: already renders "-" for any match RLS doesn't return a row for, so a hidden day just displays as unpredicted instead of leaking real numbers.

36. allow-service-role-manager-actions.sql — lets a Supabase service-role-key connection (no real manager login — used by the scheduled 365scores score-update automation, since this app is Google-OAuth-only and a headless agent can't complete that login flow) satisfy is_manager() too, alongside the existing real-manager-session check. Reuses submit_match_result()/set_main_event() as-is rather than having the automation reimplement scoring math against raw tables with a full RLS-bypassing key. Applied 2026-09-13, then reverted by migration 37 below — the automation it supported turned out to be broken (cloud sandbox egress-blocks Supabase entirely) and was cancelled 2026-09-14 in favor of manual score entry.

37. revert-service-role-manager-actions.sql — reverts migration 36: the score-update automation it supported was cancelled (2026-09-14, user going back to manual score entry), so a bare service-role key no longer has any reason to pass is_manager(). Restores the original, narrower definition (real logged-in manager session only). Applied 2026-09-14.

38. add-goal-difference-bonus-points.sql — first cut of the goal-difference scoring idea (flat exact/correct/bonus model). Superseded same day by migration 39 below before ever being applied — do not run this one, run 39 instead.

39. restructure-scoring-into-win-samediff-draw.sql — the user asked for the scoring UI itself to be reorganized into 3 independent categories rather than one global exact/correct pair plus a flat bonus, so scoring_rules now has 5 columns instead of 3: win_hit_points/win_towards_points (actual result is a win, exact score vs correct-winner-wrong-difference), same_diff_bonus_points (a bonus added on top of win_towards_points when the winner AND the exact goal difference are both correct but not the exact score — e.g. predict 2-0, actual 3-1 → win_towards_points + same_diff_bonus_points), draw_hit_points/draw_towards_points (actual result is a draw, exact score vs correct-draw-wrong-score). No separate "same-diff hit" — confirmed with the user that an exact score always already has a matching difference too, so that case is scored by win_hit_points, not a second hit field. compute_prediction_points() (its signature changed, so explicitly dropped first) now branches on draw-vs-win first, then exact/matching-diff/neither. Manager UI (ScoringRulesModal.tsx) now shows 3 grouped sections ("ניצחון בית/חוץ", "הפרש שערים זהה" — a single "בונוס" field, not a full point value — "תיקו"); still shows the for participants () so the ladder reads as real earnable points, not raw config. Edited in place before ever being applied (caught via a live "column does not exist" error the same session) rather than a new migration number.

The first-cut UI for this (an "everyone's predictions" list on /predictions) was removed the same day — see the /leaderboard feature just below instead, which is what actually shipped.

Also, to make the manager account actually a manager (role defaults to participant for everyone, including this account, on first login):

update users set role = 'manager' where email = '[email protected]';

UI reference

Prediction game for users.drawio.pdf — original wireframes. Superseded in spirit by what's actually built, but still useful for the manager fixture-entry screen, which isn't built yet.

Still to build (Phase 0 — on hold, pending info from you)

1. Manager fixture-entry screen — no UI yet to type in a round's 7 matches + deadline. This is why the "Reset round" button was removed from /manager (2026-08-26) rather than kept as a fake: a real reset means creating a new round + matches, which needs this screen first.
2. Manager result-entry — built (2026-08-22): MatchResultsModal.tsx, opened via "תוצאות מחזור" on /manager. Per-match score inputs + a per-row save button, fetches the latest round overall (not status = 'open' — see the scoring-engine note below for why that filter would break here). Requires migration 12.
3. Scoring engine — built (2026-08-22): submit_match_result() SQL function (migration 12) does the whole recompute — predictions.points_earned (exact score beats correct-direction, sign() comparison so a predicted draw vs. an actual draw counts as correct-direction too), then a full, non-incremental recompute of round_participation.total_points/exact_score_count/correct_result_count/rank for the whole round every time a match is saved (cheap at 7 matches × ~10 participants, and always self-consistent regardless of what order matches get scored in). Deliberately not in scope: is_round_winner/crown badge (only meaningful once all 7 matches are final — separate concern, see item 6) and auto-transitioning rounds.status to 'finished'. No live-push — this app has no realtime subscriptions anywhere; participants see updated numbers the next time they load or refresh /predictions//leaderboard, same fetch-on-mount pattern as everything else. /predictions now also shows each match's final score as a small line under the participant's own prediction, once set.
4. Auto-lock scheduled job — built (2026-08-18): lock_expired_rounds() (see migration 8 above) locks a round and fills per-match default scores once its deadline passes, called lazily whenever a round-dependent page loads (src/lib/lockExpiredRounds.ts). Requires migration 8 to be applied.
5. /home stat cards — built (2026-08-26): pulls the user's own season_stats row and their most-recently-played round_participation row, same pattern ParticipantModal.tsx already used.
6. — crown badge for round winner (schema supports it via , no UI yet); (2026-08-18): on , requires migration 7 to be applied.

Fixed: "current round" lookups broke once round 1 actually locked (2026-08-23)

Half the app (NewsTicker, JackpotBadge, RoundCountdown, RoundApprovalStatus, /manager's participant lists, /leaderboard's round-points table, /home's round-comments section) independently queried rounds filtered to .eq("status", "open"), several using .single(). That's fine right up until a round's deadline actually passes and lock_expired_rounds() flips it to 'locked' — which happened for real on 2026-08-23 (round 1's deadline was 22.8.2026 20:00) and broke /manager outright with a PostgREST "Cannot coerce the result to a single JSON object" error, while the other components just silently vanished (no crash, but the jackpot badge, countdown, approval card, etc. all disappeared exactly when the manager started entering results).

Fixed with one shared helper, getCurrentRound() in src/lib/currentRound.ts — the latest round overall (order by round_number desc limit 1), not filtered by status — now used by all seven of the above instead of each having its own ad-hoc query. MatchResultsModal.tsx already had this exact fix from when it was first built (see item 2 above); this pass generalized it everywhere else and removed the duplication. predictions/page.tsx was already unaffected — it fetches every round and falls back to the last one in the list when none is 'open'.

Live scoring: 0-0 kickoff baseline, current vs. final result (2026-08-23)

Real matches run live — they start at 0-0 and the manager updates the score as it happens, not just once at the end. Three linked changes (migrations 13–16 above):

• 0-0 baseline at kickoff: lock_expired_rounds() seeds a still-unscored match to 0-0 (is_final = false) once that match's own kickoff_at has passed, and computes initial predictions.points_earned/standings from it — "empty" isn't a real state once a match has actually begun. Only touches matches with home_score is null, so a result the manager may have already entered pre-lock is never clobbered. Fixed 2026-08-23 (migration 19): the original version gated this on the round locking, not each match's own kickoff — harmless when every match in round 1 shared one fake kickoff time, but wrong once migration 18 gave it real staggered kickoffs, since it would've force-seeded 0-0 for matches still days from starting the moment the round locked.
• Current vs. final result: matches.is_final (migration 13) drives a new "המשחק הסתיים" (the match ended) checkbox per row in MatchResultsModal.tsx, saved alongside the score via submit_match_result()'s new 4th parameter. On /predictions, the result line reads "תוצאה נוכחית" (current result) while is_final = false, "תוצאה סופית" (final result) once checked — same score-order fix from the previous commit applies to both.
• Round auto-completion: a round's own status now follows its matches — submit_match_result() sets it to 'finished' once every match in the round is final, and reverts it to 'locked' if a final gets unchecked again (fixing a mistake keeps the invariant true in both directions). Nothing else in the app branches on 'finished' specifically — every "current round" lookup already goes through getCurrentRound() (see the fix above), which isn't filtered by status, so a finished round keeps displaying correctly everywhere.
• The aggregate/rank recompute (previously inlined in submit_match_result()) was extracted into a shared recompute_round_standings(round_id) (migration 14) so lock_expired_rounds() can call the identical logic instead of duplicating it.

Decisions (resolved 2026-08-18, built same day)

• Scoring-rules settings screen (in the manager panel): a simple form with two fields — "Exact score points" and "Correct result (towards) points" — prefilled from the current scoring_rules row (default 10 / 5). Saving inserts a new versioned row (effective_from = now()); past rounds keep whatever scoring was current when they were played. Built — ScoringRulesModal.tsx, opened from a button on /manager. No migration needed (table + RLS already existed).
• Default-score predictions: filled in per match, not per round. If a participant predicts only some of a round's matches before it locks (e.g. 4 of 7), only the unpredicted matches get the default score — and that only happens once the round has started/locked. Built — see item 4 above. Still open: exact visual treatment for marking these as auto-filled (badge styling TBD).
• Does the manager play? Admin-only. [email protected] is the workspace/manager account and never predicts. Itay's personal participation happens through a separate account, [email protected], which plays like any other participant. The current season_stats exclusion of role = 'manager' rows is correct as-is — no code change was needed.
• Trash-talk/social feature — v1 scope: one public discussion thread per round, shown on /home. Any participant can post a comment visible to everyone; each participant can have at most one comment per round, enforced both in the UI and by a DB unique constraint on (round_id, user_id). A participant can delete their own comment (round_comments_delete_own policy) to free up their one slot and post a new one instead — there's no in-place edit. Built — see item 6 above.

Hebrew + RTL conversion (2026-08-21)

Wording was worked out first in a reviewed glossary (a Claude Artifact, not part of this repo — every English string mapped to a proposed Hebrew one, with review comments applied) before any code changed. Key terms, now used consistently everywhere they appear:

• Scoring vocabulary: כיוון ("towards" — correct result, wrong score) and פגיעה ("hit" — exact score). Standard Israeli toto-pool language, matches the existing "1X2" branding.
• "Jackpot" → קופה.
• Gendered phrasing defaults to informal plural for anything addressing the whole group; masculine singular only for the one-line manager-specific greeting on /manager/login ("ברוך שובך").
• Brand name "Motzkin Legends" stays in Latin script — see the OneXTwoIcon note under Design system above for the RTL glyph-clipping bug that caused.

Verification caveat: only / and /manager/login were actually visually checked in a browser (screenshotted via Playwright) — every other page requires a real Google-authenticated session, which isn't available in the dev/build environment this was built in. npx tsc --noEmit and next build both pass, and every English string was swept for with a final grep pass, but /home, /predictions, /leaderboard, /rules, /manager, and all the modals (Profile, Scoring rules, News strip, Participant popup) still want a real click-through once deployed, especially for RTL layout mirroring (nav icon order, StatCard's divide-x stat row, TopBar button side) that wasn't force-verified — it's expected to mirror correctly via the global dir="rtl" flip, but wasn't watched happen.