Creator Booth

v1.5.6

A football-only AI chat app for fans and creators: match and player analysis, research with sources, match-day scripts and club banter, backed by Gemini's live Google Search, our own checked data bank (fixtures, results, tables, facts) and real match/coach data (API-Football), not just whatever the model remembers from training. Runs as a website and as an Android app (see the creator-booth-app project).

Vercel settings (Project → Settings → Environment Variables, then redeploy)

• GEMINI_API_KEY — your Gemini key (free tier, no card)
• GEMINI_MODEL — comma-separated, in priority order. Recommended and now the default: gemini-2.5-flash,gemini-2.5-flash-lite. Gemini 2.5 is used because Google Search grounding is free on it (500 searches/day shared); Gemini 3.x search needs a paid account. If a model is gone, busy or out of quota, the next one answers.
• GROQ_API_KEY — backup AI only (plain openai/gpt-oss-120b, no search) plus small helper tasks (openai/gpt-oss-20b). Groq's search models (groq/compound*) were retired and are no longer used.
• API_SPORTS_KEY — API-Football key (no spaces or quotes). Free plan: 100 requests/day, today ±1 day only.
• SUPABASE_URL — https://krmjvfemsufduqdofuqy.supabase.co (same project as the app's database)
• SUPABASE_SERVICE_KEY — Supabase → Project Settings → API Keys → the secret / service_role key. Server only; never put it in the website. Used by the data bank.
• ADMIN_KEY — a long password you invent. It opens /admin.html.
• CRON_SECRET — another long random string. Vercel sends it to the daily update so nobody else can trigger it.

Data bank (v1.3.6)

Our own database of results so answers come from checked data, not the model's memory. Leagues covered: Premier League, La Liga, Serie A, Bundesliga, Ligue 1, Saudi Pro League, UEFA Champions League, Europa League, Conference League, and Inter Miami (any competition). Seasons are named by the year they start (2025 = 2025/26).

One-time setup

1. Supabase → SQL Editor → New query → paste the contents of bank.sql (kept outside this repo; already run for this project) → Run. The tables are private: the public key in the website cannot read or change them.
2. Add the five env vars above in Vercel and redeploy.
3. Open https://creator-boot.vercel.app/admin.html, enter ADMIN_KEY.
4. Import tab → Load from openfootball → pick a season and the leagues → Preview → Save. Do the current and previous seasons first. (The file names for leagues other than the Premier League are not verified; if one fails it says so and nothing else is affected. Then paste JSON instead.)
5. Gaps tab: type any missing results.

How it stays current

• Every day at 01:00 UTC = 02:00 Nigerian time (vercel.json cron → /api/cron-sync): API-Football for yesterday/today/tomorrow (fills results, kick-off times, postponements), then the openfootball file for the current season. Overview shows a red banner if the last run failed and an amber one if it is over 36 hours old. "Run the daily update now" is on the Log tab.
• Free API-Football only serves today ±1 day, so a result missing for longer than that has to come from openfootball or you.
• Rules: a stored final score is never silently overwritten. If another source disagrees it is flagged as a conflict for you to decide; anything you saved by hand is marked verified and kept. A club name nobody recognises goes to the Inbox instead of creating a duplicate club.

Admin tabs — Overview (completeness per league and season, gaps, conflicts, sync health) · Gaps (type scores or mark postponed) · Import (paste JSON with a preview of what changes, or load from openfootball; "Copy format" gives you text to paste to ChatGPT/Gemini so it returns JSON in our shape) · Matches (filter, edit, delete, see the computed table) · Clubs (merge two spellings) · Inbox · Facts (hand-checked facts such as honours; shown to the AI only when a question contains one of their keywords) · Log.

How the chat uses it — GET /api/bank?q=…&today=… works out which leagues, clubs and seasons the question is about and returns a block starting === VERIFIED DATA BANK === with the table, champion, recent results, next fixtures or head-to-head. It states how complete the season is (COMPLETE, or "N of 380 stored" plus which results are missing) so the AI says "not stored yet" instead of guessing. If the bank is down or empty the chat works as before.

Known limits — Tables are computed from results: Serie A and the Saudi league tie-break rules are not verified (flagged in code), UEFA competitions show results/finals only, no tables. Only the leagues above exist; other competitions are ignored on import. Hobby-plan cron frequency was not verified against Vercel's docs; daily is the lowest limit I know of.

Versioning

Version numbers count like an odometer. Each release raises the LAST number by one. When the last number would pass 9, it goes back to 0 and the MIDDLE number goes up by one; when the middle number would pass 9, it goes back to 0 and the FIRST number goes up by one. So: 1.3.3 → 1.3.4 → 1.3.5 → 1.3.1 … 1.9.9 → 2.0.0. (An earlier version of this note said 1.2.9 → 1.2.10; the owner's rule is the odometer rule above.) One release = one increment, no matter how many changes it contains. The Android app project (package.json + the app README) uses the same number.

This README must be updated on every change, in the same commit/patch as the code. Not just the version number — the relevant sections above too (features, known gaps, deploy steps) if they changed. A README that describes an old version is worse than no README, because it actively misleads whoever reads it next.

On every update:

1. Bump APP_VERSION in index.html (single source of truth — it drives both the header tag and the Settings screen automatically).
2. Bump "version" in package.json to match.
3. Add a line to the changelog below.
4. Update whichever sections of this README are now stale.

Setup: feedback table (required for Settings → Send feedback, v1.2.3)

Run this once in Supabase → SQL Editor. Until you do, the feedback form shows "Couldn't send it just now".

create table if not exists feedback (
  id uuid primary key default gen_random_uuid(),
  created_at timestamptz not null default now(),
  user_id uuid references auth.users(id) on delete set null,
  rating smallint not null check (rating between 1 and 5),
  category text check (category in ('bug','idea','confusing','praise')),
  message text not null check (char_length(message) between 5 and 2000),
  contact text check (contact is null or char_length(contact) <= 200),
  app_version text,
  platform text,
  viewport text
);
alter table feedback enable row level security;
create policy "Anyone can send feedback" on feedback
  for insert to anon, authenticated
  with check (user_id is null or user_id = auth.uid());
-- Deliberately no SELECT policy: nobody can read feedback through the app.
-- You read it in Supabase → Table Editor → feedback.

Setup: profiles table (required for onboarding survey + personalization)

v1.4.0 adds a personalization survey and Profile settings backed by a new Supabase table. Run this once in your Supabase project's SQL Editor:

create table if not exists profiles (
  user_id uuid primary key references auth.users(id) on delete cascade,
  surname text default '',
  other_names text default '',
  nickname text default '',
  referral_source text default '',
  referral_other text default '',
  use_case text default '',
  favorite_club text default '',
  notes text default '',
  script_preferences text default '',
  onboarded boolean default false,
  created_at timestamptz default now(),
  updated_at timestamptz default now()
);
alter table profiles enable row level security;
create policy "Users manage own profile" on profiles
  for all using (auth.uid() = user_id) with check (auth.uid() = user_id);

Until this table exists, profile/onboarding features fail silently (no onboarding prompt, greeting falls back to email prefix) rather than breaking sign-in — but run this before shipping v1.4.0 so personalization actually works.

Setup: feedback column (required for persisted thumbs up/down)

v1.7.0 makes the thumbs up/down buttons actually persist instead of being local-only UI. Run this once in your Supabase project's SQL Editor:

alter table messages add column if not exists feedback text;

Until this column exists, tapping thumbs up/down still gives visual feedback but the save silently fails (caught and ignored, same fail-open pattern as the rest of this app) — so it's safe to deploy before running this, just won't actually persist until you do.

A note on image storage (v1.7.0)

Attached images are now compressed client-side (max 1024px, JPEG ~70% quality) and saved as base64 directly in the messages.media jsonb column — not Supabase Storage. This is the simpler option and fine for personal/moderate use, but it counts against Supabase's free-tier database size limit (500MB), not the separate Storage limit (1GB), and base64 is ~33% larger than the raw bytes. If image use grows heavy, migrating to Supabase Storage (storing a URL instead of the bytes) would be the next step — flagging now so it's a deliberate choice later, not a surprise.

Changelog

• v1.3.6 — Gemini 2.5 + data bank. Gemini 2.5 Flash / Flash-Lite are the primary models (free Google Search grounding); a model that is gone, busy or out of quota hands over to the next. Groq live research (groq/compound*) is removed — it was retired by Groq. If Gemini's search is refused, the answer is written without search and the orange note says why ("Gemini search limit reached for now"). Groq is now only a plain backup (gpt-oss-120b, no tools); with an attached image and Gemini down the app says so honestly instead of guessing. New: data bank (/api/bank, /api/cron-sync, /api/admin, admin.html, supabase/bank.sql) — see "Data bank". /api/groq now only accepts openai/gpt-oss-120b and openai/gpt-oss-20b and caps request size. The "denial" guard no longer blocks an answer that used verified data. The Verified badge no longer says "API-Football". Tests: bank 36, API handlers 21, chat flow 20, update flow 28, unit 10.

• v1.3.5 — The orange "no live web search" note now ends with the reason the research step failed, e.g. [research: too slow] or the Groq error text, so a failure can be diagnosed from a screenshot. No other change.

• v1.3.4 — Update notice in the Android app, and a better-researched, more honest chat. (Website code is shared with the app, so the update code is inert in a browser tab.)

  1. Update notice (app only). The app reads version.json from the GitHub release and, when a newer version exists, opens an "Update available" sheet with Update now (downloads the web files and restarts). If that fails, or the release needs a fresh install, the sheet shows Download update (the APK, via /download on this site). Before this, the notice only appeared after a silent background download had already succeeded, so any failure meant no notice at all.
  2. Settings → App updates (app only) shows the installed version, the newest published version, the last check time and the exact error if a check failed, plus a "Check now" tap. "Not now" snoozes that version for 12 hours.
  3. Research depth no longer depends on the Short/Deep toggle. Debates, awards, rumours, theories and "why did X lose" questions (isDebatedTopic) always use the multi-search model (groq/compound). Short now only controls how long the answer is, and may use about 200 words on a debated topic. Plain questions in Short still use the fast model, and if it fails the stronger one is tried (never more than about 40 s of trying).

This is a rebuild of an earlier project (previously "Match Day Script Booth"). The backend proxy pattern carried over; the frontend was replaced with a new chat-style UI, and the feature set was intentionally slimmed down in the process — see What this version doesn't do yet below before assuming parity with the old app.

What it does

• 6 content modes (Football, Story, Secret Web Tools, Hidden AI/Prompting Guides, Conspiracy/History, AI News Roundup) — pick one from the pill above the composer. Each mode is just a different system prompt; adding a 7th mode is a few lines in MODES in index.html, no architecture changes.
• Gemini with live Google Search grounding on every request — responses come with real source links, not just the model's training data.
• Automatic Groq fallback if Gemini's quota runs out mid-conversation, so the chat doesn't just die. Groq has no web-search tool, so a Groq-sourced answer is flagged in the UI (no grounding, and it's from the model's training data — treat it with more caution).
• Best-effort live football context: for Football mode, the app checks today's fixtures via API-Football for a team name match, and if it finds one, feeds Gemini real score/scorer/card/stat data as ground truth it can't contradict. This is a simple one-shot lookup, not a tool-calling loop (see below).
• Image attachments: the + button lets you attach up to 4 photos per message, sent to Gemini as native multimodal input. Attachments reset after each send — you can attach fresh images on your next message in the same chat, it's not a once-per-chat limit. If Gemini's down and an image is attached, the Groq fallback switches to a vision-capable model (meta-llama/llama-4-scout-17b-16e-instruct) instead of the usual text-only one.
• Auth: Google OAuth or email magic link via Supabase, with a full-screen sign-in take-over and a dedicated "check your email" confirmation screen. Guests can use the app fully — chats just save to localStorage instead of the account.
• Incognito chats: a dedicated ghost-mode landing screen, never persisted, with its own header controls (new chat / delete, both confirmation-gated so you don't lose a conversation by accident).
• Per-chat management: rename/delete from a header menu once a normal chat has messages.
• Message actions: copy + thumbs up/down under every assistant reply; the current last reply also gets regenerate (replaces that message in place — doesn't stack a second reply below it) plus a brand/disclaimer footer.
• Export chat: header icon (available in incognito too, not just normal chats) exports the full transcript as Speaker:- text turns, either copied to clipboard or downloaded as a PDF. PDF generation uses jsPDF, lazy-loaded from a CDN only when Download is actually clicked.
• Terms & Privacy pages (/terms.html, /privacy.html) — short, accurate placeholders, not full legal documents.

What this version doesn't do yet

Carried over from the old app's README/code review, for anyone expecting parity — these were cut or simplified during the rebuild, not forgotten:

Feature	Status
Voiceover / TTS (ElevenLabs, Google Cloud TTS)	Removed. Deferred intentionally; no voice UI in this version at all.
Projects / saved workspaces (createProject, saveWorkspace, etc.)	Not carried over. Current app only has chats — no separate "project" concept.
Football tool-calling loop (toolGetMatchFacts, toolGetHeadToHead, live function-calling)	Simplified. Replaced with a single one-shot fixture lookup for today's matches only. No head-to-head, no multi-turn tool use.
Chat images persisted to history	Not yet. An attached image is used for that one request only; reloading a chat shows a text placeholder, not the image.
Custom email sender (vs. default "Supabase Auth")	Not set up. Requires a domain + SMTP provider (Resend, etc.) — see in-app disclaimer instead.

If you want any of these back, the architecture (see below) is set up to make that additive rather than a rewrite.

Architecture

Everything lives in one index.html (~55KB) plus a handful of serverless proxies under api/. It's intentionally still a single file at this size — see the "splitting it up" note below for when that stops being true.

• callAI() centralizes all model calls: tries Gemini first (with whatever tools/system_instruction were requested, including search grounding), falls back to Groq on any failure. geminiToolsToOpenAI() / geminiContentsToOpenAIMessages() / openAIResponseToGeminiShape() handle the format translation between the two APIs, including image content.
• MODES is a flat array of {id, icon, label, system} — the entire "personality" surface of the app. No per-mode branching anywhere else in the pipeline.
• gatherFootballContext() does the one-shot API-Football lookup; runPipeline() is the single request/response flow every mode goes through.
• Supabase handles auth + chat/message storage for signed-in users; signed-out users get the same UI backed by localStorage.

If this grows past a few more modes

At some point — a "Movie Creator" mode, a "Gaming" mode, real tool-calling coming back — this stops being comfortable as one file. The natural split, whenever that's warranted:

js/
  chat.js       runPipeline, callAI, MODES
  football.js   gatherFootballContext + any tool-calling that comes back
  auth.js       Supabase auth screens
  ui.js         drawer, settings, modals, header state machine
  storage.js    chats/messages persistence (Supabase + localStorage)

Not needed yet at this size — noted here so it's a deliberate choice later, not a surprise.

Deploy steps

1. Push this folder to a GitHub repo, or replace the contents of an existing one.

2. Go to vercel.com → New Project → Import that repo. No build settings needed — Vercel auto-detects api/ as serverless functions and serves index.html as-is.

3. Add your keys: Project → Settings → Environment Variables →

   • GEMINI_API_KEY — from aistudio.google.com/apikey
   • API_SPORTS_KEY — free key from dashboard.api-football.com (Account → My Access)
   • GROQ_API_KEY — (optional) free key from console.groq.com/keys, no card required. Automatic backup when Gemini's quota runs out. The chat still works without it, it just has no fallback.

   Then redeploy (Deployments tab → ⋯ → Redeploy) — Vercel doesn't hot-reload env vars into an existing deployment.

4. Configure Supabase auth redirect URLs (separate from Vercel): in your Supabase project → Authentication → URL Configuration, set Site URL to your deployed domain (e.g. https://creator-boot.vercel.app) and add it to Redirect URLs as https://your-domain/**. If this is still set to localhost, both Google and email sign-in will redirect to a dead localhost URL after auth — this bit us once already.

5. Open the deployed URL and click through: sign-in (both methods), each mode, a football request, an image attach, and incognito — before trusting it's fully working. None of this has had a real end-to-end test pass yet as of v1.0.0.

Keep Supabase from auto-pausing

Supabase pauses free-tier projects after 7 days with no database activity — the project goes offline (DNS_PROBE_FINISHED_NXDOMAIN when you hit its URL directly) until manually restored from the dashboard. This happened once already, after a 2-month pause between working sessions. Restoring is free and keeps all data, but it's an avoidable interruption — the project resolves this the same day it happens, but only if someone notices and restores it.

.github/workflows/supabase-keepalive.yml runs a real SELECT against the chats table every 3 days (safe margin under the 7-day limit), so the project never goes quiet long enough to trigger a pause. It needs no setup — it's already wired to this project's URL/anon key (same ones hardcoded in index.html; the anon key is public by design, so there's no security reason to hide it as a GitHub secret here too). Confirm it's running: repo → Actions tab → "Supabase Keep-Alive" should show green runs every 3 days. You can also trigger it manually from there (Run workflow button) to test it immediately.

If the project ever does get paused again anyway (workflow got disabled, a run failed silently, etc.) — restoring from the dashboard is safe up to 90 days paused; past that, the "Restore" button is disabled entirely and you'd need to download the backup and create a fresh project instead. Don't let it sit paused for months on the assumption it's fine.

Local testing (optional)

npm i -g vercel
vercel dev

Runs the same api/ functions locally on http://localhost:3000. Put your keys in a local .env file — vercel dev loads it automatically. Don't commit .env. Note: if you test locally, your Supabase redirect URL config needs http://localhost:3000 in it too (in addition to, not instead of, your production domain) or auth will break in one environment or the other.

Files

index.html                    the app — chat UI, all client-side logic
terms.html                    Terms of Service (short placeholder)
privacy.html                  Privacy Policy (short placeholder)
api/gemini.js                 proxies Gemini generateContent (grounding + vision + system_instruction passthrough)
api/groq.js                   proxies Groq chat completions (plain backup only; two allowed models)
api/download.js               /download: newest APK (Supabase copy first, GitHub fallback)
api/bank.js                   public read: verified-data block for a question
api/admin.js                  admin actions (needs ADMIN_KEY)
api/cron-sync.js              daily update (Vercel cron, needs CRON_SECRET)
lib/                          bank logic: bank-core, bank-sync, bank-context, bank-store, sync-run, apisports
(SQL files are run in Supabase and not stored in this repo)
admin.html                    the admin page (website only; not bundled in the Android app)
api/football/[...path].js     proxies any API-Football endpoint, e.g.
                               /api/football/fixtures?date=2026-07-27
api/google-tts.js             unused by the current frontend — leftover from the old voiceover pipeline
api/elevenlabs.js             unused by the current frontend — leftover from the old voiceover pipeline
vercel.json                   function config
package.json                  name/version/description only — no build step

api/google-tts.js and api/elevenlabs.js are dead code from the pre-rebuild version — safe to delete if you're not planning to bring voiceover back, kept for now since removing voiceover was a UI decision, not evidence the backend routes are broken.

v1.6.3 — squads from API-Football, matched to Transfermarkt profiles

Each club's current squad (players/squads?team=, 1 request per club) is fetched on spare requests only: quiet hours 02:00-07:00 UTC, the same busy-day limits as the transfers job, and squads and transfers share one daily allowance and the 3-requests-per-run cap (squads go first). Refreshed weekly.

• Matching. API names are short ("K. Darlow", with age and shirt number). Each is matched to ONE Transfermarkt profile by name pattern + age (+ club); a profile at another club is accepted only if it is the unique name+age match (he may have moved since the 6 July snapshot). The saved player gets the full name, birth date and nationality from the profile; position, shirt and age come from the API. Players with no unique match are saved with the API's short name and no birth date, so they are easy to spot.
• Never overwrites. A club that already has a squad for the season (all the EPL squads, anything you imported) is kept as it is; only the API snapshot is stored. Clubs with no squad (the Saudi league, for example) are filled in.
• Admin → Profiles has a Squads from API-Football card (clubs fetched, squads filled in, last run, Fetch now). New table bank_api_squads (applied). Tests: tests/squads.test.mjs. Not filled by the API: coaches, joined dates, club status beyond "active".

v1.6.2 — admin: no more reloads after a change, tabs remember what they loaded, easier sign-in

• Changes apply in place. Merging clubs, "Different clubs", answering profile flags and adding an inbox club now update or remove just that item on the page (scroll position kept). Counts are confirmed from the server in the background.
• Tab memory. Each tab's data is kept while you stay on the site (overview 2 min, log 30 s, the rest 5-10 min), so going back to a tab is instant. Any change you make empties the memory so nothing stale is shown. Tap the tab you are already on to force a fresh load.
• Sign-in. The login is now a proper form (account + password) so Chrome offers to save the key and can fill it with one tap; a Use my saved password button asks Chrome for it. Keep me signed in on this device (off by default, remembered once ticked) keeps the key in this browser or app until you press Lock, which forgets it everywhere. Use this in the Android admin app, whose built-in browser cannot offer saved passwords. Trade-off: anyone who can open the unlocked phone can open the bank.

v1.6.1 — Clubs: "Needs checking" list for duplicate club spellings

Admin → Clubs now lists names in the chosen league that are probably one club spelled two ways: one name's words are inside the other's ("Celta" / "Celta Vigo", "Bologna" / "Bologna FC 1909") or the names differ by 1-2 letters ("Al Taawoun" / "Al Taawon"). Two names that have played each other in that league are different clubs and never appear. Each pair has Merge A into B, Merge the other way and Different clubs (remembered in the new table bank_not_dupes, already applied). Merging uses the same move as before (matches moved, double matches dropped, spelling learned). Spellings that look nothing alike ("Olympiakos Piraeus" / "Olympiacos") are still found by hand in the full list. Tests: tests/suspects.test.mjs.

v1.6.0 — match details by hand (scorers, cards, stats, line-ups)

For matches API-Football does not cover. Admin → Import → Match details by hand: paste one match or {"matches": [...]} (up to 40), press Check, then Save. "Copy format for ChatGPT / Gemini" gives the exact shape and rules to give an AI with the match report.

• Accepted: score (sets the result, marks it verified), venue, referee, events (goal, own goal, penalty, yellow, red, sub, each with minute and optional stoppage extra), stats as [home, away] pairs (possession, xg, shots, shots_on_target, shots_off_target, blocked, corners, offsides, fouls, yellow_cards, red_cards, saves, passes, passes_accurate), lineups (formation, coach, 11 starters with optional grid like "2:3" for the pitch picture, subs, optional ratings).
• Everything left out shows as "data unavailable" in the match screen. The match facts show "Details: Entered by hand" so you can tell hand entries from API ones.
• Checks before saving: club names/league/season must find a stored match; minutes 0-130; the goals listed are compared with the score (warning only); starters other than 11 and partial grids are warned about.
• A match that already has API-Football details is left alone unless "replace API details" is ticked. Highest-rated player is only shown when ratings were given.
• The database column bank_match_details.api_fixture_id is now optional (already applied). Tests: tests/manualdetail.test.mjs.

v1.5.9 — transfers job: La Liga and Ligue 1 were skipped

The few team ids learned free from fixtures made the job think a league was already mapped, so the one-off teams request never ran for La Liga and Ligue 1 (only 2 clubs each). It now runs that request once per league regardless. Test added.

v1.5.8 — change a match's date from Gaps

Every row in Admin → Gaps has a Change date button: pick the new date (and optionally a UTC kick-off time) and press Move. The match stays scheduled with its score cleared, is marked verified, and the daily result check then looks for it on the new day. New admin action setDate; cup match ids that include the date are re-keyed. Tests added.

v1.5.7 — daily transfers job (API-Football, spare requests only)

Every club in the leagues that API-Football covers (EPL, La Liga, Serie A, Bundesliga, Ligue 1, Saudi Pro League, Inter Miami) gets its recent transfers (since 1 July 2025) with date and type (Loan / Free / fee text), 1 request per club.

• Runs inside the existing 20-minute check, after results and match details, at most 3 requests per run, so the 10-per-minute limit is never hit.
• Only spare quota. Quiet hours only (02:00–07:00 UTC, just after the daily reset). Daily allowance by how busy today and tomorrow are in our schedule: under 15 matches = 36 requests, 15–29 = 12, 30 or more = none. Results always come first.
• Refresh every 14 days, never-fetched clubs first. An API error pauses the job for an hour.
• Club ids are learned free from the fixtures the result check already sees, plus one teams request per league that has none (season 2024, the newest the free plan allows). Clubs that could not be matched are listed in Admin → Profiles.
• Merge with Transfermarkt: API moves newer than Transfermarkt's last move for that player are added (source api-football, with their type). API names like "K. Darlow" are matched by first initial + surname AND a club the player is known to have been at. A newer API move to our club also silences a "may have left" flag. A squad join date is not listed twice if the API has the same move within 45 days.
• Admin → Profiles has a new card: clubs matched / fetched, requests used today, last run, and Fetch now (ignores quiet hours, still 3 requests).
• New tables bank_team_ids, bank_club_transfers (already applied). Tests: tests/transfers.test.mjs (8).

v1.5.6 — wrong fixture dates and wasted requests fixed

Found while checking the gaps list against independent match pages:

• Provisional dates. The season schedule (openfootball) gives a weekend date, but TV picks move many matches (Sevilla v Osasuna and PSG v Lyon to Monday 26 Oct, Alavés v Málaga to Friday 23 Oct, Toulouse v Troyes to Sunday 25 Oct, three La Liga games to Saturday 24 Oct). When a result was filled, the date was kept as it was. Now the API's date wins when a result is filled, and the due-match check asks for the real kick-off day when it is known.
• Wasted requests. The free plan only answers yesterday to tomorrow (UTC). The due-match check kept asking for older dates (refused, but each still cost 1 of 100). It now skips them and says "enter them by hand". API_DATE_WINDOW_DAYS (default 1) widens this on a paid plan.
• Tests: two new sync-due tests.

v1.5.5 — squads can carry "joined" dates; they fill the gap after Transfermarkt's snapshot

Each squad player may now have joined (2026-08 or 2026-08-30) and joined_from (club). Both are optional; leave out what is not known. Stored in bank_players.joined / joined_from (already applied).

• Our own join date is used when it is newer than Transfermarkt's latest move for that player: it is added to his transfer history as a move marked squad (mergeHistory), and the "may have left" check no longer flags him (our data is newer, so there is nothing to confirm).
• Re-importing a squad without join dates does not erase dates already stored.
• A join date after the squad's as_of, before the birth date, or not in YYYY-MM[-DD] form is rejected.
• Dates from an AI are unverified. The prompt tells it to leave a date out when unsure. Transfermarkt dates remain the source for everything up to 6 July 2026.

v1.5.4 — Profiles: answer the flags in one go

In Admin → Profiles, tapping He left or Our data is right now only marks your choice (highlighted, tap again to undo); the page no longer reloads each time. A bar at the bottom shows the count and Confirm N answers saves them all at once (resolveFlags). Everything unanswered: our data is right fills the rest in one tap. Players marked He left are removed from their squads only when you confirm.

v1.5.3 — player profiles from Transfermarkt, and "may have left" flags

Admin → Profiles (new tab). Nothing changes in the chat yet: this release only stores the data and checks our squads against it.

• Profiles: about 6,600 players (everyone at our matched clubs plus about 670 who left them since June 2025) from the Transfermarkt dataset, snapshot 6 July 2026. Each has nationality, date of birth, position and sub-position, foot, height, contract end, market value and peak value, caps and goals, full transfer history, yearly value points, and goals/assists/cards/minutes per season and competition. No portraits and no numeric ratings. Stored in bank_player_profiles (8-player-profiles.sql, already applied).
• Our data is the truth. The check never edits a squad. It looks for players in our latest squads whom Transfermarkt places at another club and writes a flag:
  • left?: Transfermarkt lists a move away from our club (date, destination), and he is now at another club. Could be a loan.
  • mismatch: Transfermarkt has him elsewhere and never mentions our club. One source is wrong, or he came back after the snapshot.
  • Skipped: players on loan from the club Transfermarkt shows, retired players, older seasons, and players that cannot be matched safely (same name needs the same date of birth, or a unique name when our data has none).
• You answer each flag: He left (the player is marked as gone from that club and drops out of the squad) or Our data is right (dismissed for good; it does not come back).
• The check can only judge players that are in our squads. Only the Premier League squads are loaded today; load the other leagues' squads and run the check again.
• Club matching: 143 of our 186 clubs matched to Transfermarkt. Unmatched are mostly promoted or second-tier clubs and small European clubs that Transfermarkt's data does not cover; their players are simply not in the profiles.
• Admin importProfiles, profileStats, checkFlags, flags, resolveFlag. Tests: tests/profiles.test.mjs.

v1.5.2 — daily sync moved to 02:00 Nigerian time

vercel.json cron changed from 0 5 * * * to 0 1 * * * (Vercel cron times are UTC; Nigeria is UTC+1 all year). Vercel's free plan may start a daily job at any point within that hour, so expect it between 02:00 and 03:00 Nigerian time. The 20-minute result check (GitHub Actions) is unchanged.

v1.5.1 — app download fixes

• The Supabase storage bucket app-updates was private, so every Supabase address answered HTTP 400. The app's quick update and the /download link therefore always fell back to GitHub. The bucket is now public (it only holds the public update files: version.json, bundle.zip, creator-booth.apk). If the update screen ever shows "Supabase 400" again, check Supabase → Storage → app-updates → Public bucket.
• The "Get the Android app" box now also recognises a phone whose Chrome is in "Desktop site" mode (that mode hides the word Android), and always offers a "Download anyway" link.

v1.5.0 — match screen (tap a fixture card)

Tapping the fixture card under a chat answer opens a full-screen match screen with Facts, Lineup, Table, Stats and (for the European cups) Play-offs. It reads our own data bank through /api/match; it never calls the football API itself.

• Facts: competition, round, date, kick-off (shown in the phone's time zone), venue, referee, goals and cards on a timeline, substitutions, highest-rated player.
• Lineup: both starting XIs on a pitch from the API's formation grid, ratings, goals, cards, minutes, substitutes, coach.
• Table: league table computed from the stored results, both teams highlighted, with qualification and relegation colours and a legend. Champions League, Europa League and Conference League use the league-phase table: 1-8 Qualified, 9-24 Play-offs, 25+ Eliminated. The usual domestic places are in ZONES in lib/match-view.js (one place to edit). Extra European places depend on UEFA rankings and cup winners, so check them each season.
• Stats: team statistics as bars (possession first).
• Play-offs: knockout rounds with two-leg ties and aggregate. Empty until the knockout matches are stored.
• Any tab with nothing to show says "No data available" and why. The table is always shown for league and league-phase competitions.

Where line-ups and stats come from. When the due-match check fills a result it also records API-Football's fixture id. The same 20-minute run (/api/cron-sync?mode=due) then fetches fixtures?id= once per finished match: 1 API credit, saved in bank_match_details, free for every later view. At most 3 per run, only for matches finished in the last 3 days, and an API error pauses detail fetching for an hour so it cannot use up the 100 daily requests. Matches before this release, and matches the 02:00 (Nigerian time) daily sync filled first, have no details and show "No data available".

Setup (once): run 7-match-details.sql in Supabase (already applied to the project). No new environment variables. No new APK needed.

Tests: tests/matchview.test.mjs (13).

v1.4.7 — results are checked after each match, not once a day

• Due-match check. A stored match is "due" about 110 minutes after its kick-off (if the kick-off time is stored) or after 22:30 UTC on its date (if not). For due matches the site asks API-Football for that date (one request covers the whole day; at most 2 per run, a date is not asked again for 25 minutes) and fills the score. A match still being played keeps its real kick-off so the next check is exact; postponed or cancelled matches are marked as such.
• Any competition in the bank, including national-team games, cups and friendlies: it matches on team names, so no competition list has to be kept up to date.
• Two triggers: a free GitHub schedule (.github/workflows/due-sync.yml, every 20 minutes, calls /api/cron-sync?mode=due) and every chat question (/api/bank, 4-second limit). Nothing due means no API request. The daily Vercel sync stays as it was.
• The ?mode=due address needs no key: it only reads stored matches and cannot spend more than the limits above. No SQL, no new env vars or secrets.
• Log entries of kind sync-due appear on the admin Log tab.

v1.4.6 — player import no longer duplicates accented names

• Importing a squad now replaces older copies of the same player that were stored with a different spelling (for example "Victor Lindelof" and "Victor Lindelöf", same club and season) instead of adding a second row. The preview says how many will be replaced.
• The player JSON has the Saudi and Racing club names matched to the bank's spellings.
• Admin page version label now follows the app version.

v1.4.5 — fixture card under chat answers

• When an answer is about one or two clubs, a card appears under it: competition and round, both clubs, the score (or kick-off date and time) and "Full time" / "Upcoming". Two clubs: their next meeting this season, else the latest. One club: its next fixture (latest result when results were asked for).
• Only matches stored in the data bank are shown. The card is saved with the message, so it is still there when the chat is reopened.
• No club crests: clubs get a text badge (PSG, BAR, MCI…) with a colour from the name. Crests can be added later in one place (clubBadgeHtml) without touching anything else.
• /api/bank now also returns cards. No SQL, no new env vars.

v1.4.4 — phone notification when a script is ready

• When a background script finishes, the server sends a push notification through Firebase Cloud Messaging (free). It works with the app closed; tapping it opens the chat with the script.
• Needs: Vercel env var FIREBASE_SERVICE_ACCOUNT (the whole service-account JSON), and 6-device-tokens.sql run once in Supabase (paste the contents).
• New endpoint api/device-token.js links a phone to the signed-in person (also removed on sign-out). Code: lib/push.js (no dependencies; signs the Google token with Node's crypto).
• Needs the new APK (v1.4.4 app repo build). Older app files keep working but get no push; they still show the in-app notice.
• If nothing is configured, the notifier is skipped silently and the script still lands in the chat.

v1.4.3 — Script Studio: plan first, then write in the background

• A script request now gets a short plan first (angle, structure, what will be checked) with a Start writing button. Type a change and the plan is rewritten; nothing long is written until Start is pressed.
• Signed-in people: Start sends the job to /api/script-job (up to 300 s, runs server-side). The chat says "I'm on it", you can leave, and the finished script is saved into the chat. The app shows a notice when it is ready (and when you next open it). A failure saves a visible message with a Regenerate hint.
• Guests / offline / server unavailable: the script is written in the open chat as before.
• Run 5-script-jobs.sql once in the Supabase SQL Editor (paste the contents).
• vercel.json now sets 300 s only for api/script-job.js (60 s for the others). On Vercel Hobby, 300 s needs Fluid compute (Settings → Functions) on older projects.
• Push notification with the app closed comes in the next release (needs Firebase and a new APK).

v1.4.2 — squads with age, status and head coaches

• Squad import accepts what a research sheet really contains. Per club group: league, season, club, as_of (date the list is true), coach {name, nationality} and players with name, shirt, dob, age, position, nationality, club_status ("Active" or "Retired (2026)") and national_status ("Active", "Retired (2022)" or "Not capped"). "NOT FOUND", blanks, N/A and "-" are stored as empty, never as text. A player with an age but no date of birth keeps the age and the as_of date it was true on.
• Checks: league key, season, as_of not in the future, shirt 0-999, ISO dates, age 14-60, statuses, positions. Warnings (not blockers): age that disagrees with the date of birth, implausible ages, duplicate shirt numbers in a club, a player listed in two clubs, players with no birth info, no coach.
• Club names are matched to the bank's spelling ("Man City FC" becomes "Manchester City") when the league already has matches stored; otherwise the name is kept as written with a warning.
• Loans and national-team levels: club status accepts Active / Permanent / On Loan (from club) / Retired (year); national status accepts Active (senior), Youth International, Former international, Former youth international, Retired (year), Not capped / Uncapped. Loans store on_loan and loan_from.
• Chats are listed by last use. A chat moves to the top when you send, edit or regenerate in it, so the app opens the chat you used last. Needs 4-chats-last-used.sql (adds chats.updated_at); until it is run, the order still works on the device you use but is not shared between devices.
• Loading logo is orange (the brand colour) instead of white while the app starts.
• Coach, squad and form now reach the chat. For any club named in a question, the data bank block now carries the head coach (from the squads you imported), the registered squad (names, shirt numbers, loans), the club's record and current run in the stored matches, and its league finishes in completed stored seasons (so "back-to-back champions" can be stated from data). If a club has no coach on file the block says so and forbids naming one from memory. The older API-Football coach lookup now runs when the bank has no coach, and only trusts a coach whose spell at the club is still open (it used to take the first name in the list, which can be a former manager). Fixes the "Xavi's Barcelona" mistake. Only competitions you have stored are counted: the chat cannot state a Champions League run that is not in the bank.

v1.4.1 — nations, clubs and tournaments in career profiles

• Nationality travels with the player. nationality is the country he represents at senior level (or is eligible for if uncapped); other_nationalities lists any other citizenships. A national team is built later by grouping on this, so players are never entered twice.
• tournaments: registered squads only. Each entry is tournament, year, nation, status (registered or withdrew_injured) and optional stats. Allowed tournaments: FIFA World Cup, UEFA European Championship, Copa América, Africa Cup of Nations, AFC Asian Cup, CONCACAF Gold Cup, Olympic Games (common short names such as "World Cup" or "Euros" are accepted). A player who was not in the final squad simply has no entry, so each tournament's squad can be rebuilt from the profiles.
• totals now means club career only. National-team figures live in the new international list: one row per nation and level (senior, Olympic, U23 … U16), so a player who switched nations has one row for each.
• by_club: one row per spell at a club (from, to, and that spell's stats). Dates alone are fine; stats are optional. The rows can never add up to more than totals.
• Seasons: an "All competitions" row can no longer be mixed with per-competition rows for the same club and season (it would be counted twice).
• Awards take kind: individual or team.
• Merging: tournaments, clubs and national-team rows are matched by their own keys and added to; any value that would be replaced is listed in the preview. The as_of rule is unchanged and covers club, season and national-team stats alike.
• Research prompts for Deep Research (one per league plus Inter Miami) are kept outside the repo. Their example JSON is checked against this importer.
• No SQL change (profiles are stored as JSON). Only admin.html, lib/bank-career.js, tests/career.test.mjs, README.md and package.json changed.

v1.4.0 — career profiles

• Players tab → Career profiles. One profile per player with any of: career totals, per-season stats (seasons), awards, market_values (each with a date) and transfers. Every section is optional; only name is required, plus as_of whenever totals or seasons are given.
• as_of is the guard. It is the date the figures are correct up to. Matches recorded in the bank count from that date on, so recorded matches and imported career figures are never added together. A newer import replaces older stats; an import dated older than what is stored leaves the stored totals and seasons alone (awards, transfers and values are still added).
• Importing again adds, it does not wipe. Values that already exist are replaced only when you give a new one, and the preview lists every one it would replace ("totals.goals: 50 → 55"). Same file loading and chunking as squads (several files, parts under 1 MB).
• Checks before saving: stat values must be plain numbers ≥ 0; successful can't exceed attempted (dribbles, passes, crosses, shots on target, penalties); seasons can't add up to more than the career total; no future as_of; money must be a plain number with a date; duplicate season rows are refused. A stat name that isn't a standard one is kept but warned about (catches assits).
• Matching players: by normalised name plus date of birth. Without a dob a profile matches a unique stored name; two stored players with the same name need a dob. Adding a dob later to a profile saved without one updates that profile rather than creating a second.
• Copy prompt for ChatGPT / Gemini button gives a ready prompt that returns JSON in this format, told not to guess.
• Needs a database change first: run 2-career-profiles.sql once in Supabase (creates the private bank_career table). Until then the card shows a "not ready" notice and nothing else on the page breaks.
• Not wired into the chat yet. Neither squads nor career profiles are read by the AI; they are stored and reviewable only. That is the next step.
• Tests: node tests/career.test.mjs.

v1.3.9 — import JSON from a file

• Players tab: new Choose JSON file(s)… button. Pick one file or several at once (for example one per club). The file is read in the browser, split into parts of under 1 MB and sent one part at a time, so the clipboard limit and the server's ~4.5 MB request limit no longer matter. A progress label shows "Checking 2/3…" or "Saving 2/3…".
• Preview first, then Save, as before. Problems in the file are now listed on the page (before, a bad file only showed "Server answered 400"). A repeated player inside the import is flagged. Pasted text is ignored while files are loaded; Clear files goes back to pasting. A file that is not valid JSON, or was cut off, is rejected with nothing loaded.
• If a later part fails during Save, the earlier parts are already saved; saving again is safe (same players overwrite themselves).
• Import tab (results): new Choose JSON file… button that loads the file into the box, then Preview as usual. Files over 4 MB are refused with a message.
• Known limit: the repeated-shirt and two-clubs warnings are checked per part against what is already stored, not across parts of the same file. The in-file repeated-player check covers the whole file.
• Version tag on the admin page (header, next to the date), from ADMIN_VERSION in admin.html. Bump it with package.json on every release.
• APK file name carries the version. /download now saves the file as creator-booth-v<version>.apk (read from the published version.json), so downloads are recognisable. The browser still adds (1), (2) if you download the same version twice; delete old copies. Once the app is on v1.3.8 or later, updates arrive inside the app and the APK is not needed again. If the Supabase copy is missing, GitHub is used and keeps the plain name creator-booth.apk.
• Changed: admin.html, api/download.js, README.md, package.json. No SQL, no environment variables, no app update.

v1.3.8 — faster app updates, installable admin

• App updates no longer depend on GitHub's download speed. Each app build also uploads bundle.zip, version.json and the APK to a public Supabase Storage bucket named app-updates (the same host the app already uses for chats and sign-in). The app checks both Supabase and GitHub, takes the newest version, downloads from that host and automatically tries the other if it fails. The update is the web files only (expected to be well under 1 MB; not measured here because the real build needs the app repo's CI), not the 5 MB app file.
• If an update still fails the sheet now says why: it shows a connection test for each host (status code and seconds), so a screenshot tells us whether the phone, GitHub or Supabase is the problem.
• /download (the APK link) now goes to the Supabase copy when it exists (api/download.js), otherwise GitHub as before.
• Admin is installable. Open /admin.html in Chrome on the phone → ⋮ → Install app (or tap Install app in the page header). It gets its own "ADMIN" icon. It caches nothing, so it is always the newest admin page; deploying the website IS the admin update. admin.webmanifest, admin-sw.js, admin-*.png.
• The app files needed from the website are only index.html (unchanged flow: copy it into the app repo's www/). admin.html is never part of the app.
• One-time setup (see the app README): create the bucket app-updates (public) in Supabase and add two GitHub secrets to the APP repo, SUPABASE_URL and SUPABASE_SERVICE_KEY. Without them the build still works and updates come from GitHub as before.
• A phone on an older app version (v1.3.4 or earlier) still uses the old GitHub path, so it needs one APK install to get the new updater.
• Tests: update flow 35, chat flow 20, bank 36, API handlers 27, players 4, unit 10.

v1.3.7 — players, more competitions, two fixes

• Players tab (admin): paste a squad as JSON, one club per group, e.g. {"league":"EPL","season":2026,"club":"Arsenal","players":[{"name":"…","shirt":7,"dob":"2000-01-31","position":"Forward","nationality":"England"}]} (or an array of groups). Preview warns about a repeated shirt number in a club/season and about the same player at two clubs. Date of birth is stored; age is calculated when shown. Do not import unverified players.
• New competition keys for manual import: CLUBFRIENDLY, NATIONFRIENDLY, WORLD_CUP, EURO, AFCON, COPA_AMERICA, WC_QUALIFIERS, EURO_QUALIFIERS, AFCON_QUALIFIERS. They are competition categories; no results are included.
• Needs a database change first. Run 1-competitions-and-players.sql once in Supabase (paste its contents into SQL Editor). It widens the allowed competition list and creates the private bank_players table. The SQL is kept out of this repo on purpose.
• Fix: the Supabase store now really saves/loads players (before, only the test store could).
• Fix: club-spelling aliases that name several spellings (Union SG etc.) crashed the chat's bank lookup; they no longer do.
• Ligue 1 matcher fix (Paris FC vs Paris Saint-Germain) is included: node tests/matcher.test.mjs.
• Not changed: index.html (still v1.3.6), so the Android app needs no update.

Admin v1.6.4 — Matches tab: date filter

• New From date / To date fields, Order (oldest or newest first), and quick buttons Yesterday / Today / Tomorrow / Any date.
• The count line splits the total by league, so "Today" shows how many matches there are per league.
• Admin-only change; the app version is unchanged.

Admin v1.6.5 — bulk squad fetch, API-day plan

• Profiles → Squads: Fetch in batches. It fetches only clubs that have no squad (clubs that already have one cost no request), 5 requests every 40 seconds to respect the 10-a-minute limit, and stops by itself when the day's remaining requests drop to the "keep for live scores" number (default 30). Keep the page open while it runs.
• The squads card now shows the API day (UTC): matches today and tomorrow, and requests left at the last run. API-Football's day resets at 00:00 UTC (01:00 Lagos).
• "Fetch now" is a manual call, so it is no longer blocked by the busy-day allowance (the reserve still protects live scores). The automatic job keeps its rules.
• Matches tab: the Today / Yesterday / Tomorrow buttons use the UTC date, like API-Football.
• Transfers "Fetch now" still follows the busy-day rule; say if you want it changed too.

Admin v1.6.6 — pick leagues / clubs for the squad fetch

• Profiles → Squads → Choose leagues / clubs…: each league is a drop-down with a tick for the whole league, and a tick per club (each shows "no squad" or its player count). Tick all clubs with no squad is a shortcut.
• Optional coach fetch (coachs?team=, +1 request per club); the current coach is the one whose career entry at that club has no end date.
• While it runs the page shows the league and club in progress, then a result card per club as it finishes: players stored, how many have no Transfermarkt match, coach, and a drop-down listing the players (shirt, name, position, age).
• 5 requests per batch then a 40-second pause; it stops by itself when the day's requests drop to the "keep for live scores" number or on an API error.
• A club that already has a squad is never overwritten (the card says so and shows the stored players).
• Replaces the v1.6.5 "Fetch in batches" count box.

Admin v1.6.7 — squad picker: all clubs, tidy rows, link clubs to API-Football

• The picker now lists every club of the current season. Clubs without an API-Football id are greyed, with "not linked to API-Football yet" and a disabled tick (before, they were silently missing: La Liga 2 of 20, Ligue 1 2 of 18, Premier League 16 of 20 …).
• Each league row: drop-down arrow on the left, small tick on the right (ticks the whole league); each club row has its small tick on the right.
• Link clubs button (lib/link-clubs.js): 1) a league with no club list yet costs 1 request (La Liga and Ligue 1 had never been read); 2) free re-match of API teams we already know but could not name-match, with a looser rule ("Leverkusen" = "Bayer 04 Leverkusen"); 3) optional search by name, 1 request per club, accepted only when exactly one plausible club of the right country comes back. Unclear ones stay unlinked, never guessed. 5 requests per batch, 40-second pause.
• Not covered: Inter Miami's Mexican guests (no single country), and the cups.

Admin v1.6.8 — daily API requests shown under the version

• The header shows API requests today: N left of 100 (resets 00:00 UTC = 01:00 Lagos). It refreshes every 2 minutes, after every fetch or link batch, and when tapped. It turns orange at 30 or fewer.
• It reads API-Football's own status call, which per its documentation does not use a request. If the answer has an unexpected shape the line says "unavailable" instead of guessing.

Admin v1.6.9 — link only the clubs that are not linked

• The "not linked" card now lists just those clubs (ticked by default, small tick on the right). Link ticked clubs searches only those by name (1 request each), instead of going league by league.

Admin v1.7.0 (was numbered v1.6.10 by mistake) — linking shows why a club was not linked

• Each club the name search could not link now shows the reason and what API-Football answered ("API returned nothing", "none fits — API said: …"), also saved in the Log.

Admin v1.7.1 (was numbered v1.6.11 by mistake) — link clubs by hand, and spot second spellings

• Each unlinked club now has a drop-down of the API-Football club names we already hold (free, no request) and a Link button. Linking is saved with source "manual".
• Clubs that are just a second spelling of an already-linked club (SSC Napoli / Napoli, SS Lazio / Lazio, Como 1907 / Como, Leipzig / RB Leipzig) are flagged "Merge them in Clubs → Needs checking", not linked: they need merging, not a new API id.
• Read more API-Football club lists (Ligue 2, 2. Bundesliga, Liga MX; 1 request each) adds the names of clubs that were in a lower league in 2024, so they can be picked by hand.
• "D.C. United" now matches "DC United" (dots ignored).
• The name search was dropped from the screen (it returned nothing for names with prefixes such as "SSC Napoli"); the code stays for later.

Admin v1.7.2 (was numbered v1.6.12 by mistake) — picker fixes

• Opening the picker now name-matches known API clubs for free ("DC United" = "D.C. United").
• The drop-down also offers API clubs that were linked from fixtures under a name we no longer use (e.g. "Lazio · now linked as Lazio" for our "SS Lazio"). Choosing one re-links it to our spelling. Links to a club that is in this season's list are still refused.

Admin v1.7.3 (was numbered v1.6.13 by mistake) — search one club by hand

• Each unlinked club has a text box (pre-filled with its name) and Search API (1 request). The API's matches are added to that club's drop-down, labelled "search result"; nothing is linked until you pick one and tap Link. Edit the text to try a shorter name ("San Diego FC").

Admin v1.7.4 — faster squad fetch

• 8 requests per batch and one batch a minute (was 4–5 requests then a 40-second pause), so ticked clubs with coaches take about 4 clubs a minute. The pause counts from the start of the batch. The screen is kept awake while it runs (where the phone allows it).
• Version numbering: the last digit runs 0–9, then the middle one goes up (the four updates before this were numbered 1.6.10–1.6.13 by mistake and are now listed as 1.7.0–1.7.3).

v1.7.5 — full match statistics for Premier League and La Liga only; request guard

• Match details (events, line-ups, ratings, statistics: 1 request per finished match) are now fetched only for EPL and LALIGA matches. Other leagues still get their result (one request per date covers every league). Set DETAIL_LEAGUES (e.g. EPL,LALIGA,SERIEA or *) to change this.
• Request guard: the due-sync and details jobs now record the API's own "requests left today". When 15 or fewer are left, details wait so the results of the day still get fetched. A number from a previous UTC day never blocks anything.
• Dates follow the API: when the API reports a different kick-off day for a match that has not been played, our date moves to it (not for cups, whose ids contain the date). A rescheduled import drops the old kick-off. Done by hand today: Deportivo La Coruña v Osasuna (2 Nov), Lorient v Brest (2 Nov), Lyon v Angers (1 Nov); three postponed Saudi matches lost their stale kick-off.
• Header version is the admin version (1.7.5).