Merge pull request 'feat/participant-divider-roles' (#10) from feat/participant-divider-roles into master

Reviewed-on: renkar/tipibot#10

.env.example

@@ -1,17 +1,55 @@
-# Discord bot token (from https://discord.com/developers/applications)
+
-DISCORD_TOKEN=your-bot-token-here
+# Profile-specific Discord bot tokens (from https://discord.com/developers/applications)
+DISCORD_TOKEN_DEV=your-dev-bot-token-here
+DISCORD_TOKEN_ECONOMY=your-economy-bot-token-here
+
+# Legacy fallback token (optional, backward compatibility)
+DISCORD_TOKEN=
 
 # Google Sheets spreadsheet ID (the long string in the sheet URL)
 SHEET_ID=your-google-sheet-id-here
 
+# Separate spreadsheet holding tournament team registrations (Team Name + lineup
+# of Discord usernames). Optional; a FALLBACK source for /teamsync + hourly
+# team-role sync on the economy/community bot. Leave unset to disable it.
+TEAM_SHEET_ID=
+
+# Fienta ticketing - PRIMARY source for team-role sync. The registration collects
+# each competitor's Discord username + team name per ticket, so matching is by
+# real Discord handle (not game nickname). Get an API token from the Fienta admin
+# (organizer settings) and the event's numeric ID from its dashboard URL. Leave
+# unset to use only the sheet.
+FIENTA_API_TOKEN=
+FIENTA_EVENT_ID=
+
+# Where each game's team roles get positioned in the role list. The key suffix
+# is matched against the section's title row in the sheet ("TipiLAN 2026 CS2
+# Registration Log") - every underscore-separated part must appear in it, so
+# CS2_2026 matches only the 2026 CS2 block while a plain CS2 would match any
+# year. The value is the Discord role ID to place those teams under (matching by
+# ID means renaming the divider role never breaks positioning).
+# Optional: sections that match nothing still get their roles, just unpositioned.
+TEAM_DIVIDER_CS2_2026=1498736834656604251
+TEAM_DIVIDER_LOL_2026=1498736949706490017
+
 # Path to Google service account credentials JSON
 GOOGLE_CREDS_PATH=credentials.json
 
-# Guild (server) ID - right-click your server with dev mode on
+# Profile-specific guild (server) IDs - right-click your server with dev mode on
-GUILD_ID=your-guild-id-here
+GUILD_ID_DEV=your-dev-guild-id-here
+GUILD_ID_ECONOMY=your-economy-guild-id-here
 
-# Channel ID where birthday announcements are posted (bot sends @here on the birthday at 09:00 Tallinn time)
+# Legacy fallback guild ID (optional, backward compatibility)
-BIRTHDAY_CHANNEL_ID=your-channel-id-here
+GUILD_ID=
+
+# Channel ID where birthday announcements are posted (dev profile)
+BIRTHDAY_CHANNEL_ID_DEV=your-dev-birthday-channel-id-here
+
+# Optional birthday channel for economy profile (normally unset for economy-only bot)
+BIRTHDAY_CHANNEL_ID_ECONOMY=
+
+# Legacy fallback birthday channel ID (optional, backward compatibility)
+BIRTHDAY_CHANNEL_ID=
 
 # How many days before a birthday the on-join check counts as "coming up"
 BIRTHDAY_WINDOW_DAYS=7
@@ -20,3 +58,10 @@ BIRTHDAY_WINDOW_DAYS=7
 PB_URL=http://127.0.0.1:8090
 PB_ADMIN_EMAIL=admin@example.com
 PB_ADMIN_PASSWORD=your-pb-admin-password
+
+# Profile-specific PocketBase collections
+PB_ECONOMY_COLLECTION_DEV=economy_users_dev
+PB_ECONOMY_COLLECTION_ECONOMY=economy_users_prod
+
+# Legacy fallback collection name (optional, backward compatibility)
+PB_ECONOMY_COLLECTION=

.gitea/workflows/deploy.yml

@@ -0,0 +1,35 @@
+name: Test & Deploy
+
+on:
+  push:
+    branches: [master]
+
+jobs:
+  test:
+    runs-on: linux
+    steps:
+      - name: Run test suite
+        run: |
+          REPO=$(git -C /root/tipibot remote get-url origin)
+          rm -rf /tmp/tipibot-ci
+          git clone --quiet "$REPO" /tmp/tipibot-ci
+          cd /tmp/tipibot-ci
+          git checkout --quiet ${{ github.sha }}
+          python3 -m venv /opt/tipibot-ci-venv
+          /opt/tipibot-ci-venv/bin/pip install -q -r requirements-dev.txt
+          /opt/tipibot-ci-venv/bin/python -m pytest tests/ -q
+
+  deploy:
+    runs-on: linux
+    needs: test
+    steps:
+      - name: Deploy
+        run: |
+          cd /root/tipibot
+          git pull
+          source .venv/bin/activate
+          pip install -r requirements.txt
+          sudo systemctl restart tipibot_dev        # dev bot first, as canary
+          sleep 5
+          systemctl is-active --quiet tipibot_dev   # dev crashed on startup -> abort
+          sudo systemctl restart tipibot_eco        # eco bot only if dev survived

.gitignore

@@ -4,10 +4,12 @@ __pycache__/
 *.pyc
 .venv/
 venv/
-data/restart_channel.json
+data/
-data/economy.json
 pocketbase.exe
 pocketbase
 pb_data/
 pb_migrations/
 logs/
+fientalog
+fientatickets
+fientaorders

DEV_NOTES.md

@@ -1,257 +0,0 @@
-# TipiLAN Bot - Developer Reference
-
-## File Structure
-
-| File | Purpose |
-|---|---|
-| `bot.py` | All Discord commands, views (UI components), event handlers, reminder system |
-| `economy.py` | All economy logic, data model, constants (SHOP, COOLDOWNS, LEVEL_ROLES, etc.) |
-| `pb_client.py` | Async PocketBase REST client - auth token cache, CRUD on `economy_users` collection |
-| `strings.py` | **Single source of truth for all user-facing text.** Edit here to change any message. |
-| `sheets.py` | Google Sheets integration (member sync) |
-| `member_sync.py` | Birthday/member sync background task |
-| `config.py` | Environment variables (TOKEN, GUILD_ID, PB_URL, etc.) |
-
----
-
-## Adding a New Economy Command
-
-Checklist - do all of these, in order:
-
-1. **`economy.py`** - add the `do_<cmd>` async function with cooldown check, logic, `_commit`, and `_txn` logging
-2. **`economy.py`** - add the cooldown to `COOLDOWNS` dict if it has one
-3. **`economy.py`** - add the EXP reward to `EXP_REWARDS` dict
-4. **PocketBase** - if the function stores new fields, add them manually in the PB admin UI at `http://127.0.0.1:8090/_/`. Fields not in the PB schema are silently dropped on PATCH.
-5. **`strings.py` `CMD`** - add the slash command description
-6. **`strings.py` `OPT`** - add any parameter descriptions
-7. **`strings.py` `TITLE`** - add embed title(s) for success/fail states
-8. **`strings.py` `ERR`** - add any error messages (banned, cooldown uses `CD_MSG`, jailed uses `CD_MSG["jailed"]`)
-9. **`strings.py` `CD_MSG`** - add cooldown message if command has a cooldown
-10. **`strings.py` `HELP_CATEGORIES["tipibot"]["fields"]`** - add the command to the help embed
-11. **`bot.py`** - implement the `cmd_<name>` function, handle all `res["reason"]` cases
-12. **`bot.py`** - call `_maybe_remind` if the command has a cooldown and reminders make sense
-13. **`bot.py`** - call `_award_exp(interaction, economy.EXP_REWARDS["<cmd>"])` on success
-14. **`strings.py` `REMINDER_OPTS`** - add a reminder option if the command needs one
-15. **`bot.py` `_maybe_remind`** and **`_restore_reminders`** - if item-modified cooldown, add `elif` branch
-16. **`bot.py` `_REMINDER_COOLDOWN_KEYS`** - add `"cmd": "last_cmd"` mapping if reminder-capable
-
----
-
-## Adding a New Shop Item
-
-Checklist:
-
-1. **`economy.py` `SHOP`** - add the item dict `{name, emoji, cost, description: strings.ITEM_DESCRIPTIONS["key"]}`
-2. **`economy.py` `SHOP_TIERS`** - add the key to the correct tier list (1/2/3)
-3. **`economy.py` `SHOP_LEVEL_REQ`** - add minimum level if it is T2 (≥10) or T3 (≥20)
-4. **`strings.py` `ITEM_DESCRIPTIONS`** - add the item description (Estonian flavour + English effect)
-5. **`strings.py` `HELP_CATEGORIES["shop"]["fields"]`** - add display entry (sorted by cost)
-6. If the item modifies a cooldown:
-   - **`economy.py`** - add the `if "item" in user["items"]` branch in the relevant `do_<cmd>` function
-   - **`bot.py` `_maybe_remind`** - add `elif cmd == "<cmd>" and "<item>" in items:` branch with the new delay
-   - **`bot.py` `_restore_reminders`** - add the same `elif` branch
-   - **`bot.py` `cmd_cooldowns`** - add the item annotation to the relevant status line
-
----
-
-## Adding a New Level Role
-
-1. **`economy.py` `LEVEL_ROLES`** - add `(min_level, "RoleName")` in descending level order (highest first)
-2. **`bot.py` `_ensure_level_role`** - no changes needed (uses `LEVEL_ROLES` dynamically)
-3. Run **`/economysetup`** in the server to create the role and set its position
-
----
-
-## Adding a New Admin Command
-
-1. **`strings.py` `CMD`** - add `"[Admin] ..."` description
-2. **`strings.py` `OPT`** - add parameter descriptions
-3. **`strings.py` `ADMIN`** - add response and DM strings
-4. **`strings.py` `HELP_CATEGORIES["admin"]["fields"]`** - add the entry
-5. **`economy.py`** - add `do_admin_<name>` function
-6. **`bot.py`** - add command with `@app_commands.default_permissions(manage_guild=True)` and `@app_commands.guild_only()`
-
----
-
-## Economy System Design
-
-### Storage
-
-All economy state is stored in **PocketBase** (`economy_users` collection). `pb_client.py` owns all reads/writes. Each `do_*` function in `economy.py` calls `get_user()` → mutates the local dict → calls `_commit()`. `_commit` does a `PATCH` to PocketBase.
-
-### Currency & Income Sources
-
-| Command | Cooldown | Base Earn | Notes |
-|---|---|---|---|
-| `/daily` | 20h (18h w/ korvaklapid) | 150⬡ | ×streak multiplier, ×2 w/ lan_pass, +5% interest w/ gaming_laptop; prestige daily_plus adds +20% per level |
-| `/work` | 1h (40min w/ monitor) | 15-75⬡ | ×1.5 w/ gaming_hiir, ×1.25 w/ reguleeritav_laud, ×3 30% chance w/ energiajook; prestige work_plus +20%/level |
-| `/beg` | 5min (3min w/ hiirematt) | 10-40⬡ | ×2 w/ klaviatuur |
-| `/crime` | 2h | 200-500⬡ win | 60% success (75% w/ cat6), +30% w/ mikrofon; fail = fine + jail |
-| `/rob` | 2h | 10–25% of target | 45% success (60% w/ jellyfin); fail = fine; cannot rob TipiBOT directly |
-| `/heist` | 4h personal + 1h global | 20–55% of house / n players | solo allowed, max 8; 35%+5%/player success (cap 65%); fail = 3h jail + ~15% balance fine |
-| `/fish` | 2min (90s w/ ussipurk) | varies by fish rarity | Interactive minigame; catches go to inventory; sell with `/fishsell` |
-| `/slots` | - | varies | pair=+0.5× bet; triple tiered; karikas jackpot ×25; ×1.5 w/ monitor_360; miss=lose bet |
-| `/roulette` | - | 2× red/black, 14× green | 1/37 green chance |
-| `/blackjack` | - | 1:1 win, 3:2 BJ, 2:1 double | Dealer stands on 17+; double down on first action only |
-
-### Fishing System
-
-- `/fish` - interactive minigame: cast → wait 5–15s for bite → press button within 2s (3s w/ echolood) → keep or sell
-- Fish stored in `fish_inventory` (list of `{fish_id, weight, value}` objects)
-- `/fishbook` - paginated fish collection showing caught species and inventory counts
-- `/fishsell` - sell all fish from inventory at once
-- `fish_inventory` and `fish_book` **survive prestige resets**
-- `kalavork` (T3, 5000⬡): bumps all caught fish up one rarity tier
-- `ussipurk` (T2, 3500⬡): cooldown 2min → 90s
-- `echolood` (T3, 8000⬡): bite window 2s → 3s
-
-### Prestige System
-
-- Requires level 30 (9000 EXP)
-- Resets: balance, EXP, items, cooldowns, jail
-- Preserves: fish_book, fish_inventory, lifetime stats, prestige_points, season_total_exp, prestige_upgrades
-- Awards prestige_points = max(1, exp ÷ 1000) at time of prestige
-- Each prestige increments `prestige_level` counter
-- Prestige coin/exp multipliers apply to all earned values
-
-**Prestige Shop** (`PRESTIGE_SHOP` in economy.py):
-
-| Upgrade | Max Level | Cost/level | Effect |
-|---|---|---|---|
-| `coin_mult` | 5 | 5 PP | +8% coin multiplier per level |
-| `exp_mult` | 5 | 5 PP | +8% EXP multiplier per level |
-| `daily_plus` | 3 | 7 PP | +20% daily base reward per level |
-| `work_plus` | 3 | 7 PP | +20% work earnings per level |
-
-### "all" Keyword
-Commands that accept a coin amount (`/give`, `/roulette`, `/rps`, `/slots`, `/blackjack`) accept `"all"` to mean the user's full current balance. Parsed by `_parse_amount(value, balance)` in `bot.py`.
-
-### Daily Streak Multipliers
-- 1-2 days: ×1.0 (150⬡)
-- 3-6 days: ×1.5 (225⬡)
-- 7-13 days: ×2.0 (300⬡)
-- 14+ days: ×3.0 (450⬡)
-- `karikas` item: streak survives missed days
-
-### Jail
-- Normal duration: 30 minutes (`JAIL_DURATION`)
-- Heist fail duration: 3 hours (`HEIST_JAIL`) + fine 15% of balance (min 150⬡, max 1000⬡)
-- `gaming_tool`: prevents jail on crime fail
-- `/jailbreak`: 3 single-button dice rolls (both dice at once), need doubles to escape free. Animated reveal with TipiDICE emoji. On fail after 3 tries - bail = 20-30% of balance, min 350⬡. If balance < 350⬡, stay jailed until timer.
-
-### EXP Rewards (from `EXP_REWARDS` in economy.py)
-EXP is awarded on every successful command use. Level formula: `floor(sqrt(exp / 10))`, so Level 5 = 250 EXP, Level 10 = 1000, Level 20 = 4000, Level 30 = 9000.
-
-Fish EXP is awarded per catch (varies by rarity, defined in `FISH_CATALOGUE`). Prestige `exp_mult` upgrade applies to fish EXP.
-
----
-
-## Admin Commands Reference
-
-| Command | What it does |
-|---|---|
-| `/pause` | Toggle maintenance mode - blocks all non-admin commands |
-| `/admincoins @user <amount> <reason>` | Give/take coins (positive/negative). DMs user. |
-| `/adminexp @user <amount> <reason>` | Give/take EXP (positive/negative). Auto-applies level roles on change. DMs user. |
-| `/adminitem @user <item_id> <anna\|eemalda>` | Give or remove any shop item for free. DMs user. |
-| `/adminjail @user <minutes> <reason>` | Manually jail a user. DMs user. |
-| `/adminunjail @user` | Remove jail from a user. |
-| `/adminban @user <reason>` | Ban from all economy commands. DMs user. |
-| `/adminunban @user` | Lift economy ban. |
-| `/adminreset @user <reason>` | Wipe balance, EXP, items, streak. DMs user. |
-| `/adminview @user` | Full profile: balance, EXP/level, streak, prestige, fish stats, items, timestamps. |
-| `/adminseason <top_n>` | End season: DM top N players, reset all EXP. |
-
-All admin commands require **Manage Guild** permission and work in any channel (bypass pause and channel restrictions).
-
----
-
-## Role Hierarchy (Discord)
-
-Order top to bottom in server roles:
-
-```
-[Bot managed role]  ← bot's own role, always at top of our stack
-ECONOMY             ← given to everyone who uses any economy command
-TipiLEGEND          ← level 30+
-TipiCHAD            ← level 20+
-TipiHUSTLER         ← level 10+
-TipiGRINDER         ← level 5+
-TipiNOOB            ← level 1+
-```
-
-Run `/economysetup` to auto-create all roles and set their positions. The command is idempotent - safe to run multiple times.
-
-Role assignment:
-- **ECONOMY** role: given automatically on first EXP award (i.e. first successful economy command)
-- **Level roles**: given/swapped automatically on level-up; synced on `/rank`
-- **`/adminexp`**: automatically re-applies level roles if level changes
-
----
-
-## Shop Tiers & Level Requirements
-
-| Tier | Level Required | Items |
-|---|---|---|
-| T1 | 0 (any) | gaming_hiir, hiirematt, korvaklapid, lan_pass, anticheat, energiajook, gaming_laptop |
-| T2 | 10 | reguleeritav_laud, jellyfin, mikrofon, klaviatuur, monitor, cat6, **ussipurk** |
-| T3 | 20 | monitor_360, karikas, gaming_tool, **kalavork**, **echolood** |
-
-Shop display is sorted by cost (ascending) within each tier.
-The `SHOP_LEVEL_REQ` dict in `economy.py` controls per-item lock thresholds.
-
----
-
-## strings.py Organisation
-
-| Section | Dict | Usage in bot.py |
-|---|---|---|
-| Flavour text | `WORK_JOBS`, `BEG_LINES`, `CRIME_WIN`, `CRIME_LOSE` | Randomised descriptions |
-| Command descriptions | `CMD["key"]` | `@tree.command(description=S.CMD["key"])` |
-| Parameter descriptions | `OPT["key"]` | `@app_commands.describe(param=S.OPT["key"])` |
-| Help embed | `HELP_CATEGORIES["cat"]` | `cmd_help` |
-| Banned message | `MSG_BANNED` | All banned checks |
-| Reminder options | `REMINDER_OPTS` | `RemindersSelect` dropdown |
-| Slots outcomes | `SLOTS_TIERS["tier"]` → `(title, color)` | `cmd_slots` |
-| Embed titles | `TITLE["key"]` | `discord.Embed(title=S.TITLE["key"])` |
-| Error messages | `ERR["key"]` | `send_message(S.ERR["key"])` - use `.format(**kwargs)` for dynamic parts |
-| Cooldown messages | `CD_MSG["cmd"].format(ts=_cd_ts(...))` | Cooldown responses |
-| Shop UI | `SHOP_UI["key"]` | `_shop_embed` |
-| Item descriptions | `ITEM_DESCRIPTIONS["item_key"]` | `economy.SHOP[key]["description"]` |
-| Fish UI | `FISH_UI["key"]` | `/fish`, `/fishbook`, `/fishsell` |
-| Fish names | `FISH_NAMES["fish_id"]` | Fish display name |
-| Admin responses | `ADMIN["key"]` | Admin command success/DM messages |
-
----
-
-## Constants Location Quick-Reference
-
-| Constant | File | Description |
-|---|---|---|
-| `SHOP` | `economy.py` | All shop items (name, emoji, cost, description) |
-| `SHOP_TIERS` | `economy.py` | Which items are in T1/T2/T3 |
-| `SHOP_LEVEL_REQ` | `economy.py` | Min level per item |
-| `COOLDOWNS` | `economy.py` | Base cooldown per command |
-| `JAIL_DURATION` | `economy.py` | How long jail lasts |
-| `LEVEL_ROLES` | `economy.py` | `[(min_level, "RoleName"), ...]` highest first |
-| `ECONOMY_ROLE` | `economy.py` | Name of the base economy participation role |
-| `EXP_REWARDS` | `economy.py` | EXP per command |
-| `FISH_CATALOGUE` | `economy.py` | All fish species (rarity, weight, coins, exp) |
-| `PRESTIGE_SHOP` | `economy.py` | Prestige upgrade definitions |
-| `HOUSE_ID` | `economy.py` | Bot's user ID (house account for /rob) |
-| `MIN_BAIL` | `economy.py` | Minimum bail payment (350⬡) |
-| `COIN` | `economy.py` | The coin emoji string |
-
----
-
-## Balance Notes (as of current version)
-
-- **Beg** is most efficient for active players (3min cooldown + 2× multiplier w/ `klaviatuur` = high ⬡/hr)
-- **Work** is best for passive players (1h cooldown, fire and forget)
-- **Crime** is high risk/reward - best with `cat6` + `mikrofon`
-- **`lan_pass`** (1200⬡) doubles daily - good long-term investment
-- **`gaming_laptop`** (1500⬡) 5% interest, capped 500⬡/day - snowballs with large balance
-- `anticheat` is consumable (2 uses) - only item that can be re-bought
-- `karikas` (T3) is the only item that preserves a daily streak across missed days
-- `reguleeritav_laud` (T2) stacks with `gaming_hiir`: combined ×1.5 × ×1.25 = ×1.875
-- **Fishing** is a steady passive income; `kalavork` (T3) dramatically increases fish value by bumping rarity

README.md

@@ -10,8 +10,9 @@ Discord bot for the TipiLAN community. Manages member roles and nicknames via Go
 2. [Member Management](#member-management)
 3. [Admin Commands](#admin-commands)
 4. [Birthday System](#birthday-system)
-5. [TipiCOIN Economy](#tipicoin-economy)
+5. [Tournament Team Roles](#tournament-team-roles)
-6. [Project Structure](#project-structure)
+6. [TipiCOIN Economy](#tipicoin-economy)
+7. [Project Structure](#project-structure)
 
 ---
 
@@ -70,7 +71,7 @@ The economy system stores all player data in [PocketBase](https://pocketbase.io/
 1. Download `pocketbase.exe` (Windows) from https://pocketbase.io/docs/ and place it in the project root.
 2. Start PocketBase: `.\pocketbase.exe serve`
 3. Open the admin UI at http://127.0.0.1:8090/_/ and create a superuser account.
-4. Create a collection named `economy_users` - see `docs/POCKETBASE_SETUP.md` for the full schema.
+4. Create two collections for profile separation: `economy_users_dev` and `economy_users_prod` - see `docs/POCKETBASE_SETUP.md` for schema notes, then run `python scripts/sync_pb_schema.py` to add every field the bot persists. Re-run it after any update that introduces new fields (PocketBase silently drops writes to fields missing from the schema).
 5. Set `PB_URL`, `PB_ADMIN_EMAIL`, `PB_ADMIN_PASSWORD` in `.env`.
 6. **One-time data migration** (only if you have an existing `data/economy.json`): `python scripts/migrate_to_pb.py`
 
@@ -88,15 +89,27 @@ cp .env.example .env
 
 | Variable | Description |
 |---|---|
-| `DISCORD_TOKEN` | Bot token from Discord Developer Portal |
+| `BOT_PROFILE` | Runtime profile: `dev` or `economy` |
+| `DISCORD_TOKEN_DEV` | Dev bot token from Discord Developer Portal |
+| `DISCORD_TOKEN_ECONOMY` | Economy bot token from Discord Developer Portal |
+| `DISCORD_TOKEN` | Legacy fallback token (optional) |
 | `SHEET_ID` | ID from the Google Sheet URL |
 | `GOOGLE_CREDS_PATH` | Path to `credentials.json` (default: `credentials.json`) |
-| `GUILD_ID` | Right-click server → Copy Server ID (Developer Mode on) |
+| `GUILD_ID_DEV` | Dev bot guild ID |
-| `BIRTHDAY_CHANNEL_ID` | Channel for birthday `@here` pings |
+| `GUILD_ID_ECONOMY` | Economy bot guild ID |
+| `GUILD_ID` | Legacy fallback guild ID (optional) |
+| `BIRTHDAY_CHANNEL_ID_DEV` | Channel for birthday `@here` pings in dev profile |
+| `BIRTHDAY_CHANNEL_ID_ECONOMY` | Optional birthday channel in economy profile |
+| `BIRTHDAY_CHANNEL_ID` | Legacy fallback birthday channel ID (optional) |
 | `BIRTHDAY_WINDOW_DAYS` | Days before birthday that on-join check flags it (default: 7) |
 | `PB_URL` | PocketBase base URL (default: `http://127.0.0.1:8090`) |
 | `PB_ADMIN_EMAIL` | PocketBase superuser e-mail |
 | `PB_ADMIN_PASSWORD` | PocketBase superuser password |
+| `PB_ECONOMY_COLLECTION_DEV` | PocketBase collection used by `BOT_PROFILE=dev` |
+| `PB_ECONOMY_COLLECTION_ECONOMY` | PocketBase collection used by `BOT_PROFILE=economy` |
+| `PB_ECONOMY_COLLECTION` | Legacy fallback collection (optional) |
+| `TEAM_SHEET_ID` | Tournament registration spreadsheet (separate from the member sheet). Unset = team sync off |
+| `TEAM_DIVIDER_<GAME>_<YEAR>` | Divider role that a sheet section's teams get positioned under - see [Tournament team roles](#tournament-team-roles) |
 
 ### 6. Install & Run
 
@@ -110,7 +123,12 @@ pip install -r requirements.txt
 # Terminal 1 - keep running
 .\pocketbase.exe serve
 
-# Terminal 2
+# Terminal 2 (dev bot)
+set BOT_PROFILE=dev
+python bot.py
+
+# Terminal 3 (economy bot)
+set BOT_PROFILE=economy
 python bot.py
 ```
 
@@ -146,11 +164,14 @@ Admins (bot lacks permission to modify them) are silently skipped and still mark
 ## Admin Commands
 
 > These commands are hidden from users who don't have the required permission. Override per-role in **Server Settings → Integrations → Bot**.
+>
+> Profile note: `/check`, `/member`, and `/birthdays` are available only when `BOT_PROFILE=dev`.
 
 | Command | Permission | What it does |
 |---|---|---|
 | `/check` | Manage Roles | Refreshes sheet data, backfills missing User IDs, syncs nicknames + roles for every member, reports stats |
 | `/member @user` | Manage Roles | Shows a member's full sheet data + calculated age |
+| `/teamsync` | Bot admin | Reloads the tournament registration sheet, grants/removes team roles, and repositions them under their dividers. See [Tournament Team Roles](#tournament-team-roles) |
 | `/sync` | Manage Guild | Re-registers slash commands with Discord |
 | `/restart` | Manage Guild | Gracefully restarts the bot process; posts ✅ in the same channel when back up |
 | `/shutdown` | Manage Guild | Shuts the bot down cleanly without restarting |
@@ -203,9 +224,49 @@ If a member joins and their birthday is within `BIRTHDAY_WINDOW_DAYS` days, a bi
 
 ---
 
+## Tournament Team Roles
+
+Runs on the **economy** profile only, driven by the separate `TEAM_SHEET_ID` spreadsheet. It is independent of the member roster - players are matched straight from the registration sheet by Discord username, and never need a row in the member sheet.
+
+Re-runs automatically **every hour**, and on demand via `/teamsync` (admin).
+
+### What it does
+
+- Grants each registered player the role named after their team, creating that role if it doesn't exist yet
+- Removes team roles they no longer hold (switched teams, dropped out)
+- Positions every team role directly beneath its game's divider role
+- **Only role names present in the sheet are ever added, removed, or moved** - no unrelated role is at risk
+
+### Divider placement
+
+The registration sheet stacks several game sections per tab, each under a merged title row:
+
+```
+[merged] TipiLAN 2026 CS2 Registration Log
+No | Team Name | Lineup (nickname, citizenship) | ...
+1  | GENESIS   | kapa (EST), neaQ (EST)         | ...
+```
+
+Set one `TEAM_DIVIDER_*` variable per section to say where those teams belong:
+
+```bash
+TEAM_DIVIDER_CS2_2026="====== COUNTER-STRIKE 2 2026 ======"
+TEAM_DIVIDER_LOL_2026="===== LEAGUE OF LEGENDS 2026 ====="
+```
+
+- **The key suffix** is matched against the section's title row. Every underscore-separated part must appear in it as a whole word, so `CS2_2026` matches only the 2026 CS2 block, while a plain `CS2` would match that game in any year. When several keys match, the most specific one (most parts) wins.
+- **The value** is the *exact* Discord role name, decoration included. Copy it from Server Settings → Roles.
+- Sections matching no key still get their team roles - they just aren't repositioned.
+
+Teams are ordered alphabetically downwards under their divider. Every sync re-checks placement, so roles that predate this feature get pulled into place on the next run.
+
+> The bot can only move roles **below its own** role. Drag the TipiBOT role above your dividers, or placement is skipped and reported as an error.
+
+---
+
 ## TipiCOIN Economy
 
-All economy data is stored in **PocketBase** (`economy_users` collection - see `pb_client.py`). The currency is **TipiCOIN** (⬡), displayed as a custom Discord emoji configured in `economy.py → COIN`.
+All economy data is stored in **PocketBase** (`economy_users` collection - see `core/pb_client.py`). The currency is **TipiCOIN** (⬡), displayed as a custom Discord emoji configured in `core/economy/store.py → COIN`.
 
 ---
 
@@ -228,15 +289,15 @@ The house is listed at **#0** on the leaderboard. Players can attempt to rob it
 
 | Command | Cooldown | Base payout | Notes |
 |---|---|---|---|
-| `/daily` | 20h | 150 ⬡ | Streak multiplier applied (see below). Kõrvaklapid reduces cooldown to 18h. LAN Pilet doubles the reward. Botikoobas adds 5% interest on your balance (capped at 500 ⬡/day). Prestige daily_plus adds +20% base per upgrade level. |
+| `/daily` | 20h | 150 ⬡ | Streak multiplier applied (see below). Kõrvaklapid reduces cooldown to 18h. LAN pilet doubles the reward. Bot Farm adds 5% interest on your balance (capped at 500 ⬡/day). Prestige daily_plus adds +20% base per upgrade level. |
 | `/work` | 1h | 15–75 ⬡ | Random job flavour text. Mängurihiir +50%, Reguleeritav laud +25% (stacks). Red Bull: 30% chance of ×3. Ultralai monitor reduces cooldown to 40min. Prestige work_plus adds +20% per upgrade level. |
-| `/beg` | 5min | 10–40 ⬡ | XL hiirematt reduces cooldown to 3min. Mehhaaniline klaviatuur multiplies earnings ×2. |
+| `/beg` | 5min | 10–40 ⬡ | Hiirematt reduces cooldown to 3min. Mehaaniline klaviatuur multiplies earnings ×2. |
-| `/crime` | 2h | 200–500 ⬡ | 60% success rate (75% with CAT6). +30% earnings with Mikrofon on win. Fail = fine + 30min jail. Mänguritool skips jail on fail. |
+| `/crime` | 2h | 200–500 ⬡ | 60% success rate (75% with Cat6 kaabel). +30% earnings with Mikrofon on win. Fail = fine + 30min jail. Gaming tool skips jail on fail. |
 | `/fish` | 2min | varies | Interactive minigame. Cast → wait for bite → press button within 2s → keep in inventory or sell immediately. Ussipurk reduces cooldown to 90s. |
 
 ### Daily streak
 
-The streak increments each time you claim `/daily` within the cooldown window. Missing a day resets it to 1 **unless** you own the TipiLAN trofee item.
+The streak increments each time you claim `/daily` within the cooldown window. Missing a day resets it to 1 **unless** you own the TipiLAN karikas item.
 
 | Streak | Multiplier | Payout (base) |
 |---|---|---|
@@ -245,7 +306,7 @@ The streak increments each time you claim `/daily` within the cooldown window. M
 | 7–13 days | ×2.0 | 300 ⬡ |
 | 14+ days | ×3.0 | 450 ⬡ |
 
-> With LAN Pilet (×2 daily) and a 14-day streak (×3.0) the base payout reaches **900 ⬡**. Add Botikoobas 5% interest on top.
+> With LAN pilet (×2 daily) and a 14-day streak (×3.0) the base payout reaches **900 ⬡**. Add Bot Farm 5% interest on top.
 
 ---
 
@@ -262,13 +323,13 @@ Every successful economy action awards EXP:
 | `/rob` success | +15 |
 | Gambling win (`/roulette`, `/slots`, `/blackjack`) | Scaled by bet: <10⬡ = 0, 10–99⬡ = +5, 100–999⬡ = +10, 1 000–9 999⬡ = +15, 10 000–99 999⬡ = +20, 100 000+⬡ = +25 |
 | `/beg` completed | +5 |
-| `/fish` catch | +3 to +15 (varies by rarity) |
+| `/fish` catch | +2 to +25 (varies by rarity: common 2–3, uncommon 6–7, rare 10, epic 14–15, legendary 25) |
 
-**Level formula:** `level = floor(√(total_exp ÷ 10))`
+**Level formula:** `level = max(1, floor(√(total_exp ÷ 10)))`
 
 | Level | EXP required | Milestone |
 |---|---|---|
-| 1 | 10 | TipiNOOB role |
+| 1 | 0 | TipiNOOB role |
 | 5 | 250 | TipiGRINDER role |
 | 10 | 1 000 | TipiHUSTLER role · **T2 shop unlocks** |
 | 20 | 4 000 | TipiCHAD role · **T3 shop unlocks** |
@@ -323,6 +384,7 @@ The **ECONOMY** role is granted on your first EXP award (i.e. first successful e
 | `/shop` | Browse all items by tier. Shows owned status, Anticheat charges remaining, and level lock for T2/T3. |
 | `/buy <item>` | Purchase an item by name (partial match accepted). |
 | `/reminders` | Toggle per-command DM notifications. Bot DMs you the moment each cooldown expires. |
+| `/quests` | Personal daily (3) and weekly (2) quests with progress bars and a claim button. |
 | `/fish` | Interactive fishing minigame. Cast, wait for bite, pull, then keep or sell. 2min cooldown (90s with Ussipurk). |
 | `/fishbook` | View your fish collection - all caught species, rarity, count, and current inventory amounts. |
 | `/fishsell` | Sell all fish currently in your inventory at once. |
@@ -334,7 +396,7 @@ The **ECONOMY** role is granted on your first EXP award (i.e. first successful e
 
 ### Jail system
 
-`/crime` fail (without Mänguritool) jails you for **30 minutes**. While jailed, `/work`, `/beg`, `/crime`, `/rob`, and `/give` are blocked.
+`/crime` fail (without Gaming tool) jails you for **30 minutes**. While jailed, `/work`, `/beg`, `/crime`, `/rob`, and `/give` are blocked.
 
 #### `/jailbreak`
 Press the roll button - both dice are rolled simultaneously with an animated reveal. **3 attempts** per sentence. Matching values (doubles) = free instantly. If all 3 fail you pay bail:
@@ -363,6 +425,19 @@ Spend PP in `/prestigeshop`:
 
 ---
 
+### Quests
+
+`/quests` shows your personal quest board: **3 daily** and **2 weekly** quests with progress bars and a claim button.
+
+- Quests track counters you're already grinding: work/beg counts, coins earned, amount wagered, fish caught, crimes succeeded, coins given, heists joined.
+- Progress starts counting from the moment the quest set rolls - stats earned before that don't count.
+- The daily set resets at **UTC midnight**, the weekly set on the **ISO week** rollover. Each player gets their own rotation.
+- Rewards are TipiCOINs (prestige coin multiplier applies) plus EXP through the normal level-up path.
+
+> Schema note: the quest fields live in PocketBase - after pulling this feature run `python scripts/sync_pb_schema.py` once (it reconciles both the dev and prod collections with everything the bot persists).
+
+---
+
 ### Fishing
 
 `/fish` is an interactive minigame with a **2-minute cooldown** (90s with Ussipurk):
@@ -390,39 +465,34 @@ All items are **permanent** once purchased **except Anticheat**, which expires a
 | Item | Cost | Effect |
 |---|---|---|
 | Mängurihiir | 500 ⬡ | `/work` earns +50% |
-| XL hiirematt | 600 ⬡ | `/beg` cooldown 5min → 3min |
+| Hiirematt | 600 ⬡ | `/beg` cooldown 5min → 3min |
-| Anticheat | 750 ⬡ | Rob attempts against you fail and fine the robber. **2 uses**, then repurchase. |
 | Red Bull | 800 ⬡ | `/work` has 30% chance to earn ×3 |
+| Anticheat | 1 000 ⬡ | Rob attempts against you fail and fine the robber. **2 uses**, then repurchase. |
 | Kõrvaklapid | 1 200 ⬡ | `/daily` cooldown 20h → 18h |
-| LAN Pilet | 1 200 ⬡ | `/daily` reward ×2 |
+| LAN pilet | 1 200 ⬡ | `/daily` reward ×2 |
-| Botikoobas | 1 500 ⬡ | `/daily` adds 5% interest on balance (capped at 500 ⬡/day) |
+| Bot Farm | 1 500 ⬡ | `/daily` adds 5% interest on balance (capped at 500 ⬡/day) |
 
 #### Tier 2 - level 10 required (TipiHUSTLER+)
 
 | Item | Cost | Effect |
 |---|---|---|
-| Mehhaaniline klaviatuur | 1 800 ⬡ | `/beg` earns ×2 |
+| Mehaaniline klaviatuur | 1 800 ⬡ | `/beg` earns ×2 |
 | Ultralai monitor | 2 500 ⬡ | `/work` cooldown 1h → 40min |
-| Mikrofon | 2 800 ⬡ | `/crime` win earns +30% |
+| Eraldiseisev mikrofon | 2 800 ⬡ | `/crime` win earns +30% |
 | Reguleeritav laud | 3 500 ⬡ | `/work` earns +25% (stacks with Mängurihiir → ×1.875 combined) |
-| CAT6 netikaabel | 3 500 ⬡ | `/crime` success rate 60% → 75% |
+| Cat6 kaabel | 3 500 ⬡ | `/crime` success rate 60% → 75% |
 | Jellyfin server | 4 000 ⬡ | `/rob` success rate 45% → 60% |
-
-#### Tier 2 - level 10 required (TipiHUSTLER+) - continued
-
-| Item | Cost | Effect |
-|---|---|---|
 | Ussipurk | 3 500 ⬡ | `/fish` cooldown 2min → 90s |
 
 #### Tier 3 - level 20 required (TipiCHAD+)
 
 | Item | Cost | Effect |
 |---|---|---|
-| TipiLAN trofee | 6 000 ⬡ | Daily streak survives missed days |
-| 360hz monitor | 7 500 ⬡ | Slots jackpot 10× → 15×, triple 4× → 6× |
-| Mänguritool | 9 000 ⬡ | `/crime` fail never sends you to jail |
 | Kalavõrk | 5 000 ⬡ | All fish caught are bumped up one rarity tier |
+| TipiLAN karikas | 6 000 ⬡ | Daily streak survives missed days |
+| 360Hz monitor | 7 500 ⬡ | Slots triple multipliers ×1.5 (jackpot ×25 → ×37) |
 | Echolood | 8 000 ⬡ | Fishing bite window 2s → 3s |
+| Gaming tool | 9 000 ⬡ | `/crime` fail never sends you to jail |
 
 ---
 
@@ -431,7 +501,7 @@ All items are **permanent** once purchased **except Anticheat**, which expires a
 Commands that accept a coin amount (`/give`, `/roulette`, `/rps`, `/slots`, `/blackjack`) accept `"all"` as the amount to wager your entire balance.
 
 ### Custom emoji
-Change `COIN` in `economy.py` to any Discord emoji string:
+Change `COIN` in `core/economy/store.py` to any Discord emoji string:
 ```python
 COIN = "<:tipicoin:YOUR_EMOJI_ID>"
 ```
@@ -440,12 +510,12 @@ COIN = "<:tipicoin:YOUR_EMOJI_ID>"
 
 ## Logging
 
-All logs are written to the `logs/` directory (auto-created on startup).
+Logs are written under `logs/<BOT_PROFILE>/` (auto-created on startup), so dev and economy profiles keep separate log streams.
 
 | File | Rotation | Contents |
 |---|---|---|
-| `logs/bot.log` | 5 MB x 5 backups | All INFO+ events: commands, errors, member sync |
+| `logs/<profile>/bot.log` | 5 MB x 5 backups | All INFO+ events: commands, errors, member sync |
-| `logs/transactions.log` | Daily, 30 days | Economy transactions only: every balance change with user, amount, new balance |
+| `logs/<profile>/transactions.log` | Daily, 30 days | Economy transactions only: every balance change with user, amount, new balance |
 
 The terminal output is **colour-coded** by log level (green = INFO, yellow = WARNING, red = ERROR).
 
@@ -456,28 +526,68 @@ Every slash command invocation is logged with the user ID, display name, and all
 ## Project Structure
 
 ```
-├── bot.py                  # Discord client, all slash commands, event handlers
+├── bot.py                          # Discord client, event handlers, shared helpers; wires command modules together
-├── economy.py              # TipiCOIN business logic, constants (SHOP, COOLDOWNS, etc.)
+├── strings/                        # All user-facing strings, split by domain; re-exported so `import strings` works unchanged
-├── pb_client.py            # Async PocketBase REST client (auth + CRUD for economy_users)
+│   ├── __init__.py                 # Re-exports every name from the submodules
-├── strings.py              # All user-facing strings, command descriptions, help text
+│   ├── common.py                   # System messages, embed TITLEs, ERR, CD_MSG, status/send/patchnotes/reminders
-├── member_sync.py          # Role/nickname/birthday sync logic
+│   ├── commands.py                 # CMD + OPT descriptions, HELP_CATEGORIES, HELP_UI
-├── sheets.py               # Google Sheets read/write + in-memory cache
+│   ├── member.py                   # /check, member/birthday/channel/economy-setup UI
-├── config.py               # Environment variable loader
+│   ├── economy.py                  # Income flavour + income/profile/shop/quests/leaderboard/request UI
-├── requirements.txt        # Python dependencies
+│   ├── admin.py                    # Admin responses, season reset, prestige
-├── .env.example            # Template for secrets
+│   ├── games.py                    # Slots, roulette, RPS, blackjack, heist, jailbreak
-├── .env                    # Your secrets (gitignored)
+│   └── fishing.py                  # Fish catalogue, rarities, /fish UI
-├── credentials.json        # Google service account key (gitignored)
+├── config.py                       # Environment variable loader
+├── core/
+│   ├── economy/                    # TipiCOIN business logic (re-exported via core/economy/__init__.py)
+│   │   ├── store.py                # User records, per-user locks, time/cooldown helpers, txn log
+│   │   ├── house.py                # House account (fines in, heists out)
+│   │   ├── levels.py               # EXP, levels, vanity roles
+│   │   ├── shop.py                 # Item catalogue + /buy
+│   │   ├── income.py               # /daily, /work, /beg, /crime, /rob, /give
+│   │   ├── gambling.py             # /roulette, /slots, /rps, /blackjack
+│   │   ├── fishing.py              # Fish catalogue + minigame flows
+│   │   ├── quests.py               # Daily/weekly quest system
+│   │   ├── prestige.py             # Prestige resets + upgrade shop
+│   │   ├── jail.py                 # Jail, jailbreak, bail
+│   │   ├── heist.py                # Group heists against the house
+│   │   ├── leaderboards.py         # All leaderboard queries
+│   │   └── admin.py                # Admin mutations + season reset
+│   ├── pb_client.py                # Async PocketBase REST client (auth + CRUD for economy_users)
+│   ├── sheets.py                   # Google Sheets read/write + in-memory cache
+│   └── member_sync.py              # Role/nickname/birthday sync logic
+├── commands/
+│   ├── dev_member_commands.py      # /check, /member (dev profile)
+│   ├── dev_member_runtime.py       # on_member_join + birthday daily task helpers
+│   ├── economy_admin_commands.py   # /admincoins, /adminexp, /adminitem, /adminjail, ...
+│   ├── economy_extra_commands.py   # /heist, /jailbreak, /reminders, /request, ...
+│   ├── economy_fish_commands.py    # /fish, /fishbook, /fishsell
+│   ├── economy_games_commands.py   # /roulette, /slots, /blackjack, /rps
+│   ├── economy_income_commands.py  # /daily, /work, /beg, /crime, /rob
+│   ├── economy_prestige_commands.py# /prestige, /prestigeshop, /prestigebuy
+│   ├── economy_profile_commands.py # /balance, /rank, /stats, /cooldowns, /leaderboard
+│   ├── economy_quests_commands.py  # /quests (daily/weekly quest board + claim)
+│   ├── economy_support_commands.py # /shop, /buy, /give, /economysetup
+│   ├── info_commands.py            # /patchnotes, /help auxiliaries
+│   ├── ops_admin_commands.py       # /sync, /restart, /shutdown, /pause, /send, /status
+│   └── ops_channel_commands.py     # channel allowlist gating
 ├── docs/
-│   ├── DEV_NOTES.md        # Developer reference (architecture, checklists, constants)
+│   ├── DEV_NOTES.md                # Developer reference (architecture, checklists, constants)
-│   ├── CHANGELOG.md        # Version history
+│   ├── PATCHNOTES.md               # Player-facing patch notes (surfaced via /patchnotes)
-│   └── POCKETBASE_SETUP.md # PocketBase collection schema + setup instructions
+│   └── POCKETBASE_SETUP.md         # PocketBase collection schema + setup instructions
 ├── scripts/
-│   ├── migrate_to_pb.py    # One-time migration: economy.json → PocketBase
+│   ├── migrate_to_pb.py            # One-time legacy migration: economy.json → PocketBase
-│   └── add_stats_fields.py # Schema migration: add new fields to economy_users collection
+│   ├── sync_pb_schema.py           # Reconcile PB collections with the full user schema (dev + prod)
-├── data/
+│   ├── add_stats_fields.py         # Older partial schema migration (superseded by sync_pb_schema.py)
-│   └── birthday_sent.json  # Birthday dedup log (auto-created)
+│   ├── add_quest_fields.py         # Older partial schema migration (superseded by sync_pb_schema.py)
-├── pb_data/                # PocketBase database files (auto-created, gitignored)
+│   └── reset_pb_collections.py     # Destructive: deletes & recreates economy collections (--confirm required)
-└── logs/
+├── requirements.txt                # Python dependencies
-    ├── bot.log             # General rotating log (auto-created)
+├── .env.example                    # Template for secrets
-    └── transactions.log    # Daily economy transaction log (auto-created)
+├── .env                            # Your secrets (gitignored)
+├── credentials.json                # Google service account key (gitignored)
+├── data/<BOT_PROFILE>/
+│   └── birthday_sent.json          # Birthday dedup log (auto-created per profile)
+├── pb_data/                        # PocketBase database files (auto-created, gitignored)
+└── logs/<BOT_PROFILE>/
+    ├── bot.log                     # General rotating log (auto-created)
+    └── transactions.log            # Daily economy transaction log (auto-created)
 ```

commands/dev_member_commands.py

@@ -0,0 +1,315 @@
+from __future__ import annotations
+
+import datetime
+import logging
+from typing import Callable
+
+import discord
+from discord import app_commands
+
+from core import sheets
+from core.admin import bot_admin_check
+import strings as S
+from core.member_sync import announce_birthday, sync_member, today_local
+
+
+class BirthdayPages(discord.ui.View):
+    def __init__(self, pages: list[discord.Embed], start: int = 0):
+        super().__init__(timeout=120)
+        self.pages = pages
+        self.current = start
+        self._update_buttons()
+
+    def _update_buttons(self):
+        self.prev_button.disabled = self.current == 0
+        self.next_button.disabled = self.current >= len(self.pages) - 1
+
+    @discord.ui.button(label="◀", style=discord.ButtonStyle.secondary)
+    async def prev_button(self, interaction: discord.Interaction, button: discord.ui.Button):
+        self.current -= 1
+        self._update_buttons()
+        await interaction.response.edit_message(embed=self.pages[self.current], view=self)
+
+    @discord.ui.button(label="▶", style=discord.ButtonStyle.secondary)
+    async def next_button(self, interaction: discord.Interaction, button: discord.ui.Button):
+        self.current += 1
+        self._update_buttons()
+        await interaction.response.edit_message(embed=self.pages[self.current], view=self)
+
+
+def _build_birthday_pages(
+    guild: discord.Guild | None = None,
+) -> tuple[list[discord.Embed], int]:
+    """Build 12 monthly embeds (one per calendar month).
+
+    Returns (pages, start_index) where start_index is the current month.
+    """
+    rows = sheets.get_cache()
+    today = today_local()
+
+    by_month: dict[int, list[tuple[int, str, int | None]]] = {m: [] for m in range(1, 13)}
+
+    for row in rows:
+        name = str(row.get("Nimi", "")).strip()
+        bday_str = str(row.get("Sünnipäev", "")).strip()
+        if not name or not bday_str or bday_str.strip().lower() in ("-", "x", "n/a", "none", "ei"):
+            continue
+        bday = None
+        for fmt in ["%d/%m/%Y", "%Y-%m-%d", "%m-%d"]:
+            try:
+                bday = datetime.datetime.strptime(bday_str, fmt).date()
+                break
+            except ValueError:
+                continue
+        if bday is None:
+            continue
+        raw_uid = str(row.get("User ID", "")).strip()
+        try:
+            uid = int(raw_uid) if raw_uid and raw_uid not in ("0", "-") else None
+        except ValueError:
+            uid = None
+        by_month[bday.month].append((bday.day, name, uid))
+
+    pages: list[discord.Embed] = []
+    for month in range(1, 13):
+        entries = sorted(by_month[month], key=lambda x: x[0])
+        embed = discord.Embed(
+            title=f"🎂 {S.BIRTHDAY_MONTHS[month - 1]}",
+            color=0xF4A261,
+        )
+        if not entries:
+            embed.description = S.BIRTHDAY_UI["no_entries"]
+        else:
+            lines = []
+            for day, name, uid in entries:
+                try:
+                    this_year = datetime.date(today.year, month, day)
+                except ValueError:
+                    this_year = datetime.date(today.year, month, day - 1)
+                next_bday = this_year if this_year >= today else this_year.replace(year=today.year + 1)
+                days_until = (next_bday - today).days
+                if days_until == 0:
+                    when = S.BIRTHDAY_UI["today"]
+                elif days_until == 1:
+                    when = S.BIRTHDAY_UI["tomorrow"]
+                else:
+                    when = S.BIRTHDAY_UI["in_days"].format(days=days_until)
+                display = name
+                if guild and uid:
+                    member = guild.get_member(uid)
+                    if member:
+                        display = member.mention
+                lines.append(f"{display} - {day:02d}/{month:02d}  ·  {when}")
+            embed.description = "\n".join(lines)
+        embed.set_footer(text=S.BIRTHDAY_UI["footer"].format(month=month, month_name=S.BIRTHDAY_MONTHS[month - 1]))
+        pages.append(embed)
+
+    return pages, today.month - 1
+
+
+def _sheet_stats(rows: list[dict]) -> str:
+    """Return a formatted string with sheet completeness statistics."""
+    total = len(rows)
+    missing_uid = []
+    missing_discord = []
+    missing_birthday = []
+
+    for row in rows:
+        name = str(row.get("Nimi", "")).strip() or S.CHECK_UI["no_name"]
+        uid = str(row.get("User ID", "")).strip()
+        discord_name = str(row.get("Discord", "")).strip()
+        bday = str(row.get("Sünnipäev", "")).strip()
+
+        if not uid or uid == "0":
+            missing_uid.append(name)
+        if not discord_name:
+            missing_discord.append(name)
+        if not bday:
+            missing_birthday.append(name)
+
+    lines = [S.CHECK_UI["sheet_stats_header"].format(total=total)]
+    lines.append("")
+
+    def stat_line(label: str, missing: list[str]) -> str:
+        count = len(missing)
+        if count == 0:
+            return S.CHECK_UI["stat_ok"].format(label=label)
+        names = ", ".join(missing[:5])
+        more = S.CHECK_UI["stat_more"].format(count=count - 5) if count > 5 else ""
+        return S.CHECK_UI["stat_warn"].format(label=label, count=count, names=names, more=more)
+
+    lines.append(stat_line(S.CHECK_UI["stat_uid"], missing_uid))
+    lines.append(stat_line(S.CHECK_UI["stat_discord"], missing_discord))
+    lines.append(stat_line(S.CHECK_UI["stat_bday"], missing_birthday))
+
+    return "\n".join(lines)
+
+
+def register_dev_member_commands(
+    tree: app_commands.CommandTree,
+    bot: discord.Client,
+    log: logging.Logger,
+    has_announced_today: Callable[[int], bool],
+    mark_announced_today: Callable[[int], None],
+) -> None:
+    @tree.command(name="birthdays", description=S.CMD["birthdays"])
+    @app_commands.guild_only()
+    async def cmd_birthdays(interaction: discord.Interaction):
+        await interaction.response.defer()
+
+        try:
+            await sheets.refresh()
+        except Exception as e:
+            await interaction.followup.send(S.ERR["sheet_error"].format(error=e), ephemeral=True)
+            return
+
+        pages, start = _build_birthday_pages(guild=interaction.guild)
+        await interaction.followup.send(embed=pages[start], view=BirthdayPages(pages, start=start))
+
+    @tree.command(name="check", description=S.CMD["check"])
+    @app_commands.guild_only()
+    @bot_admin_check()
+    async def cmd_check(interaction: discord.Interaction):
+        await interaction.response.defer(ephemeral=True)
+
+        guild = interaction.guild
+        if guild is None:
+            await interaction.followup.send(S.ERR["guild_only"], ephemeral=True)
+            return
+
+        try:
+            data = await sheets.refresh()
+        except Exception as e:
+            await interaction.followup.send(S.ERR["sheet_error"].format(error=e), ephemeral=True)
+            return
+
+        ids_filled = 0
+        for row in data:
+            uid = str(row.get("User ID", "")).strip()
+            if uid and uid not in ("0", "-"):
+                continue
+            discord_name = str(row.get("Discord", "")).strip()
+            if not discord_name:
+                continue
+            guild_member = discord.utils.find(
+                lambda m, n=discord_name: m.name.lower() == n.lower(),
+                guild.members,
+            )
+            if guild_member:
+                await sheets.set_user_id(discord_name, guild_member.id)
+                ids_filled += 1
+
+        data = sheets.get_cache()
+
+        changed_count = 0
+        not_found = 0
+        already_ok = 0
+        errors_total = 0
+        birthday_pings = 0
+        details: list[str] = []
+        sync_updates: list[tuple[int, bool]] = []
+
+        for member in guild.members:
+            if member.bot:
+                continue
+
+            result = await sync_member(member, guild)
+
+            if result.not_found:
+                not_found += 1
+                continue
+
+            sync_updates.append((member.id, result.synced))
+
+            if result.errors:
+                errors_total += len(result.errors)
+                for err in result.errors:
+                    details.append(S.CHECK_UI["detail_error"].format(error=err))
+
+            if result.changed:
+                changed_count += 1
+                parts = []
+                if result.nickname_changed:
+                    parts.append(S.CHECK_UI["detail_nickname"])
+                if result.roles_added:
+                    parts.append(S.CHECK_UI["detail_roles_added"].format(roles=", ".join(result.roles_added)))
+                details.append(S.CHECK_UI["detail_changed"].format(name=member.display_name, parts=", ".join(parts)))
+            else:
+                already_ok += 1
+
+            if result.birthday_today and not has_announced_today(member.id):
+                birthday_pings += 1
+                await announce_birthday(member, bot)
+                mark_announced_today(member.id)
+
+        if sync_updates:
+            try:
+                await sheets.batch_set_synced(sync_updates)
+            except Exception as e:
+                log.error("/check batch_set_synced failed: %s", e)
+
+        summary_lines = [
+            S.CHECK_UI["done"],
+            S.CHECK_UI["already_ok"].format(count=already_ok),
+            S.CHECK_UI["fixed"].format(count=changed_count),
+            S.CHECK_UI["not_found"].format(count=not_found),
+            S.CHECK_UI["bday_pings"].format(count=birthday_pings),
+        ]
+        if errors_total:
+            summary_lines.append(S.CHECK_UI["errors"].format(count=errors_total))
+
+        summary = "\n".join(summary_lines)
+
+        if details:
+            detail_text = "\n".join(details[:20])
+            summary += f"\n\n{S.CHECK_UI['details_header']}\n{detail_text}"
+            if len(details) > 20:
+                summary += "\n" + S.CHECK_UI["details_more"].format(count=len(details) - 20)
+
+        stats = _sheet_stats(data)
+        id_note = S.CHECK_UI["ids_filled"].format(count=ids_filled) if ids_filled else ""
+        summary = id_note + "\n" + summary + "\n\n" + stats
+
+        await interaction.followup.send(summary.strip(), ephemeral=True)
+        log.info(
+            "/check - OK=%d, Fixed=%d, NotFound=%d, IDs=%d, Errors=%d",
+            already_ok,
+            changed_count,
+            not_found,
+            ids_filled,
+            errors_total,
+        )
+
+    @tree.command(name="member", description=S.CMD["member"])
+    @app_commands.guild_only()
+    @bot_admin_check()
+    async def cmd_member(interaction: discord.Interaction, user: discord.Member):
+        row = sheets.find_member(user.id, user.name)
+        if row is None:
+            await interaction.response.send_message(
+                S.ERR["member_not_found"].format(name=user.display_name),
+                ephemeral=True,
+            )
+            return
+
+        embed = discord.Embed(title=S.MEMBER_UI["title"].format(name=user.display_name), color=user.color)
+
+        bday_str = str(row.get("Sünnipäev", "")).strip()
+        if bday_str and bday_str.lower() not in ("-", "x", "n/a", "none", "ei"):
+            for fmt in ["%d/%m/%Y", "%Y-%m-%d"]:
+                try:
+                    bday = datetime.datetime.strptime(bday_str, fmt).date()
+                    if 1920 <= bday.year <= today_local().year:
+                        today = today_local()
+                        age = today.year - bday.year - ((today.month, today.day) < (bday.month, bday.day))
+                        embed.add_field(name=S.MEMBER_UI["age_field"], value=S.MEMBER_UI["age_val"].format(age=age), inline=True)
+                    break
+                except ValueError:
+                    continue
+
+        for sheet_key, label in S.MEMBER_FIELDS:
+            val = str(row.get(sheet_key, "")).strip()
+            if val:
+                embed.add_field(name=label, value=val, inline=True)
+
+        await interaction.response.send_message(embed=embed, ephemeral=True)

commands/dev_member_runtime.py

@@ -0,0 +1,93 @@
+from __future__ import annotations
+
+import logging
+from collections.abc import Callable
+
+import discord
+
+import config
+from core import sheets
+from core.member_sync import announce_birthday, is_birthday_today, sync_member
+
+
+async def run_birthday_daily(
+    bot: discord.Client,
+    log: logging.Logger,
+    has_announced_today: Callable[[int], bool],
+    mark_announced_today: Callable[[int], None],
+) -> None:
+    """Announce birthdays in the configured guild for users whose birthday is today."""
+    guild = bot.get_guild(config.GUILD_ID)
+    if guild is None:
+        log.warning("Birthday task: guild %s not found", config.GUILD_ID)
+        return
+
+    try:
+        data = await sheets.refresh()
+    except Exception as e:
+        log.error("Birthday task: sheet refresh failed: %s", e)
+        data = sheets.get_cache()
+
+    announced = 0
+    for row in data:
+        bday_str = str(row.get("Sünnipäev", "")).strip()
+        if not is_birthday_today(bday_str):
+            continue
+
+        member = None
+        raw_id = str(row.get("User ID", "")).strip()
+        if raw_id:
+            try:
+                member = guild.get_member(int(raw_id))
+            except ValueError:
+                pass
+        if member is None:
+            discord_name = str(row.get("Discord", "")).strip()
+            if discord_name:
+                member = discord.utils.find(
+                    lambda m, n=discord_name: m.name.lower() == n.lower(),
+                    guild.members,
+                )
+        if member and not has_announced_today(member.id):
+            await announce_birthday(member, bot)
+            mark_announced_today(member.id)
+            announced += 1
+
+    log.info("Sünnipäeva ülesanne: teavitati %d liiget", announced)
+
+
+async def handle_member_join(
+    member: discord.Member,
+    bot: discord.Client,
+    log: logging.Logger,
+    has_announced_today: Callable[[int], bool],
+    mark_announced_today: Callable[[int], None],
+    log_sync_result: Callable[[discord.Member, object], None],
+) -> None:
+    """Sync a newly joined member against sheet data and trigger birthday notice if needed."""
+    log.info("Member joined: %s (ID: %s)", member, member.id)
+
+    if not sheets.get_cache():
+        await sheets.refresh()
+
+    result = await sync_member(member, member.guild)
+
+    if result.not_found:
+        try:
+            await sheets.add_new_member_row(member.name, member.id)
+            log.info(
+                "  → %s not in sheet, added new row (Discord=%s, ID=%s)",
+                member,
+                member.name,
+                member.id,
+            )
+        except Exception as e:
+            log.error("  → Failed to add sheet row for %s: %s", member, e)
+        return
+
+    log_sync_result(member, result)
+    await sheets.set_synced(member.id, result.synced)
+
+    if result.birthday_today and not has_announced_today(member.id):
+        await announce_birthday(member, bot)
+        mark_announced_today(member.id)

commands/economy_admin_commands.py

@@ -0,0 +1,311 @@
+from __future__ import annotations
+
+import datetime
+import logging
+from collections.abc import Awaitable, Callable
+
+import discord
+from discord import app_commands
+
+from core import economy
+from core.admin import bot_admin_check
+import strings as S
+
+
+async def _dm_user(bot: discord.Client, user_id: int, msg: str) -> None:
+    """Best-effort DM to a user."""
+    try:
+        user = bot.get_user(user_id) or await bot.fetch_user(user_id)
+        await user.send(msg)
+    except Exception:
+        pass
+
+
+def register_economy_admin_commands(
+    tree: app_commands.CommandTree,
+    bot: discord.Client,
+    log: logging.Logger,
+    cd_ts: Callable[[datetime.timedelta], str],
+    apply_level_role: Callable[[discord.Member, int, int], Awaitable[None]],
+) -> None:
+    @tree.command(name="adminseason", description=S.CMD["adminseason"])
+    @app_commands.guild_only()
+    @bot_admin_check()
+    @app_commands.describe(top_n=S.OPT["adminseason_top_n"])
+    async def cmd_adminseason(interaction: discord.Interaction, top_n: int = 10):
+        await interaction.response.defer(ephemeral=True)
+        top = await economy.do_season_reset(top_n)
+        guild = interaction.guild
+
+        if guild:
+            all_role_names = {name for _, name in economy.LEVEL_ROLES}
+            for role_name in all_role_names:
+                role = discord.utils.find(lambda r: r.name == role_name, guild.roles)
+                if not role:
+                    continue
+                for member in list(role.members):
+                    try:
+                        await member.remove_roles(role, reason="Season reset")
+                    except discord.Forbidden:
+                        pass
+
+        medals = ["🥇", "🥈", "🥉"]
+        lines = []
+        for i, (uid, exp, lvl) in enumerate(top):
+            member = guild.get_member(int(uid)) if guild else None
+            name = member.display_name if member else S.LEADERBOARD_UI["unknown_user"].format(uid=uid)
+            prefix = medals[i] if i < 3 else f"**{i + 1}.**"
+            lines.append(S.SEASON["entry"].format(prefix=prefix, name=name, exp=exp, level=lvl))
+
+        embed = discord.Embed(
+            title=S.TITLE["adminseason"],
+            description=(S.SEASON["top_header"] + "\n" + "\n".join(lines)) if lines else S.SEASON["no_players"],
+            color=0xF4C430,
+        )
+        embed.set_footer(text=S.SEASON["footer"])
+        await interaction.followup.send(embed=embed, ephemeral=False)
+        await interaction.followup.send(S.SEASON["done"], ephemeral=True)
+        log.info("/adminseason triggered by %s (top_n=%d)", interaction.user, top_n)
+
+    @tree.command(name="admincoins", description=S.CMD["admincoins"])
+    @app_commands.guild_only()
+    @app_commands.describe(
+        kasutaja=S.OPT["admin_kasutaja"],
+        kogus=S.OPT["admincoins_kogus"],
+        põhjus=S.OPT["admin_põhjus"],
+    )
+    @bot_admin_check()
+    async def cmd_admincoins(interaction: discord.Interaction, kasutaja: discord.Member, kogus: int, põhjus: str):
+        if kogus == 0:
+            await interaction.response.send_message(S.ERR["admincoins_zero"], ephemeral=True)
+            return
+        res = await economy.do_admin_coins(kasutaja.id, kogus, interaction.user.id, põhjus)
+        verb = f"+{kogus}" if kogus > 0 else str(kogus)
+        emoji = "💰" if kogus > 0 else "💸"
+        await interaction.response.send_message(
+            S.ADMIN["coins_done"].format(
+                emoji=emoji,
+                name=kasutaja.display_name,
+                verb=verb,
+                coin=economy.COIN,
+                balance=f"{res['balance']:,}",
+                reason=põhjus,
+            ),
+            ephemeral=True,
+        )
+        await _dm_user(
+            bot,
+            kasutaja.id,
+            S.ADMIN["coins_dm"].format(
+                emoji=emoji,
+                verb=verb,
+                coin=economy.COIN,
+                reason=põhjus,
+                balance=f"{res['balance']:,}",
+            ),
+        )
+        log.info("ADMINCOINS %s → %s (%s) by %s", verb, kasutaja, põhjus, interaction.user)
+
+    @tree.command(name="adminjail", description=S.CMD["adminjail"])
+    @app_commands.guild_only()
+    @app_commands.describe(
+        kasutaja=S.OPT["admin_kasutaja"],
+        minutid=S.OPT["adminjail_minutid"],
+        põhjus=S.OPT["admin_põhjus"],
+    )
+    @bot_admin_check()
+    async def cmd_adminjail(interaction: discord.Interaction, kasutaja: discord.Member, minutid: int, põhjus: str):
+        if minutid <= 0:
+            await interaction.response.send_message(S.ERR["positive_duration"], ephemeral=True)
+            return
+        await economy.do_admin_jail(kasutaja.id, minutid, interaction.user.id, põhjus)
+        until_ts = cd_ts(datetime.timedelta(minutes=minutid))
+        await interaction.response.send_message(
+            S.ADMIN["jail_done"].format(name=kasutaja.display_name, minutes=minutid, ts=until_ts, reason=põhjus),
+            ephemeral=True,
+        )
+        await _dm_user(
+            bot,
+            kasutaja.id,
+            S.ADMIN["jail_dm"].format(minutes=minutid, reason=põhjus, ts=until_ts),
+        )
+        log.info("ADMINJAIL %s %dmin (%s) by %s", kasutaja, minutid, põhjus, interaction.user)
+
+    @tree.command(name="adminunjail", description=S.CMD["adminunjail"])
+    @app_commands.guild_only()
+    @app_commands.describe(kasutaja=S.OPT["admin_kasutaja"])
+    @bot_admin_check()
+    async def cmd_adminunjail(interaction: discord.Interaction, kasutaja: discord.Member):
+        await economy.do_admin_unjail(kasutaja.id, interaction.user.id)
+        await interaction.response.send_message(
+            S.ADMIN["unjail_done"].format(name=kasutaja.display_name), ephemeral=True
+        )
+        await _dm_user(bot, kasutaja.id, S.ADMIN["unjail_dm"])
+        log.info("ADMINUNJAIL %s by %s", kasutaja, interaction.user)
+
+    @tree.command(name="adminban", description=S.CMD["adminban"])
+    @app_commands.guild_only()
+    @app_commands.describe(
+        kasutaja=S.OPT["admin_kasutaja"],
+        põhjus=S.OPT["admin_põhjus"],
+    )
+    @bot_admin_check()
+    async def cmd_adminban(interaction: discord.Interaction, kasutaja: discord.Member, põhjus: str):
+        if bot.user and kasutaja.id == bot.user.id:
+            await interaction.response.send_message(S.ERR["admin_ban_bot"], ephemeral=True)
+            return
+        await economy.do_admin_ban(kasutaja.id, interaction.user.id, põhjus)
+        await interaction.response.send_message(
+            S.ADMIN["ban_done"].format(name=kasutaja.display_name, reason=põhjus),
+            ephemeral=True,
+        )
+        await _dm_user(bot, kasutaja.id, S.ADMIN["ban_dm"].format(reason=põhjus))
+        log.info("ADMINBAN %s (%s) by %s", kasutaja, põhjus, interaction.user)
+
+    @tree.command(name="adminunban", description=S.CMD["adminunban"])
+    @app_commands.guild_only()
+    @app_commands.describe(kasutaja=S.OPT["admin_kasutaja"])
+    @bot_admin_check()
+    async def cmd_adminunban(interaction: discord.Interaction, kasutaja: discord.Member):
+        await economy.do_admin_unban(kasutaja.id, interaction.user.id)
+        await interaction.response.send_message(
+            S.ADMIN["unban_done"].format(name=kasutaja.display_name), ephemeral=True
+        )
+        await _dm_user(bot, kasutaja.id, S.ADMIN["unban_dm"])
+        log.info("ADMINUNBAN %s by %s", kasutaja, interaction.user)
+
+    @tree.command(name="adminreset", description=S.CMD["adminreset"])
+    @app_commands.guild_only()
+    @app_commands.describe(
+        kasutaja=S.OPT["admin_kasutaja"],
+        põhjus=S.OPT["admin_põhjus"],
+    )
+    @bot_admin_check()
+    async def cmd_adminreset(interaction: discord.Interaction, kasutaja: discord.Member, põhjus: str):
+        if bot.user and kasutaja.id == bot.user.id:
+            await interaction.response.send_message(S.ERR["admin_reset_bot"], ephemeral=True)
+            return
+        await economy.do_admin_reset(kasutaja.id, interaction.user.id)
+        await interaction.response.send_message(
+            S.ADMIN["reset_done"].format(name=kasutaja.display_name, reason=põhjus),
+            ephemeral=True,
+        )
+        await _dm_user(bot, kasutaja.id, S.ADMIN["reset_dm"].format(reason=põhjus))
+        log.info("ADMINRESET %s (%s) by %s", kasutaja, põhjus, interaction.user)
+
+    @tree.command(name="adminview", description=S.CMD["adminview"])
+    @app_commands.guild_only()
+    @app_commands.describe(kasutaja=S.OPT["admin_kasutaja"])
+    @bot_admin_check()
+    async def cmd_adminview(interaction: discord.Interaction, kasutaja: discord.Member):
+        res = await economy.do_admin_inspect(kasutaja.id)
+        data = res["data"]
+        items_str = ", ".join(data.get("items", [])) or "-"
+        uses = data.get("item_uses", {})
+        uses_str = ", ".join(f"{k}:{v}" for k, v in uses.items()) if uses else "-"
+        jailed = data.get("jailed_until") or "-"
+        banned = S.ADMINVIEW_UI["banned_yes"] if data.get("eco_banned") else S.ADMINVIEW_UI["banned_no"]
+        exp = data.get("exp", 0)
+        level = economy.get_level(exp)
+        prestige_lvl = data.get("prestige_level", 0)
+        prestige_pp = data.get("prestige_points", 0)
+        total_fish = data.get("total_fish_caught", 0)
+        inv_fish = len(data.get("fish_inventory") or [])
+        embed = discord.Embed(
+            title=S.ADMINVIEW_UI["title"].format(name=kasutaja.display_name),
+            color=0x5865F2,
+        )
+        embed.add_field(name=S.ADMINVIEW_UI["f_balance"], value=f"{data.get('balance', 0):,} {economy.COIN}", inline=True)
+        embed.add_field(name=S.ADMINVIEW_UI["f_exp"], value=S.ADMINVIEW_UI["exp_val"].format(exp=f"{exp:,}", level=level), inline=True)
+        embed.add_field(name=S.ADMINVIEW_UI["f_streak"], value=str(data.get("daily_streak", 0)), inline=True)
+        embed.add_field(name=S.ADMINVIEW_UI["f_banned"], value=banned, inline=True)
+        embed.add_field(name=S.ADMINVIEW_UI["f_jailed"], value=jailed, inline=True)
+        embed.add_field(name=S.ADMINVIEW_UI["f_prestige"], value=S.ADMINVIEW_UI["prestige_val"].format(level=prestige_lvl, pp=prestige_pp), inline=True)
+        embed.add_field(name=S.ADMINVIEW_UI["f_fish"], value=S.ADMINVIEW_UI["fish_val"].format(caught=total_fish, inv=inv_fish), inline=True)
+        embed.add_field(name=S.ADMINVIEW_UI["f_items"], value=items_str, inline=False)
+        embed.add_field(name=S.ADMINVIEW_UI["f_uses"], value=uses_str, inline=False)
+        embed.add_field(name=S.ADMINVIEW_UI["f_last_daily"], value=data.get("last_daily") or "-", inline=True)
+        embed.add_field(name=S.ADMINVIEW_UI["f_last_work"], value=data.get("last_work") or "-", inline=True)
+        embed.add_field(name=S.ADMINVIEW_UI["f_last_crime"], value=data.get("last_crime") or "-", inline=True)
+        embed.add_field(name=S.ADMINVIEW_UI["f_last_fish"], value=data.get("last_fish") or "-", inline=True)
+        embed.set_footer(text=S.ADMINVIEW_UI["footer"].format(uid=kasutaja.id))
+        await interaction.response.send_message(embed=embed, ephemeral=True)
+        log.info("ADMINVIEW %s by %s", kasutaja, interaction.user)
+
+    @tree.command(name="adminexp", description=S.CMD["adminexp"])
+    @app_commands.guild_only()
+    @app_commands.describe(
+        kasutaja=S.OPT["admin_kasutaja"],
+        kogus=S.OPT["adminexp_kogus"],
+        põhjus=S.OPT["admin_põhjus"],
+    )
+    @bot_admin_check()
+    async def cmd_adminexp(interaction: discord.Interaction, kasutaja: discord.Member, kogus: int, põhjus: str):
+        if kogus == 0:
+            await interaction.response.send_message(S.ERR["admincoins_zero"], ephemeral=True)
+            return
+        res = await economy.do_admin_exp(kasutaja.id, kogus, interaction.user.id, põhjus)
+        verb = f"+{kogus}" if kogus > 0 else str(kogus)
+        emoji = "📈" if kogus > 0 else "📉"
+        await interaction.response.send_message(
+            S.ADMIN["exp_done"].format(
+                emoji=emoji,
+                name=kasutaja.display_name,
+                verb=verb,
+                exp=f"{res['exp']:,}",
+                level=res["new_level"],
+                reason=põhjus,
+            ),
+            ephemeral=True,
+        )
+        await _dm_user(
+            bot,
+            kasutaja.id,
+            S.ADMIN["exp_dm"].format(
+                emoji=emoji,
+                verb=verb,
+                reason=põhjus,
+                exp=f"{res['exp']:,}",
+                level=res["new_level"],
+            ),
+        )
+        if res["level_changed"]:
+            member = interaction.guild.get_member(kasutaja.id) if interaction.guild else None
+            if member:
+                await apply_level_role(member, res["new_level"], res["old_level"])
+        log.info("ADMINEXP %s → %s (%s) by %s", verb, kasutaja, põhjus, interaction.user)
+
+    @tree.command(name="adminitem", description=S.CMD["adminitem"])
+    @app_commands.guild_only()
+    @app_commands.describe(
+        kasutaja=S.OPT["admin_kasutaja"],
+        ese=S.OPT["adminitem_ese"],
+        tegevus=S.OPT["adminitem_tegevus"],
+    )
+    @bot_admin_check()
+    async def cmd_adminitem(interaction: discord.Interaction, kasutaja: discord.Member, ese: str, tegevus: str):
+        action = tegevus.strip().lower()
+        if action not in ("anna", "eemalda"):
+            await interaction.response.send_message(S.ADMIN["item_invalid"].format(item_id=tegevus), ephemeral=True)
+            return
+        action_key = "give" if action == "anna" else "remove"
+        res = await economy.do_admin_item(kasutaja.id, ese, action_key, interaction.user.id)
+        if not res["ok"]:
+            if res["reason"] == "invalid_item":
+                await interaction.response.send_message(S.ADMIN["item_invalid"].format(item_id=ese), ephemeral=True)
+            elif res["reason"] == "not_owned":
+                await interaction.response.send_message(
+                    S.ADMIN["item_not_owned"].format(name=kasutaja.display_name, item_id=ese),
+                    ephemeral=True,
+                )
+            else:
+                await interaction.response.send_message(S.ERR["generic_error"].format(error=res["reason"]), ephemeral=True)
+            return
+        item_name = economy.SHOP[ese]["name"]
+        if action_key == "give":
+            await interaction.response.send_message(S.ADMIN["item_given"].format(item=item_name, name=kasutaja.display_name), ephemeral=True)
+            await _dm_user(bot, kasutaja.id, S.ADMIN["item_dm_given"].format(item=item_name))
+        else:
+            await interaction.response.send_message(S.ADMIN["item_removed"].format(item=item_name, name=kasutaja.display_name), ephemeral=True)
+            await _dm_user(bot, kasutaja.id, S.ADMIN["item_dm_removed"].format(item=item_name))
+        log.info("ADMINITEM %s %s %s by %s", action_key, ese, kasutaja, interaction.user)

commands/economy_extra_commands.py

@@ -0,0 +1,898 @@
+from __future__ import annotations
+
+import asyncio
+import datetime
+import random
+import time
+from collections.abc import Awaitable, Callable, MutableSet
+
+import discord
+from discord import app_commands
+
+from core import economy
+from core.emoji import EMOJI as E
+import strings as S
+
+
+def register_economy_extra_commands(
+    tree: app_commands.CommandTree,
+    bot: discord.Client,
+    coin: Callable[[int], str],
+    cd_ts: Callable[[datetime.timedelta], str],
+    parse_amount: Callable[[str, int], tuple[int | None, str | None]],
+    ensure_level_role: Callable[[discord.Member, int], Awaitable[None]],
+    active_games: MutableSet[int],
+) -> None:
+    active_heist = None
+
+    # -----------------------------------------------------------------------
+    # /heist - multiplayer group robbery of the house
+    # -----------------------------------------------------------------------
+    _HEIST_JOIN_WINDOW = 300  # seconds players have to join
+    _HEIST_MIN_PLAYERS = 2
+    _HEIST_GLOBAL_CD = 14400  # seconds between heist events server-wide (4h)
+    _HEIST_MAX_PLAYERS = 8
+    _HEIST_BASE_CHANCE = 0.35  # 35% solo
+    _HEIST_CHANCE_STEP = 0.05  # +5% per extra player
+    _HEIST_MAX_CHANCE = 0.65  # cap at 65%
+
+    def _build_heist_story(participants: list[discord.Member], success: bool) -> list[str]:
+        """Return a list of story lines for the heist narrative reveal."""
+        story = S.HEIST_STORY
+        leader = participants[0].display_name
+        if len(participants) == 1:
+            names = f"**{leader}**"
+        elif len(participants) == 2:
+            names = S.HEIST_UI["names_duo"].format(
+                a=participants[0].display_name,
+                b=participants[1].display_name,
+            )
+        elif len(participants) <= 4:
+            names = S.HEIST_UI["names_sep"].join(f"**{p.display_name}**" for p in participants)
+        else:
+            names = S.HEIST_UI["names_crew"].format(leader=participants[0].display_name)
+
+        vehicle = random.choice(story["vehicles"])
+        approach = random.choice(["sneaky", "loud"])
+        non_leaders = participants[1:] if len(participants) > 1 else participants
+
+        def fill(tmpl: str) -> str:
+            picked = random.choice(non_leaders).display_name
+            return tmpl.format(
+                leader=f"**{leader}**",
+                member=f"**{picked}**",
+                names=names,
+                vehicle=vehicle,
+            )
+
+        getaway_pool = "getaway_success" if success else "getaway_fail"
+
+        return [
+            fill(random.choice(story["arrival"])),
+            fill(random.choice(story[f"entry_{approach}"])),
+            fill(random.choice(story["inside"])),
+            fill(random.choice(story["vault"])),
+            fill(random.choice(story["vault_open"])),
+            fill(random.choice(story["police_inbound"])),
+            fill(random.choice(story[getaway_pool])),
+            fill(random.choice(story["escape_success" if success else "escape_fail"])),
+        ]
+
+    class HeistLobbyView(discord.ui.View):
+        def __init__(self, organizer: discord.Member, organizer_has_jellyfin: bool = False):
+            super().__init__(timeout=_HEIST_JOIN_WINDOW)
+            self.organizer = organizer
+            self.participants: list[discord.Member] = [organizer]
+            self.message: discord.Message | None = None
+            self.resolved = False
+            self.jellyfin_holders: int = 1 if organizer_has_jellyfin else 0
+
+        def _chance(self) -> float:
+            n = len(self.participants)
+            base = min(_HEIST_BASE_CHANCE + _HEIST_CHANCE_STEP * (n - 1), _HEIST_MAX_CHANCE)
+            jelly_bonus = 0.05 if self.jellyfin_holders > 0 else 0.0
+            return min(base + jelly_bonus, _HEIST_MAX_CHANCE)
+
+        def _lobby_embed(self) -> discord.Embed:
+            names = "\n".join(f"• {p.display_name}" for p in self.participants)
+            desc = S.HEIST_UI["lobby_desc"].format(
+                n=len(self.participants),
+                max=_HEIST_MAX_PLAYERS,
+                names=names,
+                chance=int(self._chance() * 100),
+                ts=int(self._timeout_expiry()),
+            )
+            return discord.Embed(title=S.TITLE["heist_lobby"], description=desc, color=0xE67E22)
+
+        def _timeout_expiry(self) -> float:
+            return time.time() + (self.timeout or 0)
+
+        @discord.ui.button(label=S.HEIST_UI["btn_join"], style=discord.ButtonStyle.danger)
+        async def join(self, interaction: discord.Interaction, _: discord.ui.Button):
+            if any(p.id == interaction.user.id for p in self.participants):
+                await interaction.response.send_message(S.HEIST_UI["already_joined"], ephemeral=True)
+                return
+            if len(self.participants) >= _HEIST_MAX_PLAYERS:
+                await interaction.response.send_message(S.ERR["heist_full"], ephemeral=True)
+                return
+            if interaction.user.id in active_games:
+                await interaction.response.send_message(S.ERR["already_in_game"], ephemeral=True)
+                return
+            res = await economy.do_heist_check(interaction.user.id)
+            if not res["ok"]:
+                if res["reason"] == "banned":
+                    await interaction.response.send_message(S.MSG_BANNED, ephemeral=True)
+                elif res["reason"] == "jailed":
+                    await interaction.response.send_message(
+                        S.CD_MSG["jailed"].format(ts=cd_ts(res["remaining"])), ephemeral=True
+                    )
+                else:
+                    await interaction.response.send_message(
+                        S.CD_MSG["heist"].format(ts=cd_ts(res["remaining"])), ephemeral=True
+                    )
+                return
+            self.participants.append(interaction.user)
+            active_games.add(interaction.user.id)
+            joiner_data = await economy.get_user(interaction.user.id)
+            if "jellyfin" in joiner_data.get("items", []):
+                self.jellyfin_holders += 1
+            await interaction.response.edit_message(embed=self._lobby_embed())
+
+        @discord.ui.button(label=S.HEIST_UI["btn_start"], style=discord.ButtonStyle.success)
+        async def start_now(self, interaction: discord.Interaction, _: discord.ui.Button):
+            if interaction.user.id != self.organizer.id:
+                await interaction.response.send_message(S.HEIST_UI["only_organizer"], ephemeral=True)
+                return
+            if len(self.participants) < _HEIST_MIN_PLAYERS:
+                await interaction.response.send_message(
+                    S.ERR["heist_min_players"].format(min=_HEIST_MIN_PLAYERS), ephemeral=True
+                )
+                return
+            await self._resolve(interaction)
+
+        async def _resolve(self, interaction: discord.Interaction | None = None) -> None:
+            nonlocal active_heist
+            if self.resolved:
+                return
+            self.resolved = True
+            active_heist = None
+            self.stop()
+            self.clear_items()
+
+            for p in self.participants:
+                active_games.discard(p.id)
+
+            n = len(self.participants)
+            channel = interaction.channel if interaction else self.message.channel if self.message else None
+
+            if n < _HEIST_MIN_PLAYERS:
+                embed = discord.Embed(
+                    title=S.TITLE["heist_cancel"],
+                    description=S.HEIST_UI["cancel_desc"].format(min=_HEIST_MIN_PLAYERS),
+                    color=0x99AAB5,
+                )
+                if interaction and not interaction.response.is_done():
+                    await interaction.response.edit_message(embed=embed, view=self)
+                elif self.message:
+                    try:
+                        await self.message.edit(embed=embed, view=self)
+                    except discord.HTTPException:
+                        pass
+                return
+
+            success = random.random() < self._chance()
+            story_lines = _build_heist_story(self.participants, success)
+
+            lobby_done = discord.Embed(
+                title=S.HEIST_UI["started_title"],
+                description=S.HEIST_UI["started_desc"].format(n=n),
+                color=0x99AAB5,
+            )
+            if interaction and not interaction.response.is_done():
+                await interaction.response.edit_message(embed=lobby_done, view=self)
+            elif self.message:
+                try:
+                    await self.message.edit(embed=lobby_done, view=self)
+                except discord.HTTPException:
+                    pass
+
+            if channel:
+                story_embed = discord.Embed(title=S.HEIST_UI["story_title"], description="", color=0xE67E22)
+                story_msg = await channel.send(embed=story_embed)
+                accumulated = ""
+                for i, line in enumerate(story_lines):
+                    await asyncio.sleep(random.uniform(3.0, 4.5))
+                    accumulated += ("\n\n" if i > 0 else "") + line
+                    story_embed.description = accumulated
+                    try:
+                        await story_msg.edit(embed=story_embed)
+                    except discord.HTTPException:
+                        pass
+                await asyncio.sleep(2.0)
+
+            res = await economy.do_heist_resolve([p.id for p in self.participants], success)
+            payout_each = res["payout_each"]
+            names_str = "\n".join(f"• {p.display_name}" for p in self.participants)
+            guild = interaction.guild if interaction else self.message.guild if self.message else None
+
+            if success:
+                result_desc = S.HEIST_UI["win_desc"].format(names=names_str, payout=coin(payout_each))
+                result_embed = discord.Embed(
+                    title=S.TITLE["heist_win"],
+                    description=result_desc,
+                    color=0x57F287,
+                )
+                for p in self.participants:
+                    exp_res = await economy.award_exp(p.id, economy.EXP_REWARDS["heist_win"])
+                    if exp_res["old_level"] != exp_res["new_level"] and guild:
+                        gm = guild.get_member(p.id)
+                        if gm:
+                            asyncio.create_task(ensure_level_role(gm, exp_res["new_level"]))
+            else:
+                result_desc = S.HEIST_UI["fail_desc"].format(names=names_str)
+                result_embed = discord.Embed(
+                    title=S.TITLE["heist_fail"],
+                    description=result_desc,
+                    color=0xED4245,
+                )
+
+            await economy.set_heist_global_cd(time.time() + _HEIST_GLOBAL_CD)
+
+            if channel:
+                await channel.send(embed=result_embed)
+            elif self.message:
+                try:
+                    await self.message.channel.send(embed=result_embed)
+                except discord.HTTPException:
+                    pass
+
+        async def on_timeout(self) -> None:
+            await self._resolve()
+
+    @tree.command(name="heist", description=S.CMD["heist"])
+    @app_commands.guild_only()
+    async def cmd_heist(interaction: discord.Interaction):
+        nonlocal active_heist
+        if active_heist is not None:
+            await interaction.response.send_message(S.ERR["heist_active"], ephemeral=True)
+            return
+        heist_cd = await economy.get_heist_global_cd()
+        if time.time() < heist_cd:
+            await interaction.response.send_message(
+                S.CD_MSG["heist_global"].format(
+                    ts=cd_ts(datetime.timedelta(seconds=heist_cd - time.time()))
+                ),
+                ephemeral=True,
+            )
+            return
+        if interaction.user.id in active_games:
+            await interaction.response.send_message(S.ERR["already_in_game"], ephemeral=True)
+            return
+        res = await economy.do_heist_check(interaction.user.id)
+        if not res["ok"]:
+            if res["reason"] == "banned":
+                await interaction.response.send_message(S.MSG_BANNED, ephemeral=True)
+            elif res["reason"] == "jailed":
+                await interaction.response.send_message(
+                    S.CD_MSG["jailed"].format(ts=cd_ts(res["remaining"])), ephemeral=True
+                )
+            return
+
+        organizer_data = await economy.get_user(interaction.user.id)
+        view = HeistLobbyView(interaction.user, "jellyfin" in organizer_data.get("items", []))
+        active_heist = view
+        active_games.add(interaction.user.id)
+        await interaction.response.send_message(embed=view._lobby_embed(), view=view)
+        view.message = await interaction.original_response()
+
+    # -----------------------------------------------------------------------
+    # /jailbreak - Monopoly-style dice escape
+    # -----------------------------------------------------------------------
+    _DICE_EMOJI = [
+        E["TipiYKS"],
+        E["TipiKAKS"],
+        E["TipiKOLM"],
+        E["TipiNELI"],
+        E["TipiVIIS"],
+        E["TipiKUUS"],
+    ]
+
+    class JailbreakView(discord.ui.View):
+        MAX_TRIES = 3
+
+        def __init__(self, user_id: int):
+            super().__init__(timeout=120)
+            self.user_id = user_id
+            self.tries = 0
+            self._rolling = False
+            self._add_roll_btn()
+
+        def _add_roll_btn(self):
+            self.clear_items()
+            btn = discord.ui.Button(
+                label=S.JAILBREAK_UI["btn_roll"].format(try_=self.tries + 1, max=self.MAX_TRIES),
+                style=discord.ButtonStyle.primary,
+            )
+            btn.callback = self._on_roll
+            self.add_item(btn)
+
+        async def _on_roll(self, interaction: discord.Interaction):
+            if interaction.user.id != self.user_id:
+                await interaction.response.send_message(S.ERR["not_your_game"], ephemeral=True)
+                return
+            if self._rolling:
+                await interaction.response.defer()
+                return
+            self._rolling = True
+
+            self.clear_items()
+            rolling_embed = discord.Embed(
+                title=S.TITLE["jailbreak"],
+                description=S.JAILBREAK_UI["rolling_desc"],
+                color=0xF4C430,
+            )
+            await interaction.response.edit_message(embed=rolling_embed, view=self)
+
+            d1 = random.randint(1, 6)
+            d2 = random.randint(1, 6)
+            e1, e2 = _DICE_EMOJI[d1 - 1], _DICE_EMOJI[d2 - 1]
+            double = d1 == d2
+            self.tries += 1
+            tries_left = self.MAX_TRIES - self.tries
+
+            await asyncio.sleep(1.5)
+            self._rolling = False
+
+            if double:
+                await economy.do_jail_free(self.user_id)
+                self.stop()
+                embed = discord.Embed(
+                    title=S.TITLE["jailbreak_free"],
+                    description=S.JAILBREAK_UI["free_desc"].format(d1=e1, d2=e2),
+                    color=0x57F287,
+                )
+                await interaction.edit_original_response(embed=embed, view=self)
+            elif tries_left == 0:
+                self.stop()
+                user_data = await economy.get_user(self.user_id)
+                bal = user_data["balance"]
+                if bal >= economy.MIN_BAIL:
+                    min_fine = max(economy.MIN_BAIL, int(bal * 0.20))
+                    max_fine = max(economy.MIN_BAIL, int(bal * 0.30))
+                    desc = S.JAILBREAK_UI["fail_bail_offer"].format(
+                        d1=e1,
+                        d2=e2,
+                        min=coin(min_fine),
+                        max=coin(max_fine),
+                        bal=coin(bal),
+                    )
+                    embed = discord.Embed(
+                        title=S.TITLE["jailbreak_fail"],
+                        description=desc,
+                        color=0xED4245,
+                    )
+                    await interaction.edit_original_response(embed=embed, view=BailView(self.user_id))
+                else:
+                    embed = discord.Embed(
+                        title=S.TITLE["jailbreak_fail"],
+                        description=S.JAILBREAK_UI["fail_broke_desc"].format(
+                            d1=e1,
+                            d2=e2,
+                            balance=coin(bal),
+                        ),
+                        color=0xED4245,
+                    )
+                    await interaction.edit_original_response(embed=embed, view=None)
+            else:
+                self._add_roll_btn()
+                embed = discord.Embed(
+                    title=S.TITLE["jailbreak_miss"].format(tries=self.tries, max=self.MAX_TRIES),
+                    description=S.JAILBREAK_UI["miss_desc"].format(d1=e1, d2=e2, left=tries_left),
+                    color=0xF4C430,
+                )
+                await interaction.edit_original_response(embed=embed, view=self)
+
+    class BailView(discord.ui.View):
+        def __init__(self, user_id: int):
+            super().__init__(timeout=60)
+            self.user_id = user_id
+            self._paying = False
+
+        @discord.ui.button(label=S.JAILBREAK_UI["bail_btn"], style=discord.ButtonStyle.danger)
+        async def pay_bail(self, interaction: discord.Interaction, _: discord.ui.Button):
+            if interaction.user.id != self.user_id:
+                await interaction.response.send_message(S.ERR["not_your_game"], ephemeral=True)
+                return
+            if self._paying or self.is_finished():
+                await interaction.response.defer()
+                return
+            self._paying = True
+            res = await economy.do_bail(self.user_id)
+            self.clear_items()
+            self.stop()
+            if not res["ok"] and res.get("reason") == "broke":
+                embed = discord.Embed(
+                    title=S.TITLE["jailbreak_bail"],
+                    description=S.JAILBREAK_UI["bail_broke_desc"].format(
+                        min=coin(economy.MIN_BAIL),
+                        balance=coin(res["balance"]),
+                    ),
+                    color=0xED4245,
+                )
+            elif not res["ok"]:
+                # Already released (stale view or double-click) - no charge applied.
+                embed = discord.Embed(
+                    title=S.TITLE["jailbreak_bail"],
+                    description=S.JAILBREAK_UI["bail_already_free"].format(
+                        balance=coin(res["balance"]),
+                    ),
+                    color=0x57F287,
+                )
+            else:
+                embed = discord.Embed(
+                    title=S.TITLE["jailbreak_bail"],
+                    description=S.JAILBREAK_UI["bail_paid_desc"].format(
+                        fine=coin(res["fine"]),
+                        balance=coin(res["balance"]),
+                    ),
+                    color=0x57F287,
+                )
+            await interaction.response.edit_message(embed=embed, view=self)
+
+    @tree.command(name="jailbreak", description=S.CMD["jailbreak"])
+    async def cmd_jailbreak(interaction: discord.Interaction):
+        user_data = await economy.get_user(interaction.user.id)
+        remaining = economy._is_jailed(user_data)
+        if not remaining:
+            await interaction.response.send_message(S.ERR["not_jailed"], ephemeral=True)
+            return
+
+        if user_data.get("jailbreak_used", False):
+            bal = user_data["balance"]
+            min_fine = max(economy.MIN_BAIL, int(bal * 0.20))
+            max_fine = max(economy.MIN_BAIL, int(bal * 0.30))
+            if bal >= economy.MIN_BAIL:
+                desc = S.JAILBREAK_UI["already_bail"].format(
+                    min=coin(min_fine),
+                    max=coin(max_fine),
+                    bal=coin(bal),
+                    ts=cd_ts(remaining),
+                )
+                await interaction.response.send_message(
+                    embed=discord.Embed(
+                        title=S.TITLE["jailbreak_bail"],
+                        description=desc,
+                        color=0xED4245,
+                    ),
+                    view=BailView(interaction.user.id),
+                    ephemeral=True,
+                )
+            else:
+                desc = S.JAILBREAK_UI["already_broke"].format(
+                    min=coin(economy.MIN_BAIL),
+                    bal=coin(bal),
+                    ts=cd_ts(remaining),
+                )
+                await interaction.response.send_message(
+                    embed=discord.Embed(
+                        title=S.TITLE["jailbreak_bail"],
+                        description=desc,
+                        color=0xED4245,
+                    ),
+                    ephemeral=True,
+                )
+            return
+
+        await economy.set_jailbreak_used(interaction.user.id)
+        embed = discord.Embed(
+            title=S.TITLE["jailbreak"],
+            description=S.JAILBREAK_UI["intro_desc"].format(
+                ts=cd_ts(remaining),
+                tries=JailbreakView.MAX_TRIES,
+            ),
+            color=0xF4C430,
+        )
+        await interaction.response.send_message(
+            embed=embed,
+            view=JailbreakView(interaction.user.id),
+            ephemeral=True,
+        )
+
+    @tree.command(name="give", description=S.CMD["give"])
+    @app_commands.describe(kasutaja=S.OPT["give_kasutaja"], summa=S.OPT["give_summa"])
+    async def cmd_give(interaction: discord.Interaction, kasutaja: discord.Member, summa: str):
+        data = await economy.get_user(interaction.user.id)
+        summa_int, err = parse_amount(summa, data["balance"])
+        if err:
+            await interaction.response.send_message(err, ephemeral=True)
+            return
+        if summa_int is None or summa_int <= 0:
+            await interaction.response.send_message(S.ERR["positive_amount"], ephemeral=True)
+            return
+        if kasutaja.id == interaction.user.id:
+            await interaction.response.send_message(S.ERR["give_self"], ephemeral=True)
+            return
+        if kasutaja.bot:
+            await interaction.response.send_message(S.ERR["give_bot"], ephemeral=True)
+            return
+
+        res = await economy.do_give(interaction.user.id, kasutaja.id, summa_int)
+        if not res["ok"]:
+            if res["reason"] == "banned":
+                await interaction.response.send_message(S.MSG_BANNED, ephemeral=True)
+            elif res["reason"] == "jailed":
+                await interaction.response.send_message(
+                    S.ERR["give_jailed"].format(ts=cd_ts(res["remaining"])),
+                    ephemeral=True,
+                )
+            else:
+                await interaction.response.send_message(
+                    S.ERR["broke"].format(bal=coin(data["balance"])),
+                    ephemeral=True,
+                )
+            return
+
+        embed = discord.Embed(
+            title=f"{economy.COIN} {S.TITLE['give']}",
+            description=S.GIVE_UI["desc"].format(
+                giver=interaction.user.display_name,
+                amount=coin(summa_int),
+                receiver=kasutaja.display_name,
+            ),
+            color=0xF4C430,
+        )
+        await interaction.response.send_message(embed=embed)
+
+    class LeaderboardView(discord.ui.View):
+        PER_PAGE = 10
+
+        def __init__(self, data: dict, guild: discord.Guild | None, bot_user: discord.ClientUser | None):
+            super().__init__(timeout=120)
+            self.data = data
+            self.guild = guild
+            self.bot_user = bot_user
+            self.page = 0
+            self.mode = "coins"
+            self.max_page = 0
+            self._update_buttons()
+
+        def _current_list(self) -> list:
+            return self.data.get(self.mode, [])
+
+        def _update_buttons(self):
+            current = self._current_list()
+            self.max_page = max(0, (len(current) - 1) // self.PER_PAGE) if current else 0
+            self.prev_btn.disabled = self.page == 0
+            self.next_btn.disabled = self.page >= self.max_page
+            for m, btn in [
+                ("coins", self.coins_btn),
+                ("exp", self.exp_btn),
+                ("season", self.season_btn),
+                ("prestige", self.prestige_btn),
+                ("wagered", self.wagered_btn),
+                ("fish", self.fish_btn),
+            ]:
+                btn.style = discord.ButtonStyle.primary if m == self.mode else discord.ButtonStyle.secondary
+
+        def _name(self, uid: str, highlight_uid: int | None = None) -> str:
+            if self.guild:
+                member = self.guild.get_member(int(uid))
+                name = member.display_name if member else S.LEADERBOARD_UI["unknown_user"].format(uid=uid)
+            else:
+                name = S.LEADERBOARD_UI["unknown_user"].format(uid=uid)
+            if highlight_uid and int(uid) == highlight_uid:
+                name = f"**› {name} ‹**"
+            return name
+
+        def _make_embed(self, highlight_uid: int | None = None) -> discord.Embed:
+            title_map = {
+                "coins": f"{economy.COIN} {S.TITLE['leaderboard_coins']}",
+                "exp": S.TITLE["leaderboard_exp"],
+                "season": S.TITLE["leaderboard_season"],
+                "prestige": S.TITLE["leaderboard_prestige"],
+                "wagered": S.TITLE["leaderboard_wagered"],
+                "fish": S.TITLE["leaderboard_fish"],
+            }
+            color_map = {"coins": 0xF4C430, "wagered": 0xED4245, "fish": 0x57F287}
+            embed = discord.Embed(
+                title=title_map.get(self.mode, "Edetabel"),
+                color=color_map.get(self.mode, 0x5865F2),
+            )
+            lines = []
+
+            if self.mode == "coins" and self.page == 0 and self.data.get("house_entry"):
+                _, bal = self.data["house_entry"]
+                house_name = self.bot_user.display_name if self.bot_user else S.LEADERBOARD_UI["house_default_name"]
+                lines.append(S.LEADERBOARD_UI["house_entry"].format(name=house_name, balance=coin(bal)))
+                lines.append("")
+
+            start = self.page * self.PER_PAGE
+            medals = ["🥇", "🥈", "🥉"]
+            current = self._current_list()
+            slice_ = current[start : start + self.PER_PAGE]
+
+            if not slice_:
+                lines.append(S.LEADERBOARD_UI["no_entries"])
+            else:
+                for i, entry in enumerate(slice_):
+                    rank = start + i
+                    uid = entry[0]
+                    prefix = medals[rank] if rank < 3 else f"**{rank + 1}.**"
+                    name = self._name(uid, highlight_uid)
+                    if self.mode == "coins":
+                        lines.append(f"{prefix} {name} - {coin(entry[1])}")
+                    elif self.mode == "exp":
+                        lines.append(
+                            S.LEADERBOARD_UI["exp_entry"].format(
+                                prefix=prefix,
+                                name=name,
+                                exp=entry[1],
+                                level=entry[2],
+                            )
+                        )
+                    elif self.mode == "season":
+                        lines.append(
+                            S.LEADERBOARD_UI["season_entry"].format(
+                                prefix=prefix,
+                                name=name,
+                                exp=entry[1],
+                                prestige=entry[2],
+                            )
+                        )
+                    elif self.mode == "prestige":
+                        lines.append(
+                            S.LEADERBOARD_UI["prestige_entry"].format(
+                                prefix=prefix,
+                                name=name,
+                                prestige=entry[1],
+                                pp=entry[2],
+                            )
+                        )
+                    elif self.mode == "wagered":
+                        lines.append(
+                            S.LEADERBOARD_UI["wagered_entry"].format(
+                                prefix=prefix,
+                                name=name,
+                                wagered=coin(entry[1]),
+                            )
+                        )
+                    elif self.mode == "fish":
+                        lines.append(
+                            S.LEADERBOARD_UI["fish_entry"].format(
+                                prefix=prefix,
+                                name=name,
+                                caught=entry[1],
+                            )
+                        )
+
+            total = self.max_page + 1
+            embed.description = "\n".join(lines)
+            embed.set_footer(
+                text=S.LEADERBOARD_UI["footer"].format(
+                    page=self.page + 1,
+                    total=total,
+                    count=len(current),
+                )
+            )
+            return embed
+
+        @discord.ui.button(label="◄", style=discord.ButtonStyle.secondary, row=0)
+        async def prev_btn(self, interaction: discord.Interaction, button: discord.ui.Button):
+            self.page -= 1
+            self._update_buttons()
+            await interaction.response.edit_message(embed=self._make_embed(), view=self)
+
+        @discord.ui.button(label="►", style=discord.ButtonStyle.secondary, row=0)
+        async def next_btn(self, interaction: discord.Interaction, button: discord.ui.Button):
+            self.page += 1
+            self._update_buttons()
+            await interaction.response.edit_message(embed=self._make_embed(), view=self)
+
+        @discord.ui.button(label=S.LEADERBOARD_UI["btn_find_me"], style=discord.ButtonStyle.secondary, row=0)
+        async def find_me_btn(self, interaction: discord.Interaction, button: discord.ui.Button):
+            uid = interaction.user.id
+            for i, entry in enumerate(self._current_list()):
+                if int(entry[0]) == uid:
+                    self.page = i // self.PER_PAGE
+                    self._update_buttons()
+                    await interaction.response.edit_message(
+                        embed=self._make_embed(highlight_uid=uid),
+                        view=self,
+                    )
+                    return
+            await interaction.response.send_message(S.ERR["not_in_leaderboard"], ephemeral=True)
+
+        @discord.ui.button(label=S.LEADERBOARD_UI["btn_coins"], style=discord.ButtonStyle.primary, row=1)
+        async def coins_btn(self, interaction: discord.Interaction, button: discord.ui.Button):
+            self.mode = "coins"
+            self.page = 0
+            self._update_buttons()
+            await interaction.response.edit_message(embed=self._make_embed(), view=self)
+
+        @discord.ui.button(label=S.LEADERBOARD_UI["btn_exp"], style=discord.ButtonStyle.secondary, row=1)
+        async def exp_btn(self, interaction: discord.Interaction, button: discord.ui.Button):
+            self.mode = "exp"
+            self.page = 0
+            self._update_buttons()
+            await interaction.response.edit_message(embed=self._make_embed(), view=self)
+
+        @discord.ui.button(label=S.LEADERBOARD_UI["btn_season"], style=discord.ButtonStyle.secondary, row=1)
+        async def season_btn(self, interaction: discord.Interaction, button: discord.ui.Button):
+            self.mode = "season"
+            self.page = 0
+            self._update_buttons()
+            await interaction.response.edit_message(embed=self._make_embed(), view=self)
+
+        @discord.ui.button(label=S.LEADERBOARD_UI["btn_prestige"], style=discord.ButtonStyle.secondary, row=1)
+        async def prestige_btn(self, interaction: discord.Interaction, button: discord.ui.Button):
+            self.mode = "prestige"
+            self.page = 0
+            self._update_buttons()
+            await interaction.response.edit_message(embed=self._make_embed(), view=self)
+
+        @discord.ui.button(label=S.LEADERBOARD_UI["btn_wagered"], style=discord.ButtonStyle.secondary, row=1)
+        async def wagered_btn(self, interaction: discord.Interaction, button: discord.ui.Button):
+            self.mode = "wagered"
+            self.page = 0
+            self._update_buttons()
+            await interaction.response.edit_message(embed=self._make_embed(), view=self)
+
+        @discord.ui.button(label=S.LEADERBOARD_UI["btn_fish"], style=discord.ButtonStyle.secondary, row=2)
+        async def fish_btn(self, interaction: discord.Interaction, button: discord.ui.Button):
+            self.mode = "fish"
+            self.page = 0
+            self._update_buttons()
+            await interaction.response.edit_message(embed=self._make_embed(), view=self)
+
+        async def on_timeout(self):
+            for child in self.children:
+                child.disabled = True
+
+    @tree.command(name="leaderboard", description=S.CMD["leaderboard"])
+    async def cmd_leaderboard(interaction: discord.Interaction):
+        await interaction.response.defer()
+        coins_raw, exp_raw, season_raw, prestige_raw, wagered_raw, fish_raw = await asyncio.gather(
+            economy.get_leaderboard(top_n=None),
+            economy.get_leaderboard_exp(top_n=None),
+            economy.get_leaderboard_season_exp(top_n=None),
+            economy.get_leaderboard_prestige(top_n=None),
+            economy.get_leaderboard_wagered(top_n=None),
+            economy.get_leaderboard_fish(top_n=None),
+        )
+
+        house_entry = None
+        regular = []
+        bot_id = bot.user.id if bot.user else None
+        for uid, bal in coins_raw:
+            if bot_id and int(uid) == bot_id:
+                house_entry = (uid, bal)
+            else:
+                regular.append((uid, bal))
+
+        def _no_bot(entries: list) -> list:
+            return [e for e in entries if not (bot_id and int(e[0]) == bot_id)]
+
+        data = {
+            "coins": regular,
+            "exp": _no_bot(exp_raw),
+            "season": _no_bot(season_raw),
+            "prestige": _no_bot(prestige_raw),
+            "wagered": _no_bot(wagered_raw),
+            "fish": _no_bot(fish_raw),
+            "house_entry": house_entry,
+        }
+        view = LeaderboardView(data, interaction.guild, bot.user)
+        await interaction.followup.send(embed=view._make_embed(), view=view)
+
+    def _shop_embed(tier: int, user_data: dict) -> discord.Embed:
+        owned = set(user_data.get("items", []))
+        item_uses = user_data.get("item_uses", {})
+        tier_names = {1: S.SHOP_UI["tier_1"], 2: S.SHOP_UI["tier_2"], 3: S.SHOP_UI["tier_3"]}
+        embed = discord.Embed(
+            title=f"{economy.COIN} TipiBOTi pood · {tier_names[tier]}",
+            description=S.SHOP_UI["desc"].format(bal=coin(user_data["balance"])),
+            color=[0x57F287, 0xF4C430, 0xED4245][tier - 1],
+        )
+        for item_id in sorted(economy.SHOP_TIERS[tier], key=lambda k: economy.SHOP[k]["cost"]):
+            item = economy.SHOP[item_id]
+            anticheat_uses = item_uses.get("anticheat", 0) if item_id == "anticheat" else 0
+            min_lvl = economy.SHOP_LEVEL_REQ.get(item_id, 0)
+            user_lvl = economy.get_level(user_data.get("exp", 0))
+            if item_id in owned and not (item_id == "anticheat" and anticheat_uses <= 0):
+                if item_id == "anticheat":
+                    key = "owned_uses_1" if anticheat_uses == 1 else "owned_uses_n"
+                    status = S.SHOP_UI[key].format(uses=anticheat_uses)
+                else:
+                    status = S.SHOP_UI["owned"]
+            elif min_lvl > 0 and user_lvl < min_lvl:
+                status = S.SHOP_UI["locked"].format(min_lvl=min_lvl, user_lvl=user_lvl)
+            else:
+                status = f"{item['cost']} {economy.COIN}"
+            embed.add_field(
+                name=f"{item['emoji']} {item['name']}  ·  {status}",
+                value=item["description"],
+                inline=False,
+            )
+        return embed
+
+    class ShopView(discord.ui.View):
+        def __init__(self, user_data: dict, tier: int = 1):
+            super().__init__(timeout=120)
+            self._user_data = user_data
+            self._tier = tier
+            self._update_buttons()
+
+        def _update_buttons(self):
+            self.clear_items()
+            for t, label in [(1, S.SHOP_BTN[1]), (2, S.SHOP_BTN[2]), (3, S.SHOP_BTN[3])]:
+                btn = discord.ui.Button(
+                    label=label,
+                    style=discord.ButtonStyle.primary if t == self._tier else discord.ButtonStyle.secondary,
+                )
+                btn.callback = self._make_callback(t)
+                self.add_item(btn)
+
+        def _make_callback(self, tier: int):
+            async def callback(interaction: discord.Interaction):
+                self._tier = tier
+                self._update_buttons()
+                await interaction.response.defer()
+                self._user_data = await economy.get_user(interaction.user.id)
+                await interaction.edit_original_response(
+                    embed=_shop_embed(self._tier, self._user_data),
+                    view=self,
+                )
+
+            return callback
+
+    @tree.command(name="shop", description=S.CMD["shop"])
+    async def cmd_shop(interaction: discord.Interaction):
+        data = await economy.get_user(interaction.user.id)
+        await interaction.response.send_message(
+            embed=_shop_embed(1, data),
+            view=ShopView(data, tier=1),
+            ephemeral=True,
+        )
+
+    @tree.command(name="buy", description=S.CMD["buy"])
+    @app_commands.describe(ese=S.OPT["buy_ese"])
+    @app_commands.choices(
+        ese=[
+            app_commands.Choice(name=f"{v['name']} ({v['cost']} TipiCOINi)", value=k)
+            for k, v in economy.SHOP.items()
+        ]
+    )
+    async def cmd_buy(interaction: discord.Interaction, ese: app_commands.Choice[str]):
+        res = await economy.do_buy(interaction.user.id, ese.value)
+        if not res["ok"]:
+            if res["reason"] == "banned":
+                await interaction.response.send_message(S.MSG_BANNED, ephemeral=True)
+            elif res["reason"] == "owned":
+                await interaction.response.send_message(S.ERR["item_owned"], ephemeral=True)
+            elif res["reason"] == "level_required":
+                await interaction.response.send_message(
+                    S.ERR["item_level_req"].format(
+                        min_level=res["min_level"],
+                        user_level=res["user_level"],
+                    ),
+                    ephemeral=True,
+                )
+            elif res["reason"] == "insufficient":
+                await interaction.response.send_message(
+                    S.ERR["broke_need"].format(need=coin(res["need"])),
+                    ephemeral=True,
+                )
+            else:
+                await interaction.response.send_message(S.ERR["item_not_found"], ephemeral=True)
+            return
+
+        item = res["item"]
+        embed = discord.Embed(
+            title=S.BUY_UI["title"].format(emoji=item["emoji"], name=item["name"]),
+            description=S.BUY_UI["desc"].format(
+                description=item["description"],
+                balance=coin(res["balance"]),
+            ),
+            color=0x57F287,
+        )
+        await interaction.response.send_message(embed=embed)

commands/economy_fish_commands.py

@@ -0,0 +1,380 @@
+from __future__ import annotations
+
+import asyncio
+import random
+from collections.abc import Awaitable, Callable, MutableSet
+
+import discord
+from discord import app_commands
+
+from core import economy
+import strings as S
+
+
+def register_economy_fish_commands(
+    tree: app_commands.CommandTree,
+    coin: Callable[[int], str],
+    cd_ts: Callable,
+    check_cmd_rate: Callable[[discord.Interaction], Awaitable[bool]],
+    maybe_remind: Callable[[int, str], Awaitable[None]],
+    award_exp: Callable[[discord.Interaction, int], Awaitable[None]],
+    active_games: MutableSet[int],
+) -> None:
+    class FishCatchView(discord.ui.View):
+        """Shown after a successful pull - lets user sell or keep the fish."""
+
+        def __init__(self, user_id: int, res: dict, fish_id: str, weight: int):
+            super().__init__(timeout=60)
+            self.user_id = user_id
+            self._res = res
+            self._fish_id = fish_id
+            self._weight = weight
+            self._done = False
+
+        def _catch_embed(self, color: int = 0x57F287) -> discord.Embed:
+            rarity = economy.FISH_CATALOGUE[self._fish_id]["rarity"]
+            emoji = S.FISH_RARITY_EMOJI[rarity]
+            fish_name = S.FISH_NAMES[self._fish_id]
+            desc = S.FISH_UI["catch_desc"].format(
+                name=fish_name,
+                weight=self._weight,
+                exp=self._res["exp"],
+                value=coin(self._res["value"]),
+            )
+            if self._res.get("is_new"):
+                desc += S.FISH_UI["new_fish"]
+            return discord.Embed(title=f"{emoji} {fish_name}!", description=desc, color=color)
+
+        @discord.ui.button(label="", style=discord.ButtonStyle.success)
+        async def sell_btn(self, interaction: discord.Interaction, button: discord.ui.Button):
+            if interaction.user.id != self.user_id:
+                await interaction.response.send_message(S.ERR["not_your_game"], ephemeral=True)
+                return
+            if self._done:
+                await interaction.response.defer()
+                return
+            self._done = True
+            self.stop()
+            for child in self.children:
+                child.disabled = True
+            sell_res = await economy.do_fish_sell(self.user_id, [-1])
+            rarity = economy.FISH_CATALOGUE[self._fish_id]["rarity"]
+            emoji = S.FISH_RARITY_EMOJI[rarity]
+            fish_name = S.FISH_NAMES[self._fish_id]
+            desc = S.FISH_UI["catch_sold"].format(
+                name=fish_name,
+                weight=self._weight,
+                coins=coin(sell_res["coins"]),
+                exp=self._res["exp"],
+                balance=coin(sell_res["balance"]),
+            )
+            if self._res.get("is_new"):
+                desc += S.FISH_UI["new_fish"]
+            embed = discord.Embed(title=f"{emoji} {fish_name}!", description=desc, color=0x57F287)
+            await interaction.response.edit_message(embed=embed, view=self)
+
+        @discord.ui.button(label="", style=discord.ButtonStyle.secondary)
+        async def keep_btn(self, interaction: discord.Interaction, button: discord.ui.Button):
+            if interaction.user.id != self.user_id:
+                await interaction.response.send_message(S.ERR["not_your_game"], ephemeral=True)
+                return
+            if self._done:
+                await interaction.response.defer()
+                return
+            self._done = True
+            self.stop()
+            for child in self.children:
+                child.disabled = True
+            rarity = economy.FISH_CATALOGUE[self._fish_id]["rarity"]
+            emoji = S.FISH_RARITY_EMOJI[rarity]
+            fish_name = S.FISH_NAMES[self._fish_id]
+            desc = S.FISH_UI["catch_kept"].format(
+                name=fish_name,
+                weight=self._weight,
+                exp=self._res["exp"],
+            )
+            if self._res.get("is_new"):
+                desc += S.FISH_UI["new_fish"]
+            embed = discord.Embed(title=f"{emoji} {fish_name}!", description=desc, color=0x5865F2)
+            await interaction.response.edit_message(embed=embed, view=self)
+
+        async def on_timeout(self):
+            for child in self.children:
+                child.disabled = True
+
+    class FishingView(discord.ui.View):
+        BITE_WINDOW = 2.0
+
+        def __init__(self, user_id: int, fish_id: str, weight: int):
+            super().__init__(timeout=40)
+            self.user_id = user_id
+            self._fish_id = fish_id
+            self._weight = weight
+            self._clicked = False
+            self._bite_active = False
+            self._msg: discord.Message | None = None
+
+            self.pull_btn = discord.ui.Button(
+                label=S.FISH_UI["btn_wait"],
+                style=discord.ButtonStyle.secondary,
+                disabled=True,
+            )
+            self.pull_btn.callback = self._pull
+            self.add_item(self.pull_btn)
+
+        async def start(self, msg: discord.Message) -> None:
+            self._msg = msg
+            wait = random.uniform(5, 15)
+            await asyncio.sleep(wait)
+            if self._clicked or self.is_finished():
+                return
+            self._bite_active = True
+            self.pull_btn.disabled = False
+            self.pull_btn.label = S.FISH_UI["btn_bite"]
+            self.pull_btn.style = discord.ButtonStyle.success
+            try:
+                await msg.edit(
+                    embed=discord.Embed(
+                        title=S.TITLE["fish_bite"],
+                        description=S.FISH_UI["bite_desc"],
+                        color=0xED4245,
+                    ),
+                    view=self,
+                )
+            except Exception:
+                pass
+            await asyncio.sleep(self.BITE_WINDOW)
+            if not self._clicked:
+                self.stop()
+                active_games.discard(self.user_id)
+                self.pull_btn.disabled = True
+                try:
+                    await msg.edit(
+                        embed=discord.Embed(
+                            title=S.TITLE["fish_escape"],
+                            description=S.FISH_UI["escape_desc"],
+                            color=0x99AAB5,
+                        ),
+                        view=self,
+                    )
+                except Exception:
+                    pass
+
+        async def _pull(self, interaction: discord.Interaction) -> None:
+            if interaction.user.id != self.user_id:
+                await interaction.response.send_message(S.ERR["not_your_game"], ephemeral=True)
+                return
+            if not self._bite_active:
+                await interaction.response.send_message(S.FISH_UI["too_early"], ephemeral=True)
+                return
+            self._clicked = True
+            self.stop()
+            active_games.discard(self.user_id)
+            self.pull_btn.disabled = True
+            await interaction.response.defer()
+
+            if self._fish_id == "junk":
+                junk_text = random.choice(S.FISH_JUNK_LINES)
+                user_data = await economy.get_user(interaction.user.id)
+                embed = discord.Embed(
+                    title=S.TITLE["fish_junk"],
+                    description=S.FISH_UI["junk_desc"].format(
+                        text=junk_text,
+                        balance=coin(user_data.get("balance", 0)),
+                    ),
+                    color=0x99AAB5,
+                )
+                await self._msg.edit(embed=embed, view=self)
+                return
+
+            res = await economy.do_fish_resolve(self.user_id, self._fish_id, self._weight)
+            if not res["ok"]:
+                await self._msg.edit(
+                    embed=discord.Embed(title=S.ERR["generic_error"], color=0xED4245),
+                    view=self,
+                )
+                return
+
+            catch_view = FishCatchView(self.user_id, res, self._fish_id, self._weight)
+            catch_view.sell_btn.label = S.FISH_UI["btn_sell"]
+            catch_view.keep_btn.label = S.FISH_UI["btn_keep"]
+            await self._msg.edit(embed=catch_view._catch_embed(), view=catch_view)
+            if res.get("exp", 0) > 0:
+                asyncio.create_task(award_exp(interaction, res["exp"]))
+
+        async def on_timeout(self):
+            for child in self.children:
+                child.disabled = True
+            active_games.discard(self.user_id)
+
+    @tree.command(name="fish", description=S.CMD["fish"])
+    @app_commands.guild_only()
+    async def cmd_fish(interaction: discord.Interaction):
+        if await check_cmd_rate(interaction):
+            return
+        if interaction.user.id in active_games:
+            await interaction.response.send_message(S.ERR["game_in_progress"], ephemeral=True)
+            return
+
+        res = await economy.do_fish_start(interaction.user.id)
+        if not res["ok"]:
+            if res["reason"] == "banned":
+                await interaction.response.send_message(S.MSG_BANNED, ephemeral=True)
+            elif res["reason"] == "cooldown":
+                await interaction.response.send_message(
+                    S.CD_MSG["fish"].format(ts=cd_ts(res["remaining"])),
+                    ephemeral=True,
+                )
+            elif res["reason"] == "jailed":
+                await interaction.response.send_message(
+                    S.CD_MSG["jailed"].format(ts=cd_ts(res["remaining"])),
+                    ephemeral=True,
+                )
+            return
+
+        user_data = await economy.get_user(interaction.user.id)
+        rarity_bump = "kalavork" in user_data.get("items", [])
+        has_echolood = "echolood" in user_data.get("items", [])
+        fish_id, weight = economy.roll_fish(rarity_bump=rarity_bump)
+
+        active_games.add(interaction.user.id)
+        view = FishingView(interaction.user.id, fish_id, weight)
+        if has_echolood:
+            view.BITE_WINDOW = 3.0
+        embed = discord.Embed(
+            title=S.TITLE["fish_cast"],
+            description=S.FISH_UI["cast_desc"],
+            color=0x5865F2,
+        )
+        await interaction.response.send_message(embed=embed, view=view)
+        msg = await interaction.original_response()
+        asyncio.create_task(view.start(msg))
+        asyncio.create_task(maybe_remind(interaction.user.id, "fish"))
+
+    @tree.command(name="fishbook", description=S.CMD["fishbook"])
+    @app_commands.describe(kasutaja=S.OPT["fishbook_kasutaja"])
+    async def cmd_fishbook(interaction: discord.Interaction, kasutaja: discord.Member | None = None):
+        target = kasutaja or interaction.user
+        res = await economy.do_fishbook(target.id)
+        book: dict = res["book"]
+        total = res["total_species"]
+        caught_count = res["unique_caught"]
+
+        if not book:
+            embed = discord.Embed(
+                title=S.TITLE["fishbook"],
+                description=S.FISH_UI["book_empty"],
+                color=0x5865F2,
+            )
+            await interaction.response.send_message(embed=embed, ephemeral=True)
+            return
+
+        inv_counts: dict = res.get("inv_counts", {})
+        all_fish = list(economy.FISH_CATALOGUE.items())
+        lines = [S.FISH_UI["book_caught"].format(caught=caught_count, total=total)]
+        for fish_id, fish_data in all_fish:
+            rarity = fish_data["rarity"]
+            emoji = S.FISH_RARITY_EMOJI[rarity]
+            rarity_name = S.FISH_RARITY_NAMES[rarity]
+            count = book.get(fish_id, 0)
+            if count > 0:
+                n_inv = inv_counts.get(fish_id, 0)
+                inv_str = S.FISH_UI["book_inv"].format(n=n_inv) if n_inv > 0 else ""
+                lines.append(
+                    S.FISH_UI["book_yes"].format(
+                        emoji=emoji,
+                        name=S.FISH_NAMES[fish_id],
+                        rarity=rarity_name,
+                        count=count,
+                        inv=inv_str,
+                    )
+                )
+            else:
+                lines.append(S.FISH_UI["book_no"].format(rarity=rarity_name))
+
+        embed = discord.Embed(
+            title=S.TITLE["fishbook"].replace("Kalakogu", f"{target.display_name} kalakogu"),
+            description="\n".join(lines),
+            color=0x5865F2,
+        )
+        embed.set_footer(
+            text=S.FISH_UI["book_footer"].format(
+                page=1,
+                total_pages=1,
+                caught=caught_count,
+                total=total,
+            )
+        )
+        await interaction.response.send_message(embed=embed, ephemeral=True)
+
+    @tree.command(name="fishsell", description=S.CMD["fishsell"])
+    @app_commands.guild_only()
+    async def cmd_fishsell(interaction: discord.Interaction):
+        await interaction.response.defer(ephemeral=True)
+        user_data = await economy.get_user(interaction.user.id)
+        inv: list = user_data.get("fish_inventory") or []
+        if not inv:
+            embed = discord.Embed(
+                title=S.TITLE["fishbook"],
+                description=S.FISH_UI["inv_empty"],
+                color=0x5865F2,
+            )
+            await interaction.followup.send(embed=embed, ephemeral=True)
+            return
+
+        total_value = sum(e["value"] for e in inv)
+        lines = [S.FISH_UI["inv_header"].format(count=len(inv), total_value=coin(total_value))]
+        for entry in inv:
+            fid = entry.get("fish_id", "")
+            rarity = economy.FISH_CATALOGUE.get(fid, {}).get("rarity", "common")
+            emoji = S.FISH_RARITY_EMOJI.get(rarity, "🐟")
+            name = S.FISH_NAMES.get(fid, fid)
+            lines.append(
+                S.FISH_UI["inv_entry"].format(
+                    emoji=emoji,
+                    name=name,
+                    weight=entry["weight"],
+                    value=coin(entry["value"]),
+                )
+            )
+
+        embed = discord.Embed(
+            title=S.TITLE["fishbook"],
+            description="\n".join(lines),
+            color=0x5865F2,
+        )
+
+        sell_all_btn = discord.ui.Button(
+            label=S.FISH_UI["btn_sell"] + f" ({coin(total_value)})",
+            style=discord.ButtonStyle.success,
+        )
+
+        async def _sell_all(btn_interaction: discord.Interaction):
+            if btn_interaction.user.id != interaction.user.id:
+                await btn_interaction.response.send_message(S.ERR["not_your_menu"], ephemeral=True)
+                return
+            sell_view.stop()
+            for child in sell_view.children:
+                child.disabled = True
+            res = await economy.do_fish_sell(interaction.user.id)
+            if not res["ok"]:
+                await btn_interaction.response.edit_message(
+                    embed=discord.Embed(description=S.FISH_UI["inv_none"], color=0x99AAB5),
+                    view=sell_view,
+                )
+                return
+            sold_embed = discord.Embed(
+                title=S.TITLE["fishbook"],
+                description=S.FISH_UI["inv_sold_all"].format(
+                    count=res["count"],
+                    coins=coin(res["coins"]),
+                    balance=coin(res["balance"]),
+                ),
+                color=0x57F287,
+            )
+            await btn_interaction.response.edit_message(embed=sold_embed, view=sell_view)
+
+        sell_all_btn.callback = _sell_all
+        sell_view = discord.ui.View(timeout=60)
+        sell_view.add_item(sell_all_btn)
+        await interaction.followup.send(embed=embed, view=sell_view, ephemeral=True)

commands/economy_income_commands.py

@@ -0,0 +1,262 @@
+from __future__ import annotations
+
+import asyncio
+import datetime
+from collections.abc import Awaitable, Callable
+
+import discord
+from discord import app_commands
+
+from core import economy
+import strings as S
+
+
+def register_economy_income_commands(
+    tree: app_commands.CommandTree,
+    bot: discord.Client,
+    coin: Callable[[int], str],
+    cd_ts: Callable[[datetime.timedelta], str],
+    check_cmd_rate: Callable[[discord.Interaction], Awaitable[bool]],
+    maybe_remind: Callable[[int, str], Awaitable[None]],
+    award_exp: Callable[[discord.Interaction, int], Awaitable[None]],
+) -> None:
+    @tree.command(name="daily", description=S.CMD["daily"])
+    async def cmd_daily(interaction: discord.Interaction):
+        await interaction.response.defer()
+        res = await economy.do_daily(interaction.user.id)
+        if not res["ok"]:
+            if res["reason"] == "banned":
+                await interaction.followup.send(S.MSG_BANNED, ephemeral=True)
+            elif res["reason"] == "cooldown":
+                await interaction.followup.send(
+                    S.CD_MSG["daily"].format(ts=cd_ts(res["remaining"])),
+                    ephemeral=True,
+                )
+            return
+
+        streak = res["streak"]
+        streak_str = f"🔥 {streak}p" + (
+            " (+200%)"
+            if res["streak_mult"] >= 3.0
+            else " (+100%)"
+            if res["streak_mult"] >= 2.0
+            else " (+50%)"
+            if res["streak_mult"] >= 1.5
+            else ""
+        )
+        lines = [S.DAILY_UI["earned"].format(earned=coin(res["earned"]))]
+        if res["interest"]:
+            lines.append(S.DAILY_UI["interest"].format(interest=coin(res["interest"])))
+        if res["vip"]:
+            lines.append(S.DAILY_UI["vip"])
+        lines.append(S.DAILY_UI["footer"].format(streak_str=streak_str, balance=coin(res["balance"])))
+
+        embed = discord.Embed(title=S.TITLE["daily"], description="\n".join(lines), color=0xF4C430)
+        await interaction.followup.send(embed=embed)
+        asyncio.create_task(maybe_remind(interaction.user.id, "daily"))
+        asyncio.create_task(award_exp(interaction, economy.EXP_REWARDS["daily"]))
+
+    @tree.command(name="work", description=S.CMD["work"])
+    async def cmd_work(interaction: discord.Interaction):
+        if await check_cmd_rate(interaction):
+            return
+        await interaction.response.defer()
+        res = await economy.do_work(interaction.user.id)
+        if not res["ok"]:
+            if res["reason"] == "banned":
+                await interaction.followup.send(S.MSG_BANNED, ephemeral=True)
+            elif res["reason"] == "cooldown":
+                await interaction.followup.send(
+                    S.CD_MSG["work"].format(ts=cd_ts(res["remaining"])),
+                    ephemeral=True,
+                )
+            elif res["reason"] == "jailed":
+                await interaction.followup.send(
+                    S.CD_MSG["jailed"].format(ts=cd_ts(res["remaining"])),
+                    ephemeral=True,
+                )
+            return
+
+        desc = S.WORK_UI["desc"].format(job=res["job"], earned=coin(res["earned"]))
+        if res["lucky"]:
+            desc += S.WORK_UI["redbull"]
+        if res["hiir"]:
+            desc += S.WORK_UI["hiir"]
+        if res["laud"]:
+            desc += S.WORK_UI["laud"]
+        desc += S.WORK_UI["balance"].format(balance=coin(res["balance"]))
+        embed = discord.Embed(title=S.TITLE["work"], description=desc, color=0x57F287)
+        await interaction.followup.send(embed=embed)
+        asyncio.create_task(maybe_remind(interaction.user.id, "work"))
+        asyncio.create_task(award_exp(interaction, economy.EXP_REWARDS["work"]))
+
+    @tree.command(name="beg", description=S.CMD["beg"])
+    async def cmd_beg(interaction: discord.Interaction):
+        if await check_cmd_rate(interaction):
+            return
+        await interaction.response.defer()
+        res = await economy.do_beg(interaction.user.id)
+        if not res["ok"]:
+            if res["reason"] == "banned":
+                await interaction.followup.send(S.MSG_BANNED, ephemeral=True)
+            elif res["reason"] == "cooldown":
+                await interaction.followup.send(
+                    S.CD_MSG["beg"].format(ts=cd_ts(res["remaining"])),
+                    ephemeral=True,
+                )
+            return
+
+        if res["jailed"]:
+            title = "🔒 " + S.TITLE["beg"]
+            color = 0xE67E22
+        else:
+            title = S.TITLE["beg"]
+            color = 0x99AAB5
+        beg_lines = [S.BEG_UI["desc"].format(text=res["text"], earned=coin(res["earned"]))]
+        if res["klaviatuur"]:
+            beg_lines.append(S.BEG_UI["klaviatuur"])
+        beg_lines.append(S.BEG_UI["balance"].format(balance=coin(res["balance"])))
+        embed = discord.Embed(title=title, description="\n".join(beg_lines), color=color)
+        await interaction.followup.send(embed=embed)
+        asyncio.create_task(maybe_remind(interaction.user.id, "beg"))
+        asyncio.create_task(award_exp(interaction, economy.EXP_REWARDS["beg"]))
+
+    @tree.command(name="crime", description=S.CMD["crime"])
+    async def cmd_crime(interaction: discord.Interaction):
+        if await check_cmd_rate(interaction):
+            return
+        await interaction.response.defer()
+        res = await economy.do_crime(interaction.user.id)
+        if not res["ok"]:
+            if res["reason"] == "banned":
+                await interaction.followup.send(S.MSG_BANNED, ephemeral=True)
+            elif res["reason"] == "cooldown":
+                await interaction.followup.send(
+                    S.CD_MSG["crime"].format(ts=cd_ts(res["remaining"])),
+                    ephemeral=True,
+                )
+            elif res["reason"] == "jailed":
+                await interaction.followup.send(
+                    S.CD_MSG["jailed"].format(ts=cd_ts(res["remaining"])),
+                    ephemeral=True,
+                )
+            return
+
+        if res["success"]:
+            crime_lines = [S.CRIME_UI["win_desc"].format(text=res["text"], earned=coin(res["earned"]))]
+            if res["mikrofon"]:
+                crime_lines.append(S.CRIME_UI["mikrofon"].lstrip("\n"))
+            crime_lines.append(S.CRIME_UI["balance"].lstrip("\n").format(balance=coin(res["balance"])))
+            embed = discord.Embed(
+                title=S.TITLE["crime_win"],
+                description="\n".join(crime_lines),
+                color=0x57F287,
+            )
+        else:
+            jail_part = (
+                S.CRIME_UI["fail_jailed"].format(ts=cd_ts(economy.JAIL_DURATION))
+                if res.get("jailed")
+                else S.CRIME_UI["fail_shield"]
+            )
+            embed = discord.Embed(
+                title=S.TITLE["crime_fail"],
+                description=S.CRIME_UI["fail_base"].format(text=res["text"], fine=coin(res["fine"]))
+                + jail_part
+                + S.CRIME_UI["balance"].format(balance=coin(res["balance"])),
+                color=0xED4245,
+            )
+        await interaction.followup.send(embed=embed)
+        asyncio.create_task(maybe_remind(interaction.user.id, "crime"))
+        if res["success"]:
+            asyncio.create_task(award_exp(interaction, economy.EXP_REWARDS["crime_win"]))
+
+    @tree.command(name="rob", description=S.CMD["rob"])
+    async def cmd_rob(interaction: discord.Interaction, sihtmärk: discord.Member):
+        if await check_cmd_rate(interaction):
+            return
+        if sihtmärk.id == interaction.user.id:
+            await interaction.response.send_message(S.ERR["rob_self"], ephemeral=True)
+            return
+        if sihtmärk.bot and (bot.user is None or sihtmärk.id != bot.user.id):
+            await interaction.response.send_message(S.ERR["rob_bot"], ephemeral=True)
+            return
+        if bot.user and sihtmärk.id == bot.user.id:
+            await interaction.response.send_message(S.ERR["rob_house_blocked"], ephemeral=True)
+            return
+
+        await interaction.response.defer()
+        res = await economy.do_rob(interaction.user.id, sihtmärk.id)
+        if not res["ok"]:
+            if res["reason"] == "banned":
+                await interaction.followup.send(S.MSG_BANNED, ephemeral=True)
+            elif res["reason"] == "cooldown":
+                await interaction.followup.send(
+                    S.CD_MSG["rob"].format(ts=cd_ts(res["remaining"])),
+                    ephemeral=True,
+                )
+            elif res["reason"] == "jailed":
+                await interaction.followup.send(
+                    S.CD_MSG["jailed"].format(ts=cd_ts(res["remaining"])),
+                    ephemeral=True,
+                )
+            elif res["reason"] == "broke":
+                await interaction.followup.send(
+                    S.ERR["rob_too_poor"].format(name=sihtmärk.display_name),
+                    ephemeral=True,
+                )
+            elif res["reason"] == "target_jailed":
+                await interaction.followup.send(
+                    S.ERR["rob_target_jailed"].format(name=sihtmärk.display_name),
+                    ephemeral=True,
+                )
+            return
+
+        if res["success"]:
+            if res.get("jackpot"):
+                desc = S.ROB_UI["jackpot_desc"].format(stolen=coin(res["stolen"]), balance=coin(res["balance"]))
+                color = 0xF4C430
+            else:
+                desc = S.ROB_UI["win_desc"].format(
+                    stolen=coin(res["stolen"]),
+                    name=sihtmärk.display_name,
+                    balance=coin(res["balance"]),
+                )
+                color = 0x57F287
+            embed = discord.Embed(title=S.TITLE["rob_win"], description=desc, color=color)
+        elif res["reason"] == "valvur":
+            embed = discord.Embed(
+                title=S.TITLE["rob_anticheat"],
+                description=S.ROB_UI["anticheat_desc"].format(
+                    name=sihtmärk.display_name,
+                    fine=coin(res["fine"]),
+                ),
+                color=0xED4245,
+            )
+            target_data = await economy.get_user(sihtmärk.id)
+            if "anticheat" not in target_data.get("items", []):
+                try:
+                    await sihtmärk.send(S.ROB_UI["anticheat_worn"])
+                except discord.Forbidden:
+                    pass
+        else:
+            embed = discord.Embed(
+                title=S.TITLE["rob_fail"],
+                description=S.ROB_UI["fail_desc"].format(
+                    fine=coin(res["fine"]),
+                    balance=coin(res["balance"]),
+                ),
+                color=0xED4245,
+            )
+        await interaction.followup.send(embed=embed)
+        asyncio.create_task(maybe_remind(interaction.user.id, "rob"))
+        if res["success"]:
+            asyncio.create_task(award_exp(interaction, economy.EXP_REWARDS["rob_win"]))
+            try:
+                await sihtmärk.send(
+                    S.ROB_UI["victim_dm"].format(
+                        robber=interaction.user.display_name,
+                        stolen=coin(res["stolen"]),
+                    )
+                )
+            except discord.Forbidden:
+                pass

commands/economy_prestige_commands.py

@@ -0,0 +1,249 @@
+from __future__ import annotations
+
+import asyncio
+from collections.abc import Awaitable, Callable
+
+import discord
+from discord import app_commands
+
+from core import economy
+import strings as S
+
+
+def register_prestige_commands(
+    tree: app_commands.CommandTree,
+    check_cmd_rate: Callable[[discord.Interaction], Awaitable[bool]],
+    ensure_level_role: Callable[[discord.Member, int], Awaitable[None]],
+) -> None:
+    class PrestigeView(discord.ui.View):
+        def __init__(self, user_id: int, tab: str = "status"):
+            super().__init__(timeout=60)
+            self.user_id = user_id
+            self.tab = tab
+
+        async def _rebuild(self, data: dict):
+            self.clear_items()
+            pp = data.get("prestige_points", 0)
+            upgrades: dict = data.get("prestige_upgrades") or {}
+            exp = data.get("exp", 0)
+            level = economy.get_level(exp)
+
+            for tab_id, label in (("status", S.PRESTIGE_UI["btn_tab_status"]), ("shop", S.PRESTIGE_UI["btn_tab_shop"])):
+                btn = discord.ui.Button(
+                    label=label,
+                    style=discord.ButtonStyle.primary if tab_id == self.tab else discord.ButtonStyle.secondary,
+                    disabled=(tab_id == self.tab),
+                    row=0,
+                )
+                btn.callback = self._switch_tab(tab_id)
+                self.add_item(btn)
+
+            if self.tab == "status" and level >= economy.PRESTIGE_MIN_LEVEL:
+                confirm_btn = discord.ui.Button(
+                    label=S.PRESTIGE_UI["btn_confirm"],
+                    style=discord.ButtonStyle.danger,
+                    row=1,
+                )
+                confirm_btn.callback = self._do_prestige()
+                cancel_btn = discord.ui.Button(
+                    label=S.PRESTIGE_UI["btn_cancel"],
+                    style=discord.ButtonStyle.secondary,
+                    row=1,
+                )
+                cancel_btn.callback = self._do_cancel()
+                self.add_item(confirm_btn)
+                self.add_item(cancel_btn)
+            elif self.tab == "shop":
+                for uid, item in economy.PRESTIGE_SHOP.items():
+                    cur_level = upgrades.get(uid, 0)
+                    if cur_level >= item["max_level"]:
+                        continue
+                    cost = item["pp_cost"]
+                    btn = discord.ui.Button(
+                        label=S.PRESTIGE_UI["btn_buy_upgrade"].format(emoji=item["emoji"], name=S.PRESTIGE_SHOP_NAMES[uid], cost=cost),
+                        style=discord.ButtonStyle.success if pp >= cost else discord.ButtonStyle.secondary,
+                        disabled=(pp < cost),
+                        row=1,
+                    )
+                    btn.callback = self._buy_upgrade(uid)
+                    self.add_item(btn)
+
+        def _build_status_embed(self, data: dict) -> discord.Embed:
+            exp = data.get("exp", 0)
+            level = economy.get_level(exp)
+            pp = data.get("prestige_points", 0)
+            p_level = data.get("prestige_level", 0)
+            if level >= economy.PRESTIGE_MIN_LEVEL:
+                pp_preview = max(1, exp // 1000)
+                embed = discord.Embed(
+                    title=S.TITLE["prestige_confirm"],
+                    description=S.PRESTIGE_UI["confirm_desc"].format(level=level, exp=exp, pp=pp_preview),
+                    color=0xF4C430,
+                )
+            else:
+                embed = discord.Embed(
+                    title=S.TITLE["prestige_too_low"],
+                    description=S.PRESTIGE_UI["too_low_desc"].format(level=level, required=economy.PRESTIGE_MIN_LEVEL),
+                    color=0xED4245,
+                )
+            if p_level > 0:
+                embed.set_footer(text=S.PRESTIGE_UI["status_footer"].format(level=p_level, pp=pp))
+            return embed
+
+        def _build_shop_embed(self, data: dict) -> discord.Embed:
+            pp = data.get("prestige_points", 0)
+            upgrades: dict = data.get("prestige_upgrades") or {}
+            embed = discord.Embed(
+                title=S.TITLE["prestige_shop"],
+                description=S.PRESTIGE_UI["shop_desc"].format(pp=pp),
+                color=0xF4C430,
+            )
+            for uid, item in economy.PRESTIGE_SHOP.items():
+                cur_level = upgrades.get(uid, 0)
+                name = f"{item['emoji']} {S.PRESTIGE_SHOP_NAMES[uid]}"
+                cost_str = S.PRESTIGE_UI["shop_maxed"] if cur_level >= item["max_level"] else S.PRESTIGE_UI["shop_cost_fmt"].format(cost=item["pp_cost"])
+                level_str = S.PRESTIGE_UI["shop_level_fmt"].format(cur=cur_level, max=item["max_level"])
+                embed.add_field(name=f"{name}  ·  {level_str}  ·  {cost_str}", value=S.PRESTIGE_SHOP_DESCRIPTIONS[uid], inline=False)
+            return embed
+
+        def _switch_tab(self, tab_id: str):
+            async def _cb(interaction: discord.Interaction):
+                if interaction.user.id != self.user_id:
+                    await interaction.response.send_message(S.ERR["not_your_menu"], ephemeral=True)
+                    return
+                self.tab = tab_id
+                await interaction.response.defer()
+                data = await economy.get_user(self.user_id)
+                await self._rebuild(data)
+                embed = self._build_status_embed(data) if tab_id == "status" else self._build_shop_embed(data)
+                await interaction.edit_original_response(embed=embed, view=self)
+
+            return _cb
+
+        def _do_prestige(self):
+            async def _cb(interaction: discord.Interaction):
+                if interaction.user.id != self.user_id:
+                    await interaction.response.send_message(S.ERR["not_your_game"], ephemeral=True)
+                    return
+                await interaction.response.defer()
+                res = await economy.do_prestige(self.user_id)
+                self.clear_items()
+                if not res["ok"]:
+                    embed = discord.Embed(
+                        title=S.TITLE["prestige_too_low"],
+                        description=S.PRESTIGE_UI["too_low_desc"].format(level=res.get("level", 0), required=res.get("required", 30)),
+                        color=0xED4245,
+                    )
+                else:
+                    embed = discord.Embed(
+                        title=S.TITLE["prestige_success"].format(level=res["prestige_level"]),
+                        description=S.PRESTIGE_UI["success_desc"].format(pp=res["pp_earned"], level=res["prestige_level"], total_pp=res["prestige_points"]),
+                        color=0xF4C430,
+                    )
+                await interaction.edit_original_response(embed=embed, view=self)
+                if res.get("ok") and interaction.guild:
+                    member = interaction.guild.get_member(self.user_id)
+                    if member:
+                        asyncio.create_task(ensure_level_role(member, 1))
+
+            return _cb
+
+        def _do_cancel(self):
+            async def _cb(interaction: discord.Interaction):
+                if interaction.user.id != self.user_id:
+                    await interaction.response.send_message(S.ERR["not_your_game"], ephemeral=True)
+                    return
+                self.clear_items()
+                await interaction.response.edit_message(view=self)
+
+            return _cb
+
+        def _buy_upgrade(self, upgrade_id: str):
+            async def _cb(interaction: discord.Interaction):
+                if interaction.user.id != self.user_id:
+                    await interaction.response.send_message(S.ERR["not_your_menu"], ephemeral=True)
+                    return
+                await interaction.response.defer()
+                res = await economy.do_prestige_buy(self.user_id, upgrade_id)
+                if not res["ok"]:
+                    if res["reason"] == "insufficient_pp":
+                        err = S.PRESTIGE_UI["buy_no_pp"].format(have=res["have"], need=res["need"])
+                    elif res["reason"] == "maxed":
+                        err = S.PRESTIGE_UI["buy_maxed"]
+                    else:
+                        err = S.ERR["generic_error"].format(error=res["reason"])
+                    await interaction.followup.send(err, ephemeral=True)
+                    return
+                data = await economy.get_user(self.user_id)
+                await self._rebuild(data)
+                embed = self._build_shop_embed(data)
+                item = economy.PRESTIGE_SHOP[res["upgrade_id"]]
+                name = f"{item['emoji']} {S.PRESTIGE_SHOP_NAMES[res['upgrade_id']]}"
+                embed.description = S.PRESTIGE_UI["buy_success_desc"].format(
+                    name=name,
+                    new_level=res["new_level"],
+                    max_level=item["max_level"],
+                    pp=res["pp_remaining"],
+                ) + "\n\n" + (embed.description or "")
+                await interaction.edit_original_response(embed=embed, view=self)
+
+            return _cb
+
+        async def on_timeout(self):
+            self.clear_items()
+
+    @tree.command(name="prestige", description=S.CMD["prestige"])
+    @app_commands.guild_only()
+    async def cmd_prestige(interaction: discord.Interaction):
+        if await check_cmd_rate(interaction):
+            return
+        data = await economy.get_user(interaction.user.id)
+        if data.get("eco_banned"):
+            await interaction.response.send_message(S.MSG_BANNED, ephemeral=True)
+            return
+        view = PrestigeView(interaction.user.id)
+        await view._rebuild(data)
+        embed = view._build_status_embed(data)
+        await interaction.response.send_message(embed=embed, view=view, ephemeral=True)
+
+    @tree.command(name="prestigeshop", description=S.CMD["prestigeshop"])
+    async def cmd_prestigeshop(interaction: discord.Interaction):
+        data = await economy.get_user(interaction.user.id)
+        view = PrestigeView(interaction.user.id, tab="shop")
+        await view._rebuild(data)
+        embed = view._build_shop_embed(data)
+        await interaction.response.send_message(embed=embed, view=view, ephemeral=True)
+
+    @tree.command(name="prestigebuy", description=S.CMD["prestigebuy"])
+    @app_commands.describe(upgrade=S.OPT["prestigebuy_upgrade"])
+    async def cmd_prestigebuy(interaction: discord.Interaction, upgrade: str):
+        if await check_cmd_rate(interaction):
+            return
+        res = await economy.do_prestige_buy(interaction.user.id, upgrade.strip().lower())
+        if not res["ok"]:
+            if res["reason"] == "banned":
+                await interaction.response.send_message(S.MSG_BANNED, ephemeral=True)
+            elif res["reason"] == "not_found":
+                await interaction.response.send_message(S.PRESTIGE_UI["buy_not_found"], ephemeral=True)
+            elif res["reason"] == "maxed":
+                await interaction.response.send_message(S.PRESTIGE_UI["buy_maxed"], ephemeral=True)
+            elif res["reason"] == "insufficient_pp":
+                await interaction.response.send_message(
+                    S.PRESTIGE_UI["buy_no_pp"].format(have=res["have"], need=res["need"]),
+                    ephemeral=True,
+                )
+            return
+
+        item = economy.PRESTIGE_SHOP[res["upgrade_id"]]
+        name = f"{item['emoji']} {S.PRESTIGE_SHOP_NAMES[res['upgrade_id']]}"
+        embed = discord.Embed(
+            title=S.TITLE["prestige_buy_ok"],
+            description=S.PRESTIGE_UI["buy_success_desc"].format(
+                name=name,
+                new_level=res["new_level"],
+                max_level=res["max_level"],
+                pp=res["pp_remaining"],
+            ),
+            color=0x57F287,
+        )
+        await interaction.response.send_message(embed=embed, ephemeral=True)

commands/economy_profile_commands.py

@@ -0,0 +1,545 @@
+from __future__ import annotations
+
+import asyncio
+import datetime
+from collections.abc import Awaitable, Callable
+
+import discord
+from discord import app_commands
+
+from core import economy
+import strings as S
+
+
+def register_economy_profile_commands(
+    tree: app_commands.CommandTree,
+    coin: Callable[[int], str],
+    cd_ts: Callable[[datetime.timedelta], str],
+    ensure_level_role: Callable[[discord.Member, int], Awaitable[None]],
+) -> None:
+    def _profile_main_embed(target: discord.User | discord.Member, data: dict) -> discord.Embed:
+        exp = data.get("exp", 0)
+        level = economy.get_level(exp)
+        role_name = economy.level_role_name(level)
+        next_level = level + 1
+        exp_this = economy.exp_for_level(level)
+        exp_next = economy.exp_for_level(next_level)
+        progress = exp - exp_this
+        needed = exp_next - exp_this
+        pct = progress / needed if needed > 0 else 1.0
+        filled = int(pct * 12)
+        bar = "█" * filled + "░" * (12 - filled)
+        embed = discord.Embed(
+            title=S.PROFILE_UI["main_title"].format(name=target.display_name),
+            color=0xF4C430,
+        )
+        embed.add_field(name=S.PROFILE_UI["f_balance"], value=coin(data.get("balance", 0)), inline=True)
+        embed.add_field(
+            name=S.PROFILE_UI["f_level"],
+            value=S.PROFILE_UI["level_val"].format(level=level, role=role_name),
+            inline=True,
+        )
+        streak = data.get("daily_streak", 0)
+        if streak:
+            embed.add_field(
+                name=S.PROFILE_UI["f_streak"],
+                value=S.BALANCE_UI["streak_val"].format(streak=streak),
+                inline=True,
+            )
+        p_level = data.get("prestige_level", 0)
+        if p_level > 0:
+            p_pp = data.get("prestige_points", 0)
+            embed.add_field(
+                name=S.PROFILE_UI["f_prestige"],
+                value=S.PROFILE_UI["prestige_val"].format(level=p_level, pp=p_pp),
+                inline=True,
+            )
+        jail_remaining = economy._is_jailed(data)
+        if jail_remaining:
+            embed.add_field(name=S.PROFILE_UI["f_jail"], value=cd_ts(jail_remaining), inline=True)
+        embed.add_field(
+            name=S.PROFILE_UI["f_progress"].format(next=next_level),
+            value=S.PROFILE_UI["progress_bar"].format(bar=bar, done=progress, needed=needed),
+            inline=False,
+        )
+        if level < 10:
+            embed.set_footer(text=S.PROFILE_UI["footer_t1"])
+        elif level < 20:
+            embed.set_footer(text=S.PROFILE_UI["footer_t2"])
+        else:
+            embed.set_footer(text=S.PROFILE_UI["footer_t3"])
+        return embed
+
+    def _profile_items_embed(target: discord.User | discord.Member, data: dict) -> discord.Embed:
+        embed = discord.Embed(
+            title=S.PROFILE_UI["items_title"].format(name=target.display_name),
+            color=0xF4C430,
+        )
+        uses_map = data.get("item_uses", {})
+        item_lines = []
+        for item_id in data.get("items", []):
+            if item_id not in economy.SHOP:
+                continue
+            line = f"{economy.SHOP[item_id]['emoji']} **{economy.SHOP[item_id]['name']}**"
+            if item_id in uses_map:
+                uses = uses_map[item_id]
+                line += (
+                    S.BALANCE_UI["uses_one"].format(uses=uses)
+                    if uses == 1
+                    else S.BALANCE_UI["uses_many"].format(uses=uses)
+                )
+            item_lines.append(line)
+        embed.description = "\n".join(item_lines) if item_lines else S.PROFILE_UI["items_empty"]
+        return embed
+
+    def _profile_stats_embed(target: discord.User | discord.Member, data: dict) -> discord.Embed:
+        def _s(key: str) -> int:
+            return data.get(key, 0)
+
+        embed = discord.Embed(
+            title=S.PROFILE_UI["stats_title"].format(name=target.display_name),
+            color=0x5865F2,
+        )
+        embed.add_field(
+            name=S.STATS_UI["economy_field"],
+            value=S.STATS_UI["economy_val"].format(
+                peak=coin(_s("peak_balance")),
+                earned=coin(_s("lifetime_earned")),
+                lost=coin(_s("lifetime_lost")),
+            ),
+            inline=True,
+        )
+        embed.add_field(
+            name=S.STATS_UI["work_field"],
+            value=S.STATS_UI["work_val"].format(work=_s("work_count"), beg=_s("beg_count")),
+            inline=True,
+        )
+        embed.add_field(name="\u200b", value="\u200b", inline=False)
+        embed.add_field(
+            name=S.STATS_UI["gamble_field"],
+            value=S.STATS_UI["gamble_val"].format(
+                wagered=coin(_s("total_wagered")),
+                win=coin(_s("biggest_win")),
+                loss=coin(_s("biggest_loss")),
+                jackpots=_s("slots_jackpots"),
+            ),
+            inline=True,
+        )
+        embed.add_field(
+            name=S.STATS_UI["crime_field"],
+            value=S.STATS_UI["crime_val"].format(
+                crimes=_s("crimes_attempted"),
+                succeeded=_s("crimes_succeeded"),
+                heists=_s("heists_joined"),
+                heists_won=_s("heists_won"),
+                jailed=_s("times_jailed"),
+                bail=coin(_s("total_bail_paid")),
+            ),
+            inline=True,
+        )
+        embed.add_field(name="\u200b", value="\u200b", inline=False)
+        embed.add_field(
+            name=S.STATS_UI["social_field"],
+            value=S.STATS_UI["social_val"].format(
+                given=coin(_s("total_given")),
+                received=coin(_s("total_received")),
+            ),
+            inline=True,
+        )
+        embed.add_field(
+            name=S.STATS_UI["records_field"],
+            value=S.STATS_UI["records_val"].format(streak=_s("best_daily_streak")),
+            inline=True,
+        )
+        return embed
+
+    def _profile_fish_embed(target: discord.User | discord.Member, fish_res: dict) -> discord.Embed:
+        embed = discord.Embed(
+            title=S.PROFILE_UI["fish_title"].format(name=target.display_name),
+            color=0x5865F2,
+        )
+        book: dict = fish_res["book"]
+        if not book:
+            embed.description = S.FISH_UI["book_empty"]
+            return embed
+        inv_counts: dict = fish_res.get("inv_counts", {})
+        caught_count = fish_res["unique_caught"]
+        total = fish_res["total_species"]
+        lines = [S.FISH_UI["book_caught"].format(caught=caught_count, total=total)]
+        for fish_id, fish_data in economy.FISH_CATALOGUE.items():
+            rarity = fish_data["rarity"]
+            emoji = S.FISH_RARITY_EMOJI[rarity]
+            rarity_name = S.FISH_RARITY_NAMES[rarity]
+            count = book.get(fish_id, 0)
+            if count > 0:
+                n_inv = inv_counts.get(fish_id, 0)
+                inv_str = S.FISH_UI["book_inv"].format(n=n_inv) if n_inv > 0 else ""
+                lines.append(
+                    S.FISH_UI["book_yes"].format(
+                        emoji=emoji,
+                        name=S.FISH_NAMES[fish_id],
+                        rarity=rarity_name,
+                        count=count,
+                        inv=inv_str,
+                    )
+                )
+            else:
+                lines.append(S.FISH_UI["book_no"].format(rarity=rarity_name))
+        embed.description = "\n".join(lines)
+        embed.set_footer(
+            text=S.FISH_UI["book_footer"].format(
+                page=1,
+                total_pages=1,
+                caught=caught_count,
+                total=total,
+            )
+        )
+        return embed
+
+    class ProfileView(discord.ui.View):
+        def __init__(self, target: discord.User | discord.Member, invoker_id: int, tab: str = "main"):
+            super().__init__(timeout=120)
+            self.target = target
+            self.invoker_id = invoker_id
+            self.tab = tab
+            self._rebuild()
+
+        def _rebuild(self):
+            self.clear_items()
+            tabs = [
+                ("main", S.PROFILE_UI["btn_profile"]),
+                ("items", S.PROFILE_UI["btn_items"]),
+                ("stats", S.PROFILE_UI["btn_stats"]),
+                ("fish", S.PROFILE_UI["btn_fish"]),
+            ]
+            for tab_id, label in tabs:
+                btn = discord.ui.Button(
+                    label=label,
+                    style=(
+                        discord.ButtonStyle.primary
+                        if tab_id == self.tab
+                        else discord.ButtonStyle.secondary
+                    ),
+                    disabled=(tab_id == self.tab),
+                )
+                btn.callback = self._make_cb(tab_id)
+                self.add_item(btn)
+
+        def _make_cb(self, tab_id: str):
+            async def _cb(interaction: discord.Interaction):
+                if interaction.user.id != self.invoker_id:
+                    await interaction.response.send_message(S.ERR["not_your_menu"], ephemeral=True)
+                    return
+                self.tab = tab_id
+                self._rebuild()
+                await interaction.response.defer()
+                data = await economy.get_user(self.target.id)
+                if tab_id == "fish":
+                    fish_res = await economy.do_fishbook(self.target.id)
+                    embed = _profile_fish_embed(self.target, fish_res)
+                    inv: list = data.get("fish_inventory") or []
+                    if inv and self.target.id == self.invoker_id:
+                        total_value = sum(entry.get("value", 0) for entry in inv)
+                        sell_btn = discord.ui.Button(
+                            label=(
+                                f"{S.FISH_UI['btn_sell']} "
+                                f"({len(inv)} kala · {total_value:,} {economy.COIN})"
+                            ),
+                            style=discord.ButtonStyle.success,
+                            row=1,
+                        )
+                        sell_btn.callback = self._sell_fish_cb()
+                        self.add_item(sell_btn)
+                elif tab_id == "items":
+                    embed = _profile_items_embed(self.target, data)
+                elif tab_id == "stats":
+                    embed = _profile_stats_embed(self.target, data)
+                else:
+                    embed = _profile_main_embed(self.target, data)
+                await interaction.edit_original_response(embed=embed, view=self)
+
+            return _cb
+
+        def _sell_fish_cb(self):
+            async def _cb(interaction: discord.Interaction):
+                if interaction.user.id != self.invoker_id:
+                    await interaction.response.send_message(S.ERR["not_your_menu"], ephemeral=True)
+                    return
+                await interaction.response.defer()
+                res = await economy.do_fish_sell(self.invoker_id)
+                self.tab = "fish"
+                self._rebuild()
+                fish_res = await economy.do_fishbook(self.target.id)
+                embed = _profile_fish_embed(self.target, fish_res)
+                sold_line = S.FISH_UI["inv_sold_all"].format(
+                    count=res.get("count", 0),
+                    coins=coin(res.get("coins", 0)),
+                    balance=coin(res.get("balance", 0)),
+                )
+                embed.description = f"{sold_line}\n\n{embed.description or ''}"
+                await interaction.edit_original_response(embed=embed, view=self)
+
+            return _cb
+
+    def _balance_embed(user: discord.User | discord.Member, data: dict) -> discord.Embed:
+        embed = discord.Embed(
+            title=f"{economy.COIN} {user.display_name}",
+            color=0xF4C430,
+        )
+        embed.add_field(name=S.BALANCE_UI["saldo"], value=coin(data["balance"]), inline=True)
+        streak = data.get("daily_streak", 0)
+        if streak:
+            embed.add_field(
+                name=S.BALANCE_UI["streak"],
+                value=S.BALANCE_UI["streak_val"].format(streak=streak),
+                inline=True,
+            )
+        jail_remaining = economy._is_jailed(data)
+        if jail_remaining:
+            embed.add_field(name=S.BALANCE_UI["jailed_until"], value=cd_ts(jail_remaining), inline=True)
+        item_lines = []
+        uses_map = data.get("item_uses", {})
+        for item_id in data.get("items", []):
+            if item_id not in economy.SHOP:
+                continue
+            line = f"{economy.SHOP[item_id]['emoji']} {economy.SHOP[item_id]['name']}"
+            if item_id in uses_map:
+                uses = uses_map[item_id]
+                line += (
+                    S.BALANCE_UI["uses_one"].format(uses=uses)
+                    if uses == 1
+                    else S.BALANCE_UI["uses_many"].format(uses=uses)
+                )
+            item_lines.append(line)
+        if item_lines:
+            embed.add_field(name=S.BALANCE_UI["items"], value="\n".join(item_lines), inline=False)
+        return embed
+
+    @tree.command(name="profile", description=S.CMD["profile"])
+    @app_commands.describe(kasutaja=S.OPT["profile_kasutaja"])
+    async def cmd_profile(interaction: discord.Interaction, kasutaja: discord.Member | None = None):
+        target = kasutaja or interaction.user
+        data = await economy.get_user(target.id)
+        embed = _profile_main_embed(target, data)
+        invoker_id = interaction.user.id
+        await interaction.response.send_message(embed=embed, view=ProfileView(target, invoker_id))
+        if not kasutaja and interaction.guild:
+            member = interaction.guild.get_member(target.id)
+            if member:
+                asyncio.create_task(ensure_level_role(member, economy.get_level(data.get("exp", 0))))
+
+    @tree.command(name="balance", description=S.CMD["balance"])
+    async def cmd_balance(interaction: discord.Interaction, kasutaja: discord.Member | None = None):
+        target = kasutaja or interaction.user
+        data = await economy.get_user(target.id)
+        await interaction.response.send_message(embed=_balance_embed(target, data))
+
+    @tree.command(name="cooldowns", description=S.CMD["cooldowns"])
+    async def cmd_cooldowns(interaction: discord.Interaction):
+        data = await economy.get_user(interaction.user.id)
+        now = datetime.datetime.now(datetime.timezone.utc)
+        items = set(data.get("items", []))
+
+        def _status(last_key: str, cooldown: datetime.timedelta) -> str:
+            raw = data.get(last_key)
+            if not raw:
+                return S.COOLDOWNS_UI["ready"]
+            last = economy._parse_dt(raw)
+            if last is None:
+                return S.COOLDOWNS_UI["ready"]
+            expires = last + cooldown
+            if expires <= now:
+                return S.COOLDOWNS_UI["ready"]
+            ts = int(expires.timestamp())
+            return f"⏳ <t:{ts}:R>"
+
+        work_cd = datetime.timedelta(minutes=40) if "monitor" in items else economy.COOLDOWNS["work"]
+        beg_cd = datetime.timedelta(minutes=3) if "hiirematt" in items else economy.COOLDOWNS["beg"]
+        daily_cd = datetime.timedelta(hours=18) if "korvaklapid" in items else economy.COOLDOWNS["daily"]
+        fish_cd = datetime.timedelta(seconds=90) if "ussipurk" in items else economy.COOLDOWNS["fish"]
+
+        lines = [
+            S.COOLDOWNS_UI["daily_line"].format(
+                status=_status("last_daily", daily_cd),
+                note=S.COOLDOWNS_UI["note_korvak"] if "korvaklapid" in items else "",
+            ),
+            S.COOLDOWNS_UI["work_line"].format(
+                status=_status("last_work", work_cd),
+                note=S.COOLDOWNS_UI["note_monitor"] if "monitor" in items else "",
+            ),
+            S.COOLDOWNS_UI["beg_line"].format(
+                status=_status("last_beg", beg_cd),
+                note=S.COOLDOWNS_UI["note_hiirematt"] if "hiirematt" in items else "",
+            ),
+            S.COOLDOWNS_UI["crime_line"].format(status=_status("last_crime", economy.COOLDOWNS["crime"])),
+            S.COOLDOWNS_UI["rob_line"].format(status=_status("last_rob", economy.COOLDOWNS["rob"])),
+            S.COOLDOWNS_UI["fish_line"].format(
+                status=_status("last_fish", fish_cd),
+                note=S.COOLDOWNS_UI["note_ussipurk"] if "ussipurk" in items else "",
+            ),
+        ]
+
+        jailed = data.get("jailed_until")
+        if jailed:
+            jail_dt = datetime.datetime.fromisoformat(jailed)
+            if jail_dt > now:
+                ts = int(jail_dt.timestamp())
+                lines.append(S.COOLDOWNS_UI["jailed"].format(ts=ts))
+            else:
+                lines.append(S.COOLDOWNS_UI["jail_expired"])
+
+        embed = discord.Embed(
+            title=S.TITLE["cooldowns"],
+            description="\n".join(lines),
+            color=0x5865F2,
+        )
+        await interaction.response.send_message(embed=embed, ephemeral=True)
+
+    @tree.command(name="jailed", description=S.CMD["jailed"])
+    @app_commands.guild_only()
+    async def cmd_jailed(interaction: discord.Interaction):
+        await interaction.response.defer()
+        jailed = await economy.do_get_jailed()
+        if not jailed:
+            embed = discord.Embed(
+                title=S.JAILED_UI["title"],
+                description=S.JAILED_UI["empty"],
+                color=0x57F287,
+            )
+            await interaction.followup.send(embed=embed)
+            return
+
+        now = datetime.datetime.now(datetime.timezone.utc)
+        lines = []
+        for uid, remaining in jailed:
+            ts = int((now + remaining).timestamp())
+            member = interaction.guild.get_member(uid) if interaction.guild else None
+            mention = member.mention if member else f"<@{uid}>"
+            lines.append(S.JAILED_UI["entry"].format(mention=mention, ts=ts))
+
+        plural = "" if len(jailed) == 1 else "i"
+        embed = discord.Embed(
+            title=S.JAILED_UI["title"],
+            description="\n".join(lines),
+            color=0xED4245,
+        )
+        embed.set_footer(text=S.JAILED_UI["footer"].format(count=len(jailed), plural=plural))
+        await interaction.followup.send(embed=embed)
+
+    @tree.command(name="rank", description=S.CMD["rank"])
+    @app_commands.describe(kasutaja=S.OPT["rank_kasutaja"])
+    async def cmd_rank(interaction: discord.Interaction, kasutaja: discord.Member | None = None):
+        target = kasutaja or interaction.user
+        data = await economy.get_user(target.id)
+        exp = data.get("exp", 0)
+        level = economy.get_level(exp)
+        role_name = economy.level_role_name(level)
+        next_level = level + 1
+        exp_this = economy.exp_for_level(level)
+        exp_next = economy.exp_for_level(next_level)
+        progress = exp - exp_this
+        needed = exp_next - exp_this
+        pct = progress / needed if needed > 0 else 1.0
+        filled = int(pct * 12)
+        bar = "█" * filled + "░" * (12 - filled)
+        embed = discord.Embed(
+            title=S.RANK_UI["title"].format(name=target.display_name, level=level),
+            color=0x5865F2,
+        )
+        embed.add_field(name=S.RANK_UI["field_title"], value=f"**{role_name}**", inline=True)
+        embed.add_field(name=S.RANK_UI["field_exp"], value=str(exp), inline=True)
+        embed.add_field(
+            name=S.RANK_UI["field_progress"].format(next=next_level),
+            value=S.RANK_UI["progress_val"].format(bar=bar, progress=progress, needed=needed),
+            inline=False,
+        )
+        p_level = data.get("prestige_level", 0)
+        p_pp = data.get("prestige_points", 0)
+        s_exp = data.get("season_total_exp", 0)
+        if p_level > 0 or s_exp > 0:
+            embed.add_field(
+                name="\u200b",
+                value=(
+                    S.PRESTIGE_UI["rank_line"].format(level=p_level, pp=p_pp)
+                    + "\n"
+                    + S.PRESTIGE_UI["rank_season"].format(exp=s_exp)
+                ),
+                inline=False,
+            )
+        if level < 10:
+            embed.set_footer(text=S.RANK_UI["footer_t1"])
+        elif level < 20:
+            embed.set_footer(text=S.RANK_UI["footer_t2"])
+        else:
+            embed.set_footer(text=S.RANK_UI["footer_t3"])
+        await interaction.response.send_message(embed=embed, ephemeral=True)
+        if not kasutaja and interaction.guild:
+            member = interaction.guild.get_member(target.id)
+            if member:
+                asyncio.create_task(ensure_level_role(member, level))
+
+    @tree.command(name="stats", description=S.CMD["stats"])
+    @app_commands.describe(kasutaja=S.OPT["stats_kasutaja"])
+    async def cmd_stats(interaction: discord.Interaction, kasutaja: discord.Member | None = None):
+        target = kasutaja or interaction.user
+        data = await economy.get_user(target.id)
+
+        def _s(key: str) -> int:
+            return data.get(key, 0)
+
+        embed = discord.Embed(
+            title=f"{S.TITLE['stats']} - {target.display_name}",
+            color=0x5865F2,
+        )
+        embed.add_field(
+            name=S.STATS_UI["economy_field"],
+            value=S.STATS_UI["economy_val"].format(
+                peak=coin(_s("peak_balance")),
+                earned=coin(_s("lifetime_earned")),
+                lost=coin(_s("lifetime_lost")),
+            ),
+            inline=True,
+        )
+        embed.add_field(
+            name=S.STATS_UI["work_field"],
+            value=S.STATS_UI["work_val"].format(work=_s("work_count"), beg=_s("beg_count")),
+            inline=True,
+        )
+        embed.add_field(name="\u200b", value="\u200b", inline=False)
+        embed.add_field(
+            name=S.STATS_UI["gamble_field"],
+            value=S.STATS_UI["gamble_val"].format(
+                wagered=coin(_s("total_wagered")),
+                win=coin(_s("biggest_win")),
+                loss=coin(_s("biggest_loss")),
+                jackpots=_s("slots_jackpots"),
+            ),
+            inline=True,
+        )
+        embed.add_field(
+            name=S.STATS_UI["crime_field"],
+            value=S.STATS_UI["crime_val"].format(
+                crimes=_s("crimes_attempted"),
+                succeeded=_s("crimes_succeeded"),
+                heists=_s("heists_joined"),
+                heists_won=_s("heists_won"),
+                jailed=_s("times_jailed"),
+                bail=coin(_s("total_bail_paid")),
+            ),
+            inline=True,
+        )
+        embed.add_field(name="\u200b", value="\u200b", inline=False)
+        embed.add_field(
+            name=S.STATS_UI["social_field"],
+            value=S.STATS_UI["social_val"].format(
+                given=coin(_s("total_given")),
+                received=coin(_s("total_received")),
+            ),
+            inline=True,
+        )
+        embed.add_field(
+            name=S.STATS_UI["records_field"],
+            value=S.STATS_UI["records_val"].format(streak=_s("best_daily_streak")),
+            inline=True,
+        )
+        await interaction.response.send_message(embed=embed, ephemeral=True)

commands/economy_quests_commands.py

@@ -0,0 +1,108 @@
+from __future__ import annotations
+
+import asyncio
+import datetime
+from collections.abc import Awaitable, Callable
+
+import discord
+from discord import app_commands
+
+from core import economy
+import strings as S
+
+
+_BAR_SLOTS = 8
+
+
+def _bar(progress: int, goal: int) -> str:
+    """Return an 8-slot ▰/▱ progress bar for a quest."""
+    filled = 0 if goal <= 0 else min(_BAR_SLOTS, round(_BAR_SLOTS * progress / goal))
+    return "▰" * filled + "▱" * (_BAR_SLOTS - filled)
+
+
+def _has_claimable(view_data: dict) -> bool:
+    return any(
+        q["done"] and not q["claimed"]
+        for q in view_data["daily"] + view_data["weekly"]
+    )
+
+
+def register_economy_quests_commands(
+    tree: app_commands.CommandTree,
+    bot: discord.Client,
+    coin: Callable[[int], str],
+    award_exp: Callable[[discord.Interaction, int], Awaitable[None]],
+) -> None:
+    def _render(view_data: dict) -> discord.Embed:
+        embed = discord.Embed(title=S.TITLE["quests"], color=0xF4C430)
+        sections = (
+            (S.QUEST_UI["daily_header"], view_data["daily"]),
+            (S.QUEST_UI["weekly_header"], view_data["weekly"]),
+        )
+        for header, quests in sections:
+            if quests:
+                blocks = []
+                for q in quests:
+                    desc = S.QUEST_DESCRIPTIONS.get(q["id"], q["id"])
+                    if q["claimed"]:
+                        status = S.QUEST_UI["completed"]
+                    elif q["done"]:
+                        status = S.QUEST_UI["ready"]
+                    else:
+                        status = S.QUEST_UI["progress"].format(progress=q["progress"], max=q["goal"])
+                    reward = S.QUEST_UI["reward"].format(coins=f"{q['coins']:,}", exp=q["exp"])
+                    blocks.append(
+                        f"{_bar(q['progress'], q['goal'])} **{desc}**\n{status} · {reward}"
+                    )
+                value = "\n\n".join(blocks)
+            else:
+                value = S.QUEST_UI["empty"]
+            embed.add_field(name=header, value=value, inline=False)
+        return embed
+
+    class QuestView(discord.ui.View):
+        def __init__(self, invoker_id: int, view_data: dict):
+            super().__init__(timeout=180)
+            self.invoker_id = invoker_id
+            btn = discord.ui.Button(
+                label=S.QUEST_UI["claim_btn"],
+                style=discord.ButtonStyle.success,
+                disabled=not _has_claimable(view_data),
+            )
+            btn.callback = self._claim
+            self.add_item(btn)
+
+        async def _claim(self, interaction: discord.Interaction):
+            if interaction.user.id != self.invoker_id:
+                await interaction.response.send_message(S.ERR["not_your_menu"], ephemeral=True)
+                return
+            try:
+                res = await economy.claim_quests(self.invoker_id)
+            except economy.DatabaseError:
+                await interaction.response.send_message(S.QUEST_UI["error"], ephemeral=True)
+                return
+            if not res["ok"]:
+                await interaction.response.send_message(S.QUEST_UI["nothing"], ephemeral=True)
+                return
+            new_data = await economy.get_quests(self.invoker_id)
+            await interaction.response.edit_message(
+                embed=_render(new_data), view=QuestView(self.invoker_id, new_data)
+            )
+            await interaction.followup.send(
+                S.QUEST_UI["claimed_msg"].format(
+                    count=res["claimed"], coins=coin(res["coins"]), exp=res["exp"]
+                ),
+                ephemeral=True,
+            )
+            if res["exp"]:
+                asyncio.create_task(award_exp(interaction, res["exp"]))
+
+    @tree.command(name="quests", description=S.CMD["quests"])
+    async def cmd_quests(interaction: discord.Interaction):
+        await interaction.response.defer()
+        try:
+            data = await economy.get_quests(interaction.user.id)
+        except economy.DatabaseError:
+            await interaction.followup.send(S.QUEST_UI["error"], ephemeral=True)
+            return
+        await interaction.followup.send(embed=_render(data), view=QuestView(interaction.user.id, data))

commands/economy_support_commands.py

@@ -0,0 +1,300 @@
+from __future__ import annotations
+
+from collections.abc import Callable
+
+import discord
+from discord import app_commands
+
+from core import economy
+import strings as S
+
+
+def register_economy_support_commands(
+    tree: app_commands.CommandTree,
+    parse_amount: Callable[[str, int], tuple[int | None, str | None]],
+    coin: Callable[[int], str],
+    cancel_reminder_task: Callable[[int, str], None],
+) -> None:
+    class FundModal(discord.ui.Modal):
+        summa = discord.ui.TextInput(
+            label=S.REQUEST_UI["modal_label"],
+            min_length=1,
+            max_length=10,
+        )
+
+        def __init__(self, view: "RequestView"):
+            super().__init__(title=S.REQUEST_UI["modal_title"])
+            self._view = view
+            self.summa.placeholder = f"1 - {view.remaining}"
+
+        async def on_submit(self, interaction: discord.Interaction):
+            amount, err = parse_amount(self.summa.value, 0)
+            if err or amount is None:
+                await interaction.response.send_message(S.ERR["invalid_amount"], ephemeral=True)
+                return
+            if amount <= 0 or amount > self._view.remaining:
+                await interaction.response.send_message(
+                    S.ERR["fund_range"].format(max=self._view.remaining), ephemeral=True
+                )
+                return
+
+            # Reserve the amount synchronously (no await between the range check
+            # and the decrement) so two concurrent modal submits can't both fund
+            # the same request. discord.py runs each submit as its own task and
+            # do_give is not idempotent, so without this reservation a funder
+            # could double-submit and transfer `amount` more than once.
+            self._view.remaining -= amount
+            res = await economy.do_give(interaction.user.id, self._view.requester.id, amount)
+            if not res["ok"]:
+                self._view.remaining += amount  # roll back the reservation
+                data = await economy.get_user(interaction.user.id)
+                await interaction.response.send_message(
+                    S.ERR["broke"].format(bal=coin(data["balance"])), ephemeral=True
+                )
+                return
+
+            funded_line = S.REQUEST_UI["funded_line"].format(
+                name=interaction.user.display_name,
+                amount=coin(amount),
+            )
+            if self._view.remaining <= 0:
+                self._view.fund_btn.disabled = True
+                self._view.fund_btn.label = S.REQUEST_UI["btn_funded"]
+                self._view.fund_btn.style = discord.ButtonStyle.secondary
+                self._view.stop()
+                funded_line += S.REQUEST_UI["funded_full"]
+            else:
+                self._view.fund_btn.label = S.REQUEST_UI["btn_fund_remaining"].format(
+                    remaining=self._view.remaining
+                )
+                funded_line += S.REQUEST_UI["funded_partial"].format(
+                    remaining=coin(self._view.remaining)
+                )
+
+            await interaction.response.send_message(funded_line)
+            if self._view.message:
+                await self._view.message.edit(view=self._view)
+
+    class RequestView(discord.ui.View):
+        def __init__(self, requester: discord.Member, amount: int, target: discord.Member | None):
+            super().__init__(timeout=300)
+            self.requester = requester
+            self.remaining = amount
+            self.target = target
+            self.message: discord.Message | None = None
+            self.fund_btn = discord.ui.Button(
+                label=S.REQUEST_UI["btn_fund"],
+                style=discord.ButtonStyle.success,
+            )
+            self.fund_btn.callback = self._fund
+            self.add_item(self.fund_btn)
+
+        async def _fund(self, interaction: discord.Interaction):
+            if self.remaining <= 0 or self.is_finished():
+                await interaction.response.send_message(S.ERR["request_closed"], ephemeral=True)
+                return
+            if interaction.user.id == self.requester.id:
+                await interaction.response.send_message(S.ERR["request_self_fund"], ephemeral=True)
+                return
+            if self.target and interaction.user.id != self.target.id:
+                await interaction.response.send_message(
+                    S.ERR["request_targeted"].format(name=self.target.display_name),
+                    ephemeral=True,
+                )
+                return
+            await interaction.response.send_modal(FundModal(self))
+
+        async def on_timeout(self):
+            for item in self.children:
+                item.disabled = True
+
+    max_request = 1_000_000
+
+    @tree.command(name="request", description=S.CMD["request"])
+    @app_commands.describe(
+        summa=S.OPT["request_summa"],
+        põhjus=S.OPT["request_põhjus"],
+        sihtmärk=S.OPT["request_sihtmärk"],
+    )
+    async def cmd_request(
+        interaction: discord.Interaction,
+        summa: str,
+        põhjus: str,
+        sihtmärk: discord.Member | None = None,
+    ):
+        summa_int, err = parse_amount(summa, 0)
+        if err or summa_int is None:
+            await interaction.response.send_message(err or S.ERR["invalid_amount"], ephemeral=True)
+            return
+        if summa_int <= 0:
+            await interaction.response.send_message(S.ERR["positive_amount"], ephemeral=True)
+            return
+        if summa_int > max_request:
+            await interaction.response.send_message(
+                S.ERR["fund_range"].format(max=coin(max_request)),
+                ephemeral=True,
+            )
+            return
+        summa = summa_int
+        if sihtmärk and sihtmärk.id == interaction.user.id:
+            await interaction.response.send_message(S.ERR["request_self"], ephemeral=True)
+            return
+        if sihtmärk and sihtmärk.bot:
+            await interaction.response.send_message(S.ERR["request_bot"], ephemeral=True)
+            return
+
+        audience = (
+            S.REQUEST_UI["audience_targeted"].format(name=sihtmärk.display_name)
+            if sihtmärk
+            else S.REQUEST_UI["audience_all"]
+        )
+        embed = discord.Embed(
+            title=S.TITLE["request"],
+            description=S.REQUEST_UI["desc"].format(
+                requester=interaction.user.display_name,
+                amount=coin(summa),
+                reason=põhjus,
+                audience=audience,
+            ),
+            color=0xF4C430,
+        )
+        embed.set_footer(text=S.REQUEST_UI["footer"])
+        view = RequestView(interaction.user, summa, sihtmärk)
+        await interaction.response.send_message(embed=embed, view=view)
+        view.message = await interaction.original_response()
+
+    # -- /consumables -------------------------------------------------------
+    def _consumables_embed(user_data: dict) -> discord.Embed:
+        embed = discord.Embed(
+            title=S.CONSUMABLES_UI["title"],
+            description=S.CONSUMABLES_UI["desc"].format(bal=coin(user_data["balance"])),
+            color=0xF4C430,
+        )
+        active = economy.active_buffs(user_data)
+        if active:
+            lines = [
+                S.CONSUMABLES_UI["buff_line"].format(
+                    name=S.CONSUMABLES_UI[f"kind_{kind}"],
+                    time=economy.format_td(economy.buff_remaining(user_data, kind)),
+                )
+                for kind in active
+            ]
+            buff_value = "\n".join(lines)
+        else:
+            buff_value = S.CONSUMABLES_UI["active_none"]
+        embed.add_field(name=S.CONSUMABLES_UI["active_header"], value=buff_value, inline=False)
+        for cons in economy.CONSUMABLES.values():
+            embed.add_field(
+                name=f"{cons['emoji']} {cons['name']}  ·  {cons['cost']} {economy.COIN}",
+                value=cons["description"],
+                inline=False,
+            )
+        return embed
+
+    @tree.command(name="consumables", description=S.CMD["consumables"])
+    @app_commands.describe(ese=S.OPT["consumable_ese"])
+    @app_commands.choices(
+        ese=[
+            app_commands.Choice(name=f"{c['name']} ({c['cost']} TipiCOINi)", value=cid)
+            for cid, c in economy.CONSUMABLES.items()
+        ]
+    )
+    async def cmd_consumables(
+        interaction: discord.Interaction,
+        ese: app_commands.Choice[str] | None = None,
+    ):
+        if ese is None:
+            data = await economy.get_user(interaction.user.id)
+            await interaction.response.send_message(
+                embed=_consumables_embed(data), ephemeral=True
+            )
+            return
+
+        res = await economy.do_buy_consumable(interaction.user.id, ese.value)
+        if not res["ok"]:
+            if res["reason"] == "banned":
+                await interaction.response.send_message(S.MSG_BANNED, ephemeral=True)
+            elif res["reason"] == "insufficient":
+                await interaction.response.send_message(
+                    S.ERR["broke_need"].format(need=coin(res["need"])), ephemeral=True
+                )
+            else:
+                await interaction.response.send_message(S.ERR["item_not_found"], ephemeral=True)
+            return
+
+        cons = res["consumable"]
+        if res["instant"]:
+            desc = S.CONSUMABLES_UI["bought_instant"].format(balance=coin(res["balance"]))
+        else:
+            key = "bought_extended" if res["extended"] else "bought_buff"
+            desc = S.CONSUMABLES_UI[key].format(
+                time=economy.format_td(res["remaining"]),
+                balance=coin(res["balance"]),
+            )
+        embed = discord.Embed(
+            title=S.CONSUMABLES_UI["bought_title"].format(emoji=cons["emoji"], name=cons["name"]),
+            description=desc,
+            color=0x57F287,
+        )
+        await interaction.response.send_message(embed=embed)
+
+    class RemindersSelect(discord.ui.Select):
+        def __init__(self, user_id: int, current: list[str]):
+            self.user_id = user_id
+            options = [
+                discord.SelectOption(
+                    label=label,
+                    description=desc,
+                    value=cmd,
+                    default=cmd in current,
+                )
+                for cmd, label, desc in S.REMINDER_OPTS
+            ]
+            super().__init__(
+                placeholder=S.REMINDERS_UI["select_placeholder"],
+                options=options,
+                min_values=0,
+                max_values=len(S.REMINDER_OPTS),
+            )
+
+        async def callback(self, interaction: discord.Interaction):
+            if interaction.user.id != self.user_id:
+                await interaction.response.send_message(S.ERR["not_your_menu"], ephemeral=True)
+                return
+            await economy.do_set_reminders(self.user_id, self.values)
+            enabled = set(self.values)
+            for cmd in [opt[0] for opt in S.REMINDER_OPTS]:
+                if cmd not in enabled:
+                    cancel_reminder_task(self.user_id, cmd)
+            if self.values:
+                names = "  ".join(f"`/{v}`" for v in self.values)
+                msg = S.REMINDERS_UI["saved_on"].format(names=names)
+            else:
+                msg = S.REMINDERS_UI["saved_off"]
+            await interaction.response.send_message(msg, ephemeral=True)
+
+    class RemindersView(discord.ui.View):
+        def __init__(self, user_id: int, current: list[str]):
+            super().__init__(timeout=60)
+            self.add_item(RemindersSelect(user_id, current))
+
+    @tree.command(name="reminders", description=S.CMD["reminders"])
+    async def cmd_reminders(interaction: discord.Interaction):
+        user_data = await economy.get_user(interaction.user.id)
+        current = user_data.get("reminders", [])
+        if current:
+            status = "  ".join(f"`/{c}`" for c in current)
+            desc = S.REMINDERS_UI["desc_active"].format(status=status)
+        else:
+            desc = S.REMINDERS_UI["desc_none"]
+        embed = discord.Embed(
+            title=S.TITLE["reminders"],
+            description=desc,
+            color=0x5865F2,
+        )
+        embed.set_footer(text=S.REMINDERS_UI["footer"])
+        await interaction.response.send_message(
+            embed=embed,
+            view=RemindersView(interaction.user.id, current),
+            ephemeral=True,
+        )

commands/economy_team_commands.py

@@ -0,0 +1,98 @@
+"""Tournament team-role sync for the economy/community guild.
+
+The tournament participants live in the *economy* (community) guild, not the
+internal dev guild, so team-role assignment runs here rather than as part of the
+member-roster sync in :mod:`commands.dev_member_commands`. This is deliberately
+roster-INDEPENDENT: it matches Discord usernames straight against the separate
+registration spreadsheet (``TEAM_SHEET_ID``) and never touches the member sheet.
+"""
+
+from __future__ import annotations
+
+import logging
+
+import discord
+from discord import app_commands
+
+from core import fienta, sheets
+from core.admin import bot_admin_check
+from core.member_sync import sync_all_team_roles
+import strings as S
+
+
+def register_economy_team_commands(
+    tree: app_commands.CommandTree,
+    bot: discord.Client,
+    log: logging.Logger,
+) -> None:
+    @tree.command(name="teamsync", description=S.CMD["teamsync"])
+    @app_commands.guild_only()
+    @bot_admin_check()
+    async def cmd_teamsync(interaction: discord.Interaction):
+        await interaction.response.defer(ephemeral=True)
+
+        guild = interaction.guild
+        if guild is None:
+            await interaction.followup.send(S.ERR["guild_only"], ephemeral=True)
+            return
+
+        try:
+            rosters = await sheets.refresh_teams()
+            fienta_teams = await fienta.refresh_teams()
+        except Exception as e:
+            await interaction.followup.send(
+                S.TEAMSYNC_UI["refresh_error"].format(error=e), ephemeral=True
+            )
+            return
+        if not rosters and not fienta_teams:
+            await interaction.followup.send(S.TEAMSYNC_UI["disabled"], ephemeral=True)
+            return
+
+        summary = await sync_all_team_roles(guild, log)
+        await interaction.followup.send(_format_summary(summary), ephemeral=True)
+        log.info(
+            "/teamsync - scanned=%d, assigned=%d, removed=%d, created=%d, "
+            "positioned=%d, divider_assigned=%d, divider_removed=%d, errors=%d",
+            summary.scanned,
+            summary.assigned,
+            summary.removed,
+            len(summary.created),
+            summary.positioned,
+            summary.divider_assigned,
+            summary.divider_removed,
+            len(summary.errors),
+        )
+
+
+def _format_summary(summary) -> str:
+    lines = [
+        S.TEAMSYNC_UI["done"],
+        S.TEAMSYNC_UI["scanned"].format(count=summary.scanned),
+        S.TEAMSYNC_UI["assigned"].format(count=summary.assigned),
+        S.TEAMSYNC_UI["removed"].format(count=summary.removed),
+    ]
+    if summary.created:
+        # A team can be created only once, but the same role could surface for
+        # several members in one run - de-dupe for the report.
+        unique = list(dict.fromkeys(summary.created))
+        lines.append(S.TEAMSYNC_UI["created"].format(roles=", ".join(unique)))
+    if summary.positioned:
+        lines.append(S.TEAMSYNC_UI["positioned"].format(count=summary.positioned))
+    if summary.divider_assigned:
+        lines.append(S.TEAMSYNC_UI["divider_assigned"].format(count=summary.divider_assigned))
+    if summary.divider_removed:
+        lines.append(S.TEAMSYNC_UI["divider_removed"].format(count=summary.divider_removed))
+    if summary.errors:
+        lines.append(S.TEAMSYNC_UI["errors"].format(count=len(summary.errors)))
+
+    text = "\n".join(lines)
+
+    if summary.changes:
+        shown = summary.changes[:20]
+        text += "\n\n" + S.TEAMSYNC_UI["changes_header"] + "\n" + "\n".join(shown)
+        if len(summary.changes) > 20:
+            text += "\n" + S.TEAMSYNC_UI["changes_more"].format(count=len(summary.changes) - 20)
+    else:
+        text += "\n\n" + S.TEAMSYNC_UI["no_changes"]
+
+    return text

commands/info_commands.py

@@ -0,0 +1,148 @@
+from __future__ import annotations
+
+import logging
+import re
+from pathlib import Path
+
+import discord
+from discord import app_commands
+
+import strings as S
+
+
+_PATCHNOTES_PATH = Path(__file__).resolve().parent.parent / "docs" / "PATCHNOTES.md"
+_VERSION_RE = re.compile(r"^##\s+(.+?)\s*$")
+_EMBED_DESC_MAX = 4096
+_SELECT_OPTIONS_MAX = 25
+
+
+def _load_versions() -> list[tuple[str, str]]:
+    try:
+        text = _PATCHNOTES_PATH.read_text(encoding="utf-8")
+    except FileNotFoundError:
+        return []
+    versions: list[tuple[str, str]] = []
+    cur_header: str | None = None
+    cur_body: list[str] = []
+    for line in text.splitlines():
+        m = _VERSION_RE.match(line)
+        if m:
+            if cur_header is not None:
+                versions.append((cur_header, "\n".join(cur_body).strip()))
+            cur_header = m.group(1).strip()
+            cur_body = []
+        elif cur_header is not None:
+            cur_body.append(line)
+    if cur_header is not None:
+        versions.append((cur_header, "\n".join(cur_body).strip()))
+    return versions
+
+
+def _build_embed(versions: list[tuple[str, str]], idx: int) -> discord.Embed:
+    header, body = versions[idx]
+    if len(body) > _EMBED_DESC_MAX:
+        body = body[: _EMBED_DESC_MAX - 1] + "…"
+    embed = discord.Embed(
+        title=S.PATCHNOTES_UI["title"].format(version=header),
+        description=body or S.PATCHNOTES_UI["empty_version"],
+        color=0x5865F2,
+    )
+    embed.set_footer(
+        text=S.PATCHNOTES_UI["footer"].format(idx=idx + 1, total=len(versions))
+    )
+    return embed
+
+
+def register_info_commands(
+    tree: app_commands.CommandTree,
+    bot: discord.Client,
+    log: logging.Logger,
+) -> None:
+    @tree.command(name="patchnotes", description=S.CMD["patchnotes"])
+    async def cmd_patchnotes(interaction: discord.Interaction):
+        versions = _load_versions()
+        if not versions:
+            await interaction.response.send_message(
+                S.PATCHNOTES_UI["empty_file"], ephemeral=True
+            )
+            return
+
+        invoker_id = interaction.user.id
+
+        class PatchNotesView(discord.ui.View):
+            def __init__(self, idx: int = 0):
+                super().__init__(timeout=180)
+                self.idx = idx
+                self._rebuild()
+
+            def _rebuild(self):
+                self.clear_items()
+                newer_btn = discord.ui.Button(
+                    label=S.PATCHNOTES_UI["btn_newer"],
+                    style=discord.ButtonStyle.secondary,
+                    disabled=self.idx <= 0,
+                )
+                older_btn = discord.ui.Button(
+                    label=S.PATCHNOTES_UI["btn_older"],
+                    style=discord.ButtonStyle.secondary,
+                    disabled=self.idx >= len(versions) - 1,
+                )
+                newer_btn.callback = self._make_step_cb(-1)
+                older_btn.callback = self._make_step_cb(+1)
+                self.add_item(newer_btn)
+                self.add_item(older_btn)
+
+                opts: list[discord.SelectOption] = []
+                for i, (hdr, _) in enumerate(versions[:_SELECT_OPTIONS_MAX]):
+                    opts.append(
+                        discord.SelectOption(
+                            label=hdr[:100],
+                            value=str(i),
+                            default=(i == self.idx),
+                        )
+                    )
+                if len(opts) > 1:
+                    select = discord.ui.Select(
+                        placeholder=S.PATCHNOTES_UI["select_placeholder"],
+                        options=opts,
+                        min_values=1,
+                        max_values=1,
+                    )
+                    select.callback = self._make_select_cb(select)
+                    self.add_item(select)
+
+            def _make_step_cb(self, delta: int):
+                async def _cb(interaction: discord.Interaction):
+                    if interaction.user.id != invoker_id:
+                        await interaction.response.send_message(
+                            S.ERR["not_your_menu"], ephemeral=True
+                        )
+                        return
+                    self.idx = max(0, min(len(versions) - 1, self.idx + delta))
+                    self._rebuild()
+                    await interaction.response.edit_message(
+                        embed=_build_embed(versions, self.idx), view=self
+                    )
+
+                return _cb
+
+            def _make_select_cb(self, select: discord.ui.Select):
+                async def _cb(interaction: discord.Interaction):
+                    if interaction.user.id != invoker_id:
+                        await interaction.response.send_message(
+                            S.ERR["not_your_menu"], ephemeral=True
+                        )
+                        return
+                    self.idx = int(select.values[0])
+                    self._rebuild()
+                    await interaction.response.edit_message(
+                        embed=_build_embed(versions, self.idx), view=self
+                    )
+
+                return _cb
+
+        view = PatchNotesView(0)
+        await interaction.response.send_message(
+            embed=_build_embed(versions, 0), view=view, ephemeral=True
+        )
+        log.info("/patchnotes by %s (%d versions)", interaction.user, len(versions))

commands/ops_admin_commands.py

@@ -0,0 +1,136 @@
+from __future__ import annotations
+
+import asyncio
+import datetime
+import json
+import logging
+import os
+import subprocess
+import sys
+from collections.abc import Awaitable, Callable
+from pathlib import Path
+
+import discord
+from discord import app_commands
+
+from core.admin import bot_admin_check
+import strings as S
+from core.admin import bot_admin_check
+
+
+def register_ops_admin_commands(
+    tree: app_commands.CommandTree,
+    bot: discord.Client,
+    log: logging.Logger,
+    process,
+    start_time: datetime.datetime,
+    log_dir: Path,
+    guild_obj: discord.Object,
+    restart_file: Path,
+    get_member_cache_size: Callable[[], int],
+    get_paused: Callable[[], bool],
+    set_paused: Callable[[bool], None],
+    count_economy_users: Callable[[], Awaitable[int]],
+) -> None:
+    @tree.command(name="status", description=S.CMD["status"])
+    @app_commands.guild_only()
+    @bot_admin_check()
+    async def cmd_status(interaction: discord.Interaction):
+        mem = process.memory_info()
+        cpu = process.cpu_percent(interval=0.1)
+        uptime = datetime.datetime.now() - start_time
+        hours, rem = divmod(int(uptime.total_seconds()), 3600)
+        minutes, seconds = divmod(rem, 60)
+        tasks_count = len(asyncio.all_tasks())
+        latency_ms = round(bot.latency * 1000, 1)
+        cache_size = get_member_cache_size()
+        user_count = await count_economy_users()
+
+        embed = discord.Embed(title=S.STATUS_UI["title"], color=0x57F287)
+        embed.add_field(
+            name=S.STATUS_UI["uptime_field"],
+            value=S.STATUS_UI["uptime_val"].format(hours=hours, minutes=minutes, seconds=seconds),
+            inline=True,
+        )
+        embed.add_field(
+            name=S.STATUS_UI["latency_field"],
+            value=S.STATUS_UI["latency_val"].format(ms=latency_ms),
+            inline=True,
+        )
+        embed.add_field(
+            name=S.STATUS_UI["ram_field"],
+            value=S.STATUS_UI["ram_val"].format(mb=f"{mem.rss / 1024**2:.1f}"),
+            inline=True,
+        )
+        embed.add_field(
+            name=S.STATUS_UI["cpu_field"],
+            value=S.STATUS_UI["cpu_val"].format(percent=f"{cpu:.1f}"),
+            inline=True,
+        )
+        embed.add_field(
+            name=S.STATUS_UI["tasks_field"],
+            value=str(tasks_count),
+            inline=True,
+        )
+        embed.add_field(
+            name=S.STATUS_UI["eco_players_field"],
+            value=str(user_count),
+            inline=True,
+        )
+        embed.add_field(
+            name=S.STATUS_UI["members_cache_field"],
+            value=str(cache_size),
+            inline=True,
+        )
+
+        log_lines = [
+            S.STATUS_UI["log_line"].format(name=p.name, size_kb=f"{p.stat().st_size / 1024:.1f}")
+            for p in sorted(log_dir.glob("*.log*"))
+            if p.is_file()
+        ]
+        embed.add_field(
+            name=S.STATUS_UI["log_files_field"],
+            value="\n".join(log_lines) or S.STATUS_UI["none"],
+            inline=False,
+        )
+        await interaction.response.send_message(embed=embed, ephemeral=True)
+
+    @tree.command(name="sync", description=S.CMD["sync"])
+    @app_commands.guild_only()
+    @bot_admin_check()
+    async def cmd_sync(interaction: discord.Interaction):
+        await interaction.response.defer(ephemeral=True)
+        tree.copy_global_to(guild=guild_obj)
+        await tree.sync(guild=guild_obj)
+        tree.clear_commands(guild=None)
+        await tree.sync()
+        await interaction.followup.send(S.MSG_SYNC_DONE, ephemeral=True)
+        log.info("/sync triggered by %s", interaction.user)
+
+    @tree.command(name="restart", description=S.CMD["restart"])
+    @app_commands.guild_only()
+    @bot_admin_check()
+    async def cmd_restart(interaction: discord.Interaction):
+        restart_file.write_text(json.dumps({"channel_id": interaction.channel_id}), encoding="utf-8")
+        await interaction.response.send_message(S.MSG_RESTARTING, ephemeral=True)
+        log.info("/restart triggered by %s", interaction.user)
+        subprocess.Popen([sys.executable] + sys.argv, cwd=os.getcwd())
+        await bot.close()
+
+    @tree.command(name="shutdown", description=S.CMD["shutdown"])
+    @app_commands.guild_only()
+    @bot_admin_check()
+    async def cmd_shutdown(interaction: discord.Interaction):
+        await interaction.response.send_message(S.MSG_SHUTTING_DOWN, ephemeral=True)
+        log.info("/shutdown triggered by %s", interaction.user)
+        await bot.close()
+
+    @tree.command(name="pause", description=S.CMD["pause"])
+    @app_commands.guild_only()
+    @bot_admin_check()
+    async def cmd_pause(interaction: discord.Interaction):
+        paused = not get_paused()
+        set_paused(paused)
+        msg = S.MSG_PAUSED if paused else S.MSG_UNPAUSED
+        log.info("/pause toggled → %s by %s", "PAUSED" if paused else "UNPAUSED", interaction.user)
+        await interaction.response.send_message(msg, ephemeral=True)

commands/ops_channel_commands.py

@@ -0,0 +1,135 @@
+from __future__ import annotations
+
+import logging
+from collections.abc import Callable
+
+import discord
+from discord import app_commands
+
+from core import economy
+import strings as S
+
+
+def register_ops_channel_commands(
+    tree: app_commands.CommandTree,
+    bot: discord.Client,
+    log: logging.Logger,
+    get_allowed_channels: Callable[[], list[int]],
+    set_allowed_channels: Callable[[list[int]], None],
+) -> None:
+    @tree.command(name="send", description=S.CMD["send"])
+    @app_commands.guild_only()
+    @app_commands.describe(
+        kanal=S.OPT["send_kanal"],
+        sõnum=S.OPT["send_sõnum"],
+    )
+    @app_commands.default_permissions(manage_guild=True)
+    async def cmd_send(interaction: discord.Interaction, kanal: discord.TextChannel, sõnum: str):
+        try:
+            await kanal.send(sõnum)
+            await interaction.response.send_message(
+                S.SEND_UI["sent"].format(channel=kanal.mention), ephemeral=True
+            )
+        except discord.Forbidden:
+            await interaction.response.send_message(
+                S.SEND_UI["forbidden"].format(channel=kanal.mention), ephemeral=True
+            )
+        except Exception as e:
+            await interaction.response.send_message(
+                S.ERR["send_failed"].format(error=e), ephemeral=True
+            )
+
+    @tree.command(name="economysetup", description=S.CMD["economysetup"])
+    @app_commands.guild_only()
+    @app_commands.default_permissions(manage_guild=True)
+    async def cmd_economysetup(interaction: discord.Interaction):
+        await interaction.response.defer(ephemeral=True)
+        guild = interaction.guild
+        bot_member = guild.get_member(bot.user.id)
+        bot_top_pos = max((r.position for r in bot_member.roles if r.managed), default=1)
+
+        all_role_names = [economy.ECONOMY_ROLE] + [name for _, name in economy.LEVEL_ROLES]
+
+        created, existing = [], []
+        for name in all_role_names:
+            role = discord.utils.find(lambda r, n=name: r.name == n, guild.roles)
+            if role is None:
+                await guild.create_role(name=name, reason="/economysetup")
+                created.append(name)
+            else:
+                existing.append(name)
+
+        positions: dict[discord.Role, int] = {}
+        base = max(bot_top_pos - 1, 1)
+        for i, name in enumerate(all_role_names):
+            role = discord.utils.find(lambda r, n=name: r.name == n, guild.roles)
+            if role:
+                positions[role] = max(base - i, 1)
+        if positions:
+            try:
+                await guild.edit_role_positions(positions=positions)
+            except discord.Forbidden:
+                pass
+
+        embed = discord.Embed(title=S.TITLE["economysetup"], color=0x57F287)
+        if created:
+            embed.add_field(name=S.ECONOMYSETUP_UI["created_field"], value="\n".join(created), inline=True)
+        if existing:
+            embed.add_field(name=S.ECONOMYSETUP_UI["existing_field"], value="\n".join(existing), inline=True)
+        embed.set_footer(text=S.ECONOMYSETUP_UI["footer"])
+        await interaction.followup.send(embed=embed, ephemeral=True)
+        log.info("/economysetup triggered by %s", interaction.user)
+
+    @tree.command(name="allowchannel", description=S.CMD["allowchannel"])
+    @app_commands.guild_only()
+    @app_commands.describe(kanal=S.OPT["allowchannel_kanal"])
+    @app_commands.default_permissions(manage_guild=True)
+    async def cmd_allowchannel(interaction: discord.Interaction, kanal: discord.TextChannel):
+        allowed = get_allowed_channels()
+        if kanal.id in allowed:
+            await interaction.response.send_message(
+                S.CHANNEL_UI["already_allowed"].format(channel=kanal.mention), ephemeral=True
+            )
+            return
+        allowed.append(kanal.id)
+        set_allowed_channels(allowed)
+        log.info("ALLOWCHANNEL +%s by %s", kanal, interaction.user)
+        await interaction.response.send_message(
+            S.CHANNEL_UI["added"].format(channel=kanal.mention), ephemeral=True
+        )
+
+    @tree.command(name="denychannel", description=S.CMD["denychannel"])
+    @app_commands.guild_only()
+    @app_commands.describe(kanal=S.OPT["denychannel_kanal"])
+    @app_commands.default_permissions(manage_guild=True)
+    async def cmd_denychannel(interaction: discord.Interaction, kanal: discord.TextChannel):
+        allowed = get_allowed_channels()
+        if kanal.id not in allowed:
+            await interaction.response.send_message(
+                S.CHANNEL_UI["not_in_list"].format(channel=kanal.mention), ephemeral=True
+            )
+            return
+        allowed.remove(kanal.id)
+        set_allowed_channels(allowed)
+        log.info("DENYCHANNEL -%s by %s", kanal, interaction.user)
+        if allowed:
+            await interaction.response.send_message(
+                S.CHANNEL_UI["removed"].format(channel=kanal.mention), ephemeral=True
+            )
+        else:
+            await interaction.response.send_message(
+                S.CHANNEL_UI["removed_last"].format(channel=kanal.mention), ephemeral=True
+            )
+
+    @tree.command(name="channels", description=S.CMD["channels"])
+    @app_commands.guild_only()
+    @app_commands.default_permissions(manage_guild=True)
+    async def cmd_channels(interaction: discord.Interaction):
+        allowed = get_allowed_channels()
+        if not allowed:
+            desc = S.CHANNEL_UI["list_empty"]
+        else:
+            lines = "\n".join(f"• <#{cid}>" for cid in allowed)
+            desc = S.CHANNEL_UI["list_filled"].format(lines=lines)
+        embed = discord.Embed(title=S.CHANNEL_UI["list_title"], description=desc, color=0x5865F2)
+        await interaction.response.send_message(embed=embed, ephemeral=True)

config.py

@@ -3,14 +3,129 @@ from dotenv import load_dotenv
 
 load_dotenv()
 
-DISCORD_TOKEN = os.getenv("DISCORD_TOKEN")
+BOT_PROFILE = os.getenv("BOT_PROFILE", "dev").strip().lower() or "dev"
+if BOT_PROFILE not in {"dev", "economy"}:
+    raise SystemExit("BOT_PROFILE must be either 'dev' or 'economy'.")
+
+
+def _env_int(name: str, default: int) -> int:
+    raw = os.getenv(name)
+    if raw is None or not raw.strip():
+        return default
+    return int(raw)
+
+
+_LEGACY_DISCORD_TOKEN = os.getenv("DISCORD_TOKEN", "")
+DISCORD_TOKEN_DEV = os.getenv("DISCORD_TOKEN_DEV", "")
+DISCORD_TOKEN_ECONOMY = os.getenv("DISCORD_TOKEN_ECONOMY", "")
+DISCORD_TOKEN = (
+    DISCORD_TOKEN_ECONOMY if BOT_PROFILE == "economy" else DISCORD_TOKEN_DEV
+) or _LEGACY_DISCORD_TOKEN
+
 SHEET_ID = os.getenv("SHEET_ID")
+# Separate spreadsheet holding the tournament team registrations (Team Name +
+# lineup of Discord usernames). Optional: when unset, team-role sync is a no-op.
+TEAM_SHEET_ID = os.getenv("TEAM_SHEET_ID")
 GOOGLE_CREDS_PATH = os.getenv("GOOGLE_CREDS_PATH", "credentials.json")
-GUILD_ID = int(os.getenv("GUILD_ID", "0"))
+
-BIRTHDAY_CHANNEL_ID = int(os.getenv("BIRTHDAY_CHANNEL_ID", "0"))
+# Fienta ticketing: the registration collects each competitor's Discord username
+# (+ sometimes Discord user ID) and team name per ticket, giving a reliable
+# Discord-identity -> team mapping the nickname-only sheet cannot. Primary source
+# for team-role sync; the sheet stays as a fallback. Unset -> Fienta is skipped.
+FIENTA_API_TOKEN = os.getenv("FIENTA_API_TOKEN", "")
+FIENTA_EVENT_ID = os.getenv("FIENTA_EVENT_ID", "")
+
+_LEGACY_GUILD_ID = _env_int("GUILD_ID", 0)
+GUILD_ID_DEV = _env_int("GUILD_ID_DEV", _LEGACY_GUILD_ID)
+GUILD_ID_ECONOMY = _env_int("GUILD_ID_ECONOMY", _LEGACY_GUILD_ID)
+GUILD_ID = GUILD_ID_ECONOMY if BOT_PROFILE == "economy" else GUILD_ID_DEV
+
+_LEGACY_BIRTHDAY_CHANNEL_ID = _env_int("BIRTHDAY_CHANNEL_ID", 0)
+BIRTHDAY_CHANNEL_ID_DEV = _env_int("BIRTHDAY_CHANNEL_ID_DEV", _LEGACY_BIRTHDAY_CHANNEL_ID)
+BIRTHDAY_CHANNEL_ID_ECONOMY = _env_int("BIRTHDAY_CHANNEL_ID_ECONOMY", 0)
+BIRTHDAY_CHANNEL_ID = (
+    BIRTHDAY_CHANNEL_ID_ECONOMY
+    if BOT_PROFILE == "economy"
+    else BIRTHDAY_CHANNEL_ID_DEV
+)
+
 BIRTHDAY_WINDOW_DAYS = int(os.getenv("BIRTHDAY_WINDOW_DAYS", "7"))
 BASE_ROLE_IDS: list[int] = [1478304631930228779, 1478302278862766190]
 
+
+def _parse_admin_roles(raw: str) -> dict[int, set[int]]:
+    """Parse DISCORD_ADMIN_ROLES env var as "guild_id:role_id[:role_id...],guild_id:role_id...".
+
+    Multiple admin roles per guild are colon-separated; guild entries are comma-separated.
+    Repeating a guild_id across entries merges its roles.
+    """
+    result: dict[int, set[int]] = {}
+    for entry in raw.split(","):
+        entry = entry.strip()
+        if not entry:
+            continue
+        parts = entry.split(":")
+        if len(parts) < 2 or not all(p.strip() for p in parts):
+            raise SystemExit(
+                f"DISCORD_ADMIN_ROLES: expected 'guild_id:role_id[:role_id...]', got {entry!r}"
+            )
+        guild_id = int(parts[0].strip())
+        result.setdefault(guild_id, set()).update(int(p.strip()) for p in parts[1:])
+    return result
+
+
+BOT_ADMIN_ROLES: dict[int, set[int]] = _parse_admin_roles(os.getenv("DISCORD_ADMIN_ROLES", ""))
+
+_TEAM_DIVIDER_PREFIX = "TEAM_DIVIDER_"
+
+
+def _parse_team_dividers() -> dict[str, int]:
+    """Collect TEAM_DIVIDER_<SUFFIX> env vars into {suffix: divider role ID}.
+
+    The suffix says which sheet sections the divider covers, the value is the
+    Discord role ID their teams get positioned under:
+
+        TEAM_DIVIDER_CS2_2026=1498736834656604251
+
+    Matching by ID (not name) means renaming the divider role in Discord never
+    breaks positioning. Every underscore-separated part of the suffix must appear
+    in the section's title row, so `CS2_2026` matches only "TipiLAN 2026 CS2
+    Registration Log" while a plain `CS2` would match that section in any year.
+    Defining a var is what switches positioning on for those sections; teams
+    whose section matches nothing are still granted their role, just never moved.
+    """
+    dividers: dict[str, int] = {}
+    for key, value in os.environ.items():
+        if not key.startswith(_TEAM_DIVIDER_PREFIX):
+            continue
+        suffix = key[len(_TEAM_DIVIDER_PREFIX):].strip().lower()
+        raw = value.strip()
+        if not suffix or not raw:
+            continue
+        try:
+            dividers[suffix] = int(raw)
+        except ValueError:
+            raise SystemExit(
+                f"{key}: expected a Discord role ID (integer), got {raw!r}"
+            )
+    return dividers
+
+
+TEAM_DIVIDERS: dict[str, int] = _parse_team_dividers()
+
 PB_URL = os.getenv("PB_URL", "http://127.0.0.1:8090")
 PB_ADMIN_EMAIL = os.getenv("PB_ADMIN_EMAIL", "")
 PB_ADMIN_PASSWORD = os.getenv("PB_ADMIN_PASSWORD", "")
+
+_LEGACY_PB_COLLECTION = os.getenv("PB_ECONOMY_COLLECTION", "").strip()
+PB_ECONOMY_COLLECTION_DEV = (
+    os.getenv("PB_ECONOMY_COLLECTION_DEV", "").strip()
+    or (_LEGACY_PB_COLLECTION if _LEGACY_PB_COLLECTION else "economy_users_dev")
+)
+PB_ECONOMY_COLLECTION_ECONOMY = (
+    os.getenv("PB_ECONOMY_COLLECTION_ECONOMY", "").strip()
+    or (_LEGACY_PB_COLLECTION if _LEGACY_PB_COLLECTION else "economy_users_prod")
+)
+PB_ECONOMY_COLLECTION = (
+    PB_ECONOMY_COLLECTION_ECONOMY if BOT_PROFILE == "economy" else PB_ECONOMY_COLLECTION_DEV
+)

core/admin.py

@@ -0,0 +1,27 @@
+from __future__ import annotations
+
+import discord
+from discord import app_commands
+
+import config
+
+
+def is_bot_admin(member: discord.abc.User | None) -> bool:
+    """True when the member has any of the configured admin roles for their guild."""
+    if not isinstance(member, discord.Member) or member.guild is None:
+        return False
+    admin_role_ids = config.BOT_ADMIN_ROLES.get(member.guild.id)
+    if not admin_role_ids:
+        return False
+    return any(r.id in admin_role_ids for r in member.roles)
+
+
+def bot_admin_check():
+    """Slash-command decorator that gates execution behind ``is_bot_admin``."""
+
+    async def predicate(interaction: discord.Interaction) -> bool:
+        if is_bot_admin(interaction.user):
+            return True
+        raise app_commands.MissingPermissions(["bot_admin_role"])
+
+    return app_commands.check(predicate)

core/economy/__init__.py

@@ -0,0 +1,36 @@
+"""TipiCOIN economy - data layer and business logic.
+
+Storage: PocketBase (see core/pb_client.py). All public async functions are the
+single source of truth for mutations; see store.py for the locking rules.
+
+This package re-exports everything so callers keep using `from core import
+economy` + attribute access.
+"""
+
+from ..pb_client import DatabaseError
+
+from .store import *
+from .store import (
+    _commit, _default_user, _is_jailed, _locked_by, _now, _parse_dt,
+    _prestige_mult, _txn, _user_lock, _user_locks,
+)
+from .house import *
+from .house import _credit_house, _house_record_id
+from .levels import *
+from .shop import *
+from .consumables import *
+from .fishing import *
+from .quests import *
+from .quests import _ensure_quests, _pick_quests, _quest_view
+from .income import *
+from .jail import *
+from .gambling import *
+from .prestige import *
+from .leaderboards import *
+from .heist import *
+from .admin import *
+
+from . import (  # noqa: E402  (submodules addressable as economy.store etc.)
+    admin, consumables, fishing, gambling, heist, house, income, jail,
+    leaderboards, levels, prestige, quests, shop, store,
+)

core/economy/admin.py

@@ -0,0 +1,165 @@
+"""Admin mutations and the season reset."""
+
+from __future__ import annotations
+
+from datetime import timedelta
+
+from .. import pb_client
+from .store import _commit, _default_user, _locked_by, _now, _txn, get_user
+from .levels import get_level
+from .shop import SHOP
+
+
+async def do_season_reset(top_n: int = 10) -> list[tuple[str, int, int]]:
+    """Snapshot top_n by EXP, then full wipe: EXP, balance, items, item_uses.
+    Returns top list (uid, exp, level) captured before the reset."""
+    records = await pb_client.list_all_records()
+    top = sorted(
+        ((r["user_id"], r.get("exp", 0)) for r in records if r.get("user_id")),
+        key=lambda x: x[1],
+        reverse=True,
+    )[:top_n]
+    reset_fields = {
+        "exp": 0,
+        "balance": 0,
+        "items": [],
+        "item_uses": {},
+        "last_daily": None,
+        "last_work": None,
+        "last_beg": None,
+        "last_crime": None,
+        "last_rob": None,
+        "last_fish": None,
+        "daily_streak": 0,
+        "last_streak_date": None,
+        "season_total_exp": 0,
+    }
+    for record in records:
+        await pb_client.update_record(record["id"], reset_fields)
+    return [(uid, exp, get_level(exp)) for uid, exp in top]
+
+
+# ---------------------------------------------------------------------------
+# Admin actions
+# ---------------------------------------------------------------------------
+@_locked_by(0)
+async def do_admin_coins(target_id: int, amount: int, admin_id: int, reason: str) -> dict:
+    """Give (positive) or take (negative) coins from a user. Balance is floored at 0."""
+    user = await get_user(target_id)
+    user["balance"] = max(0, user["balance"] + amount)
+    await _commit(target_id, user)
+    verb = f"+{amount}" if amount >= 0 else str(amount)
+    _txn("ADMIN_COINS", admin=admin_id, target=target_id, amount=verb, reason=reason, bal=user["balance"])
+    return {"ok": True, "balance": user["balance"], "change": amount}
+
+
+@_locked_by(0)
+async def do_admin_jail(target_id: int, minutes: int, admin_id: int, reason: str) -> dict:
+    """Manually jail a user for `minutes` minutes."""
+    user = await get_user(target_id)
+    user["jailed_until"] = (_now() + timedelta(minutes=minutes)).isoformat()
+    user["jailbreak_used"] = False
+    await _commit(target_id, user)
+    _txn("ADMIN_JAIL", admin=admin_id, target=target_id, minutes=minutes, reason=reason)
+    return {"ok": True, "jailed_until": user["jailed_until"]}
+
+
+@_locked_by(0)
+async def do_admin_unjail(target_id: int, admin_id: int) -> dict:
+    """Remove jail from a user."""
+    user = await get_user(target_id)
+    user["jailed_until"] = None
+    user["jailbreak_used"] = False
+    await _commit(target_id, user)
+    _txn("ADMIN_UNJAIL", admin=admin_id, target=target_id)
+    return {"ok": True}
+
+
+@_locked_by(0)
+async def do_admin_ban(target_id: int, admin_id: int, reason: str) -> dict:
+    """Ban a user from all economy commands."""
+    user = await get_user(target_id)
+    user["eco_banned"] = True
+    await _commit(target_id, user)
+    _txn("ADMIN_BAN", admin=admin_id, target=target_id, reason=reason)
+    return {"ok": True}
+
+
+@_locked_by(0)
+async def do_admin_unban(target_id: int, admin_id: int) -> dict:
+    """Lift an economy ban."""
+    user = await get_user(target_id)
+    user["eco_banned"] = False
+    await _commit(target_id, user)
+    _txn("ADMIN_UNBAN", admin=admin_id, target=target_id)
+    return {"ok": True}
+
+
+@_locked_by(0)
+async def do_admin_reset(target_id: int, admin_id: int) -> dict:
+    """Wipe a user's economy data back to defaults."""
+    user = await get_user(target_id)
+    fresh = _default_user()
+    fresh["_pb_id"] = user.get("_pb_id")  # type: ignore[typeddict-unknown-key]
+    await _commit(target_id, fresh)
+    _txn("ADMIN_RESET", admin=admin_id, target=target_id)
+    return {"ok": True}
+
+
+async def do_admin_inspect(target_id: int) -> dict:
+    """Return the user's full raw economy data."""
+    user = await get_user(target_id)
+    return {"ok": True, "data": dict(user)}
+
+
+@_locked_by(0)
+async def do_admin_exp(target_id: int, amount: int, admin_id: int, reason: str) -> dict:
+    """Give (positive) or take (negative) EXP from a user. EXP is floored at 0."""
+    user = await get_user(target_id)
+    old_exp = user.get("exp", 0)
+    old_level = get_level(old_exp)
+    user["exp"] = max(0, old_exp + amount)
+    user["season_total_exp"] = max(0, user.get("season_total_exp", 0) + amount)
+    new_level = get_level(user["exp"])
+    await _commit(target_id, user)
+    verb = f"+{amount}" if amount >= 0 else str(amount)
+    _txn("ADMIN_EXP", admin=admin_id, target=target_id, amount=verb, reason=reason, exp=user["exp"])
+    return {
+        "ok": True,
+        "exp": user["exp"],
+        "change": amount,
+        "old_level": old_level,
+        "new_level": new_level,
+        "level_changed": new_level != old_level,
+    }
+
+
+@_locked_by(0)
+async def do_admin_item(target_id: int, item_id: str, action: str, admin_id: int) -> dict:
+    """Give or remove an item. action='give'|'remove'. Returns ok/reason."""
+    if item_id not in SHOP:
+        return {"ok": False, "reason": "invalid_item"}
+    user = await get_user(target_id)
+    items: list = list(user.get("items") or [])
+    item_uses: dict = dict(user.get("item_uses") or {})
+    if action == "give":
+        if item_id not in items:
+            items.append(item_id)
+        if item_id == "anticheat":
+            item_uses["anticheat"] = 2
+        user["items"] = items
+        user["item_uses"] = item_uses
+        await _commit(target_id, user)
+        _txn("ADMIN_ITEM_GIVE", admin=admin_id, target=target_id, item=item_id)
+        return {"ok": True, "action": "given", "item_id": item_id}
+    elif action == "remove":
+        if item_id not in items:
+            return {"ok": False, "reason": "not_owned"}
+        items.remove(item_id)
+        item_uses.pop(item_id, None)
+        user["items"] = items
+        user["item_uses"] = item_uses
+        await _commit(target_id, user)
+        _txn("ADMIN_ITEM_REMOVE", admin=admin_id, target=target_id, item=item_id)
+        return {"ok": True, "action": "removed", "item_id": item_id}
+    return {"ok": False, "reason": "invalid_action"}

core/economy/consumables.py

@@ -0,0 +1,146 @@
+"""Consumables: repeatable, expiring boosts - a recurring coin sink.
+
+Unlike SHOP items (permanent, bought once), consumables are bought over and
+over. Buying either activates a timed buff (stored in user["active_buffs"] as
+{kind: expiry_iso}) or applies an instant effect, and the coins are destroyed -
+so this keeps the shop relevant, and the economy draining, after a player has
+maxed out permanent gear.
+
+Effect hooks live where the effect belongs:
+  - "earn" buff  -> income.do_work / do_beg / do_crime (via earn_mult)
+  - "exp"  buff  -> levels.award_exp             (via exp_buff_mult)
+  - instant kohv -> handled entirely here (wipes cooldown timestamps)
+"""
+
+from __future__ import annotations
+
+from datetime import timedelta
+from typing import TypedDict
+
+import strings
+
+from ..pb_client import DatabaseError
+from ..emoji import EMOJI as E
+from .store import _commit, _locked_by, _now, _parse_dt, _txn, get_user
+
+
+class Consumable(TypedDict):
+    name: str
+    emoji: str
+    cost: int
+    description: str
+    kind: str          # active_buffs key ("earn"/"exp"), or "instant"
+    duration_min: int  # buff lifetime in minutes (0 for instant effects)
+
+
+CONSUMABLES: dict[str, Consumable] = {
+    "energy_xl": {
+        "name": "Energiajook XL",
+        "emoji": E["TipiBULL"],
+        "cost": 500,
+        "description": strings.CONSUMABLE_DESCRIPTIONS["energy_xl"],
+        "kind": "earn",
+        "duration_min": 60,
+    },
+    "xp_potion": {
+        "name": "XP jook",
+        "emoji": "✨",
+        "cost": 500,
+        "description": strings.CONSUMABLE_DESCRIPTIONS["xp_potion"],
+        "kind": "exp",
+        "duration_min": 60,
+    },
+    "kohv": {
+        "name": "Kohv",
+        "emoji": "☕",
+        "cost": 300,
+        "description": strings.CONSUMABLE_DESCRIPTIONS["kohv"],
+        "kind": "instant",
+        "duration_min": 0,
+    },
+}
+
+# Multiplier granted while a buff of each kind is active.
+_BUFF_MULT: dict[str, float] = {"earn": 2.0, "exp": 2.0}
+
+# Cooldown timestamps an instant "kohv" clears.
+_COOLDOWN_FIELDS = ("last_work", "last_beg", "last_crime", "last_rob", "last_fish")
+
+
+# ---------------------------------------------------------------------------
+# Buff inspection helpers (pure - safe to call while holding a user lock)
+# ---------------------------------------------------------------------------
+def active_buffs(user) -> dict[str, str]:
+    """Return {kind: expiry_iso} for buffs that have not expired yet."""
+    buffs = user.get("active_buffs") or {}
+    now = _now()
+    out: dict[str, str] = {}
+    for kind, expiry in buffs.items():
+        dt = _parse_dt(expiry)
+        if dt is not None and dt > now:
+            out[kind] = expiry
+    return out
+
+
+def buff_remaining(user, kind: str) -> timedelta | None:
+    """Remaining time on a buff kind, or None if it is inactive."""
+    expiry = active_buffs(user).get(kind)
+    if expiry is None:
+        return None
+    return _parse_dt(expiry) - _now()
+
+
+def earn_mult(user) -> float:
+    """Earnings multiplier from an active 'earn' buff (1.0 if none)."""
+    return _BUFF_MULT["earn"] if "earn" in active_buffs(user) else 1.0
+
+
+def exp_buff_mult(user) -> float:
+    """EXP multiplier from an active 'exp' buff (1.0 if none)."""
+    return _BUFF_MULT["exp"] if "exp" in active_buffs(user) else 1.0
+
+
+# ---------------------------------------------------------------------------
+# /consumables purchase
+# ---------------------------------------------------------------------------
+@_locked_by(0)
+async def do_buy_consumable(user_id: int, cons_id: str) -> dict:
+    if cons_id not in CONSUMABLES:
+        return {"ok": False, "reason": "not_found"}
+    try:
+        user = await get_user(user_id)
+    except DatabaseError:
+        return {"ok": False, "reason": "db_error"}
+    if user.get("eco_banned"):
+        return {"ok": False, "reason": "banned"}
+
+    cons = CONSUMABLES[cons_id]
+    if user["balance"] < cons["cost"]:
+        return {"ok": False, "reason": "insufficient", "need": cons["cost"] - user["balance"]}
+
+    user["balance"] -= cons["cost"]
+
+    extended = False
+    if cons["kind"] == "instant":
+        for field in _COOLDOWN_FIELDS:
+            user[field] = None
+    else:
+        buffs = dict(user.get("active_buffs") or {})
+        current = _parse_dt(buffs.get(cons["kind"]))
+        # Stack: extend from the current expiry if still active, else from now.
+        extended = current is not None and current > _now()
+        start = current if extended else _now()
+        buffs[cons["kind"]] = (start + timedelta(minutes=cons["duration_min"])).isoformat()
+        user["active_buffs"] = buffs
+
+    await _commit(user_id, user)
+    _txn("BUY_CONSUMABLE", user=user_id, item=cons_id, cost=f"-{cons['cost']}", bal=user["balance"])
+
+    return {
+        "ok": True,
+        "consumable": cons,
+        "balance": user["balance"],
+        "instant": cons["kind"] == "instant",
+        "extended": extended,
+        "remaining": None if cons["kind"] == "instant" else buff_remaining(user, cons["kind"]),
+    }

core/economy/fishing.py

@@ -0,0 +1,194 @@
+"""Fishing minigame: catalogue, rolls, catch/sell flows."""
+
+from __future__ import annotations
+
+import random
+from datetime import timedelta
+
+from ..pb_client import DatabaseError
+from .store import (
+    COOLDOWNS, _cooldown_remaining, _commit, _is_jailed, _locked_by, _now,
+    _prestige_mult, _txn, get_user,
+)
+
+
+# ---------------------------------------------------------------------------
+# Fish catalogue
+# ---------------------------------------------------------------------------
+FISH_CATALOGUE: dict[str, dict] = {
+    # id: { rarity, weight=(min_g, max_g), coins=(min, max), exp }
+    "sarj":     {"rarity": "common",   "weight": (50,    500),  "coins": (3,   18),  "exp": 3},
+    "ahven":    {"rarity": "common",   "weight": (80,    700),  "coins": (5,   22),  "exp": 3},
+    "koger":    {"rarity": "common",   "weight": (100,   800),  "coins": (5,   20),  "exp": 3},
+    "viidikas": {"rarity": "common",   "weight": (10,    120),  "coins": (2,    8),  "exp": 2},
+    "latikas":  {"rarity": "uncommon", "weight": (300,  2500),  "coins": (20,  70),  "exp": 6},
+    "karpkala": {"rarity": "uncommon", "weight": (500,  4000),  "coins": (25,  80),  "exp": 7},
+    "linask":   {"rarity": "uncommon", "weight": (200,  2000),  "coins": (18,  60),  "exp": 6},
+    "haug":     {"rarity": "rare",     "weight": (500,  6000),  "coins": (50, 180),  "exp": 10},
+    "angerjas": {"rarity": "rare",     "weight": (200,  1800),  "coins": (40, 120),  "exp": 10},
+    "siig":     {"rarity": "rare",     "weight": (200,  2000),  "coins": (45, 130),  "exp": 10},
+    "forell":   {"rarity": "epic",     "weight": (400,  4500),  "coins": (100, 280), "exp": 15},
+    "koha":     {"rarity": "epic",     "weight": (600,  7000),  "coins": (120, 300), "exp": 15},
+    "tougjas":  {"rarity": "epic",     "weight": (400,  4000),  "coins": (90,  250), "exp": 14},
+    "lohe":     {"rarity": "legendary","weight": (1500, 12000), "coins": (250, 700), "exp": 25},
+    "vimb":     {"rarity": "legendary","weight": (200,  1200),  "coins": (200, 600), "exp": 25},
+}
+
+FISH_RARITY_WEIGHTS: dict[str, int] = {
+    "junk":      15,
+    "common":    45,
+    "uncommon":  22,
+    "rare":      12,
+    "epic":       5,
+    "legendary":  1,
+}
+
+
+def roll_fish(rarity_bump: bool = False) -> tuple[str, int]:
+    """Roll a random fish. Returns (fish_id, weight_grams) or ('junk', 0).
+    rarity_bump=True (kalavork item) shifts each catch one tier up.
+    """
+    rarity_pool = list(FISH_RARITY_WEIGHTS.keys())
+    weights = list(FISH_RARITY_WEIGHTS.values())
+    chosen_rarity = random.choices(rarity_pool, weights=weights)[0]
+    if chosen_rarity == "junk":
+        return ("junk", 0)
+    if rarity_bump:
+        order = ["common", "uncommon", "rare", "epic", "legendary"]
+        idx = order.index(chosen_rarity) if chosen_rarity in order else 0
+        chosen_rarity = order[min(idx + 1, len(order) - 1)]
+    fish_of_rarity = [k for k, v in FISH_CATALOGUE.items() if v["rarity"] == chosen_rarity]
+    if not fish_of_rarity:
+        return ("junk", 0)
+    fish_id = random.choice(fish_of_rarity)
+    fish = FISH_CATALOGUE[fish_id]
+    weight = random.randint(fish["weight"][0], fish["weight"][1])
+    return (fish_id, weight)
+
+
+# ---------------------------------------------------------------------------
+# /fish
+# ---------------------------------------------------------------------------
+@_locked_by(0)
+async def do_fish_start(user_id: int) -> dict:
+    """Check cooldown + jail, set cooldown. Call before starting the fishing minigame."""
+    try:
+        user = await get_user(user_id)
+    except DatabaseError:
+        return {"ok": False, "reason": "db_error"}
+    if user.get("eco_banned"):
+        return {"ok": False, "reason": "banned"}
+    if jail := _is_jailed(user):
+        return {"ok": False, "reason": "jailed", "remaining": jail}
+
+    fish_cd = timedelta(seconds=90) if "ussipurk" in user["items"] else COOLDOWNS["fish"]
+    if cd := _cooldown_remaining(user, "fish", override_cd=fish_cd):
+        return {"ok": False, "reason": "cooldown", "remaining": cd}
+
+    user["last_fish"] = _now().isoformat()
+    await _commit(user_id, user)
+    return {"ok": True}
+
+
+@_locked_by(0)
+async def do_fish_resolve(user_id: int, fish_id: str, weight: int) -> dict:
+    """Add catch to inventory + update fish_book. Returns catch info incl. pre-calculated value."""
+    user = await get_user(user_id)
+
+    if fish_id == "junk":
+        _txn("FISH_JUNK", user=user_id)
+        return {"ok": True, "type": "junk", "coins": 0, "exp": 0}
+
+    if fish_id not in FISH_CATALOGUE:
+        return {"ok": False, "reason": "invalid_fish"}
+
+    fish = FISH_CATALOGUE[fish_id]
+    min_c, max_c = fish["coins"]
+    w_min, w_max = fish["weight"]
+    weight_ratio = (weight - w_min) / max(1, w_max - w_min)
+    base_coins = int(min_c + weight_ratio * (max_c - min_c))
+    coin_mult, _ = _prestige_mult(user)
+    value = int(base_coins * coin_mult)
+    exp = fish["exp"]
+
+    book: dict = user.get("fish_book") or {}
+    prev_count = book.get(fish_id, 0)
+    book[fish_id] = prev_count + 1
+    user["fish_book"] = book
+    user["total_fish_caught"] = user.get("total_fish_caught", 0) + 1
+
+    inv: list = list(user.get("fish_inventory") or [])
+    inv.append({"fish_id": fish_id, "weight": weight, "value": value})
+    user["fish_inventory"] = inv
+
+    await _commit(user_id, user)
+    _txn("FISH", user=user_id, fish=fish_id, weight=weight, value=value)
+
+    return {
+        "ok": True,
+        "type": "fish",
+        "fish_id": fish_id,
+        "weight": weight,
+        "value": value,
+        "exp": exp,
+        "is_new": prev_count == 0,
+        "total_caught": book[fish_id],
+    }
+
+
+@_locked_by(0)
+async def do_fish_sell(user_id: int, indices: list[int] | None = None) -> dict:
+    """Sell fish from inventory. indices=None sells all. Returns coins earned."""
+    user = await get_user(user_id)
+    inv: list = list(user.get("fish_inventory") or [])
+    if not inv:
+        return {"ok": False, "reason": "empty"}
+
+    if indices is None:
+        to_sell = inv
+        remaining = []
+    else:
+        sell_idx = {
+            (i if i >= 0 else len(inv) + i)
+            for i in indices
+        }
+        sell_idx = {i for i in sell_idx if 0 <= i < len(inv)}
+        to_sell = [inv[i] for i in sorted(sell_idx)]
+        keep_idx = set(range(len(inv))) - sell_idx
+        remaining = [inv[i] for i in sorted(keep_idx)]
+
+    if not to_sell:
+        return {"ok": False, "reason": "empty"}
+
+    total_coins = sum(entry["value"] for entry in to_sell)
+    user["fish_inventory"] = remaining
+    user["balance"] = user.get("balance", 0) + total_coins
+    user["lifetime_earned"] = user.get("lifetime_earned", 0) + total_coins
+    user["peak_balance"] = max(user.get("peak_balance", 0), user["balance"])
+    await _commit(user_id, user)
+    _txn("FISH_SELL", user=user_id, count=len(to_sell), coins=f"+{total_coins}", bal=user["balance"])
+    return {
+        "ok": True,
+        "coins": total_coins,
+        "count": len(to_sell),
+        "balance": user["balance"],
+    }
+
+
+async def do_fishbook(user_id: int) -> dict:
+    """Return the user's fish book data including per-species inventory counts."""
+    user = await get_user(user_id)
+    book: dict = user.get("fish_book") or {}
+    inv: list = user.get("fish_inventory") or []
+    inv_counts: dict[str, int] = {}
+    for entry in inv:
+        fid = entry.get("fish_id", "")
+        inv_counts[fid] = inv_counts.get(fid, 0) + 1
+    return {
+        "ok": True,
+        "book": book,
+        "inv_counts": inv_counts,
+        "total_fish_caught": user.get("total_fish_caught", 0),
+        "unique_caught": len(book),
+        "total_species": len(FISH_CATALOGUE),
+    }

core/economy/gambling.py

@@ -0,0 +1,275 @@
+"""Casino games: roulette, slots, RPS bets and escrow, blackjack."""
+
+from __future__ import annotations
+
+import random
+
+from ..pb_client import DatabaseError
+from ..emoji import EMOJI as E
+from .store import _commit, _is_jailed, _locked_by, _txn, get_user
+from .house import _credit_house
+
+
+# ---------------------------------------------------------------------------
+# /roulette
+# ---------------------------------------------------------------------------
+@_locked_by(0)
+async def do_roulette(user_id: int, bet: int, colour: str) -> dict:
+    try:
+        user = await get_user(user_id)
+    except DatabaseError:
+        return {"ok": False, "reason": "db_error"}
+    if user.get("eco_banned"):
+        return {"ok": False, "reason": "banned"}
+    if jail := _is_jailed(user):
+        return {"ok": False, "reason": "jailed", "remaining": jail}
+
+    if user["balance"] < bet:
+        return {"ok": False, "reason": "insufficient"}
+
+    # Wheel: 18 red, 18 black, 1 green (37 slots - real roulette proportions)
+    result = random.choices(["punane", "must", "roheline"], weights=[18, 18, 1])[0]
+    won = result == colour
+    mult = 14 if colour == "roheline" else 1
+    change = bet * mult if won else -bet
+    user["balance"] = max(0, user["balance"] + change)
+    user["total_wagered"] = user.get("total_wagered", 0) + bet
+    if won:
+        user["lifetime_earned"] = user.get("lifetime_earned", 0) + abs(change)
+        user["biggest_win"] = max(user.get("biggest_win", 0), abs(change))
+        user["peak_balance"] = max(user.get("peak_balance", 0), user["balance"])
+    else:
+        user["lifetime_lost"] = user.get("lifetime_lost", 0) + bet
+        user["biggest_loss"] = max(user.get("biggest_loss", 0), bet)
+    await _commit(user_id, user)
+    if not won:
+        await _credit_house(bet)
+    _txn("ROULETTE_" + ("WIN" if won else "LOSE"), user=user_id, bet=bet, colour=colour, result=result, mult=mult, bal=user["balance"])
+
+    return {
+        "ok": True, "won": won,
+        "result": result, "change": abs(change), "mult": mult,
+        "balance": user["balance"],
+    }
+
+
+# ---------------------------------------------------------------------------
+# /rps (bet resolution)
+# ---------------------------------------------------------------------------
+@_locked_by(0)
+async def do_game_bet(user_id: int, bet: int, outcome: str) -> dict:
+    """Settle a simple win/tie/lose bet.  outcome: 'win' | 'tie' | 'lose'."""
+    try:
+        user = await get_user(user_id)
+    except DatabaseError:
+        return {"ok": False, "reason": "db_error"}
+    if user.get("eco_banned"):
+        return {"ok": False, "reason": "banned"}
+    if jail := _is_jailed(user):
+        return {"ok": False, "reason": "jailed", "remaining": jail}
+    if user["balance"] < bet:
+        return {"ok": False, "reason": "insufficient"}
+    user["total_wagered"] = user.get("total_wagered", 0) + bet
+    if outcome == "win":
+        user["balance"] += bet
+        user["lifetime_earned"] = user.get("lifetime_earned", 0) + bet
+        user["biggest_win"] = max(user.get("biggest_win", 0), bet)
+        user["peak_balance"] = max(user.get("peak_balance", 0), user["balance"])
+    elif outcome == "lose":
+        user["balance"] = max(0, user["balance"] - bet)
+        user["lifetime_lost"] = user.get("lifetime_lost", 0) + bet
+        user["biggest_loss"] = max(user.get("biggest_loss", 0), bet)
+    # tie: no change
+    await _commit(user_id, user)
+    if outcome == "lose" and bet > 0:
+        await _credit_house(bet)
+    _txn("RPS_" + outcome.upper(), user=user_id, bet=bet, bal=user["balance"])
+    return {"ok": True, "balance": user["balance"]}
+
+
+# ---------------------------------------------------------------------------
+# /rps PvP escrow (deposit/payout/refund)
+# ---------------------------------------------------------------------------
+@_locked_by(0)
+async def do_rps_pvp_deposit(user_id: int, bet: int) -> dict:
+    """Hold `bet` coins from a player as escrow for a PvP RPS duel."""
+    try:
+        user = await get_user(user_id)
+    except DatabaseError:
+        return {"ok": False, "reason": "db_error"}
+    if user.get("eco_banned"):
+        return {"ok": False, "reason": "banned"}
+    if jail := _is_jailed(user):
+        return {"ok": False, "reason": "jailed", "remaining": jail}
+    if user["balance"] < bet:
+        return {"ok": False, "reason": "insufficient"}
+    user["balance"] -= bet
+    user["total_wagered"] = user.get("total_wagered", 0) + bet
+    try:
+        await _commit(user_id, user)
+    except DatabaseError:
+        return {"ok": False, "reason": "db_error"}
+    _txn("RPS_PVP_DEPOSIT", user=user_id, bet=bet, bal=user["balance"])
+    return {"ok": True, "balance": user["balance"]}
+
+
+@_locked_by(0)
+async def do_rps_pvp_payout(winner_id: int, bet: int) -> dict:
+    """Credit the duel winner with 2*bet (their stake back + opponent's)."""
+    try:
+        user = await get_user(winner_id)
+    except DatabaseError:
+        return {"ok": False, "reason": "db_error"}
+    payout = bet * 2
+    user["balance"] = user.get("balance", 0) + payout
+    user["lifetime_earned"] = user.get("lifetime_earned", 0) + bet
+    user["biggest_win"] = max(user.get("biggest_win", 0), bet)
+    user["peak_balance"] = max(user.get("peak_balance", 0), user["balance"])
+    try:
+        await _commit(winner_id, user)
+    except DatabaseError:
+        return {"ok": False, "reason": "db_error"}
+    _txn("RPS_PVP_PAYOUT", user=winner_id, payout=f"+{payout}", bal=user["balance"])
+    return {"ok": True, "balance": user["balance"]}
+
+
+@_locked_by(0)
+async def do_rps_pvp_refund(user_id: int, bet: int) -> dict:
+    """Refund a previously escrowed bet (tie / timeout / cancel)."""
+    try:
+        user = await get_user(user_id)
+    except DatabaseError:
+        return {"ok": False, "reason": "db_error"}
+    user["balance"] = user.get("balance", 0) + bet
+    user["total_wagered"] = max(0, user.get("total_wagered", 0) - bet)
+    try:
+        await _commit(user_id, user)
+    except DatabaseError:
+        return {"ok": False, "reason": "db_error"}
+    _txn("RPS_PVP_REFUND", user=user_id, bet=bet, bal=user["balance"])
+    return {"ok": True, "balance": user["balance"]}
+
+
+# ---------------------------------------------------------------------------
+# /slots
+# ---------------------------------------------------------------------------
+_SLOTS_SYMBOLS: list[tuple[str, int]] = [
+    (E["TipiHEART"],   27),
+    (E["TipiFIRE"],    22),
+    (E["TipiTROLL"],   18),
+    (E["TipICRY"],     15),
+    (E["TipiSKULL"],   10),
+    (E["TipiKARIKAS"],  8),
+]
+_SLOTS_JACKPOT = E["TipiKARIKAS"]
+_SLOTS_TRIPLE_MULT: dict[str, int] = {
+    E["TipiHEART"]:   4,
+    E["TipiFIRE"]:    5,
+    E["TipiTROLL"]:   7,
+    E["TipICRY"]:    10,
+    E["TipiSKULL"]:  15,
+    E["TipiKARIKAS"]: 25,  # jackpot
+}
+
+
+def _spin() -> str:
+    symbols, weights = zip(*_SLOTS_SYMBOLS)
+    return random.choices(list(symbols), weights=list(weights), k=1)[0]
+
+
+@_locked_by(0)
+async def do_slots(user_id: int, bet: int) -> dict:
+    try:
+        user = await get_user(user_id)
+    except DatabaseError:
+        return {"ok": False, "reason": "db_error"}
+    if user.get("eco_banned"):
+        return {"ok": False, "reason": "banned"}
+    if jail := _is_jailed(user):
+        return {"ok": False, "reason": "jailed", "remaining": jail}
+    if user["balance"] < bet:
+        return {"ok": False, "reason": "insufficient"}
+
+    reels = [_spin(), _spin(), _spin()]
+    a, b, c = reels
+
+    has_360 = "monitor_360" in user["items"]
+    if a == b == c:
+        tier = "jackpot" if a == _SLOTS_JACKPOT else "triple"
+        base_mult = _SLOTS_TRIPLE_MULT.get(a, 4)
+        mult = int(base_mult * 1.5) if has_360 else base_mult
+        change = bet * (mult - 1)
+    elif a == b or b == c or a == c:
+        tier = "pair"
+        change = bet // 2
+    else:
+        tier = "miss"
+        change = -bet
+
+    user["balance"] = max(0, user["balance"] + change)
+    user["total_wagered"] = user.get("total_wagered", 0) + bet
+    if tier in ("jackpot", "triple", "pair"):
+        user["lifetime_earned"] = user.get("lifetime_earned", 0) + change
+        user["biggest_win"] = max(user.get("biggest_win", 0), change)
+        user["peak_balance"] = max(user.get("peak_balance", 0), user["balance"])
+        if tier == "jackpot":
+            user["slots_jackpots"] = user.get("slots_jackpots", 0) + 1
+    else:
+        user["lifetime_lost"] = user.get("lifetime_lost", 0) + bet
+        user["biggest_loss"] = max(user.get("biggest_loss", 0), bet)
+    await _commit(user_id, user)
+    if tier == "miss":
+        await _credit_house(bet)
+    _txn("SLOTS_" + tier.upper(), user=user_id, bet=bet, change=change, bal=user["balance"])
+
+    return {
+        "ok": True,
+        "reels": reels,
+        "tier": tier,
+        "change": change,
+        "balance": user["balance"],
+    }
+
+
+# ---------------------------------------------------------------------------
+# /blackjack
+# ---------------------------------------------------------------------------
+@_locked_by(0)
+async def do_blackjack_bet(user_id: int, bet: int) -> dict:
+    """Deduct the initial blackjack bet. Returns ok/fail."""
+    try:
+        user = await get_user(user_id)
+    except DatabaseError:
+        return {"ok": False, "reason": "db_error"}
+    if user.get("eco_banned"):
+        return {"ok": False, "reason": "banned"}
+    if jail := _is_jailed(user):
+        return {"ok": False, "reason": "jailed", "remaining": jail}
+    if user["balance"] < bet:
+        return {"ok": False, "reason": "insufficient", "balance": user["balance"]}
+    user["balance"] -= bet
+    await _commit(user_id, user)
+    return {"ok": True, "balance": user["balance"]}
+
+
+@_locked_by(0)
+async def do_blackjack_payout(user_id: int, payout: int, total_invested: int = 0) -> dict:
+    """Credit the net payout. House receives the difference when payout < total_invested."""
+    user = await get_user(user_id)
+    user["balance"] += payout
+    user["balance"] = max(0, user["balance"])
+    user["total_wagered"] = user.get("total_wagered", 0) + total_invested
+    net = payout - total_invested
+    if net > 0:
+        user["lifetime_earned"] = user.get("lifetime_earned", 0) + net
+        user["biggest_win"] = max(user.get("biggest_win", 0), net)
+        user["peak_balance"] = max(user.get("peak_balance", 0), user["balance"])
+    elif net < 0:
+        user["lifetime_lost"] = user.get("lifetime_lost", 0) + abs(net)
+        user["biggest_loss"] = max(user.get("biggest_loss", 0), abs(net))
+    await _commit(user_id, user)
+    house_gain = total_invested - payout
+    if house_gain > 0:
+        await _credit_house(house_gain)
+    _txn("BLACKJACK", user=user_id, payout=f"{payout:+}", net=f"{net:+}", bal=user["balance"])
+    return {"ok": True, "balance": user["balance"]}

core/economy/heist.py

@@ -0,0 +1,103 @@
+"""Bank heist: group robbery of the house."""
+
+from __future__ import annotations
+
+import random
+
+from .. import pb_client
+from ..pb_client import DatabaseError
+from . import house
+from .store import HEIST_JAIL, _commit, _is_jailed, _now, _txn, _user_lock, get_user
+from .house import _credit_house, _refund_house_safe, _refund_user_safe
+
+
+# ---------------------------------------------------------------------------
+# /heist
+# ---------------------------------------------------------------------------
+
+async def do_heist_check(user_id: int) -> dict:
+    """Check whether a user is eligible to join a heist."""
+    try:
+        user = await get_user(user_id)
+    except DatabaseError:
+        return {"ok": False, "reason": "db_error"}
+    if user.get("eco_banned"):
+        return {"ok": False, "reason": "banned"}
+    if jail := _is_jailed(user):
+        return {"ok": False, "reason": "jailed", "remaining": jail}
+    return {"ok": True}
+
+
+async def do_heist_resolve(user_ids: list[int], success: bool) -> dict:
+    """Apply heist outcome to all participants. On win, steals from house.
+
+    Per-user commit failures attempt to compensate the house so the economy
+    stays balanced. If compensation also fails, a CRITICAL log is emitted.
+    """
+    now = _now()
+    payout_each = 0
+    failed_users: list[int] = []
+
+    if success and house.HOUSE_ID is not None:
+        # NB: use a distinct local name - assigning to `house` here would shadow
+        # the imported module for the whole function and break `house.HOUSE_ID`.
+        try:
+            house_rec = await get_user(house.HOUSE_ID)
+            pct = random.uniform(0.20, 0.55)
+            # Never promise more than the house actually holds: the desired pot
+            # is capped at the current balance, and each share is floored, so the
+            # amount debited equals the amount paid out (no minting, no leak).
+            pot = min(max(300, int(house_rec["balance"] * pct)), house_rec["balance"])
+            pot = max(0, pot)
+            payout_each = pot // len(user_ids)
+            debit = payout_each * len(user_ids)
+            # Atomic decrement instead of a full record commit, so concurrent
+            # _credit_house increments aren't lost.
+            if debit > 0:
+                await pb_client.update_record(house_rec["_pb_id"], {"balance-": debit})  # type: ignore[typeddict-item]
+        except DatabaseError:
+            return {"ok": False, "reason": "db_error"}
+        _txn("HEIST_HOUSE", change=f"-{debit}", house_bal=house_rec["balance"] - debit)
+
+    for uid in user_ids:
+        async with _user_lock(uid):
+            try:
+                user = await get_user(uid)
+            except DatabaseError:
+                failed_users.append(uid)
+                if success and payout_each > 0:
+                    await _refund_house_safe(payout_each, "heist_win_compensate", uid)
+                continue
+            user["last_heist"] = now.isoformat()
+            user["heists_joined"] = user.get("heists_joined", 0) + 1
+            fine_credited = False
+            if success:
+                user["balance"] += payout_each
+                user["heists_won"] = user.get("heists_won", 0) + 1
+                user["lifetime_earned"] = user.get("lifetime_earned", 0) + payout_each
+                user["peak_balance"] = max(user.get("peak_balance", 0), user["balance"])
+                _txn("HEIST_WIN", user=uid, change=f"+{payout_each}", bal=user["balance"])
+            else:
+                fine = max(150, min(1000, int(user["balance"] * 0.15)))
+                user["balance"] = max(0, user["balance"] - fine)
+                user["jailed_until"] = (now + HEIST_JAIL).isoformat()
+                user["jailbreak_used"] = False
+                user["times_jailed"] = user.get("times_jailed", 0) + 1
+                user["lifetime_lost"] = user.get("lifetime_lost", 0) + fine
+                _txn("HEIST_FAIL", user=uid, fine=f"-{fine}", jailed_until=user["jailed_until"], bal=user["balance"])
+                if fine > 0:
+                    try:
+                        await _credit_house(fine)
+                        fine_credited = True
+                    except DatabaseError:
+                        pass  # user commit will still be attempted; if both fail, no economy effect
+            try:
+                await _commit(uid, user)
+            except DatabaseError:
+                failed_users.append(uid)
+                if success and payout_each > 0:
+                    await _refund_house_safe(payout_each, "heist_win_compensate", uid)
+                elif not success and fine_credited:
+                    await _refund_user_safe(house.HOUSE_ID, fine if 'fine' in locals() else 0, "heist_fail_compensate", uid)
+
+    return {"ok": True, "payout_each": payout_each, "success": success, "failed_users": failed_users}

core/economy/house.py

@@ -0,0 +1,91 @@
+"""House account: the bot's own balance, fed by fines and lost bets."""
+
+from __future__ import annotations
+
+from .. import pb_client
+from ..pb_client import DatabaseError
+from .store import _log, _now, get_user, _commit
+
+
+# ---------------------------------------------------------------------------
+# House account (bot user)
+# ---------------------------------------------------------------------------
+HOUSE_ID: int | None = None
+_house_pb_id: str | None = None
+
+
+def set_house(user_id: int) -> None:
+    """Register the bot's Discord user ID as the house account."""
+    global HOUSE_ID, _house_pb_id
+    if HOUSE_ID != user_id:
+        _house_pb_id = None
+    HOUSE_ID = user_id
+
+
+async def _house_record_id() -> str | None:
+    """PocketBase record id of the house account (cached; creates the record on first use)."""
+    global _house_pb_id
+    if HOUSE_ID is None:
+        return None
+    if _house_pb_id is None:
+        house = await get_user(HOUSE_ID)
+        _house_pb_id = house.get("_pb_id")  # type: ignore[typeddict-item]
+    return _house_pb_id
+
+
+async def _credit_house(amount: int) -> None:
+    """Add `amount` coins to the house via an atomic PocketBase increment.
+
+    Deliberately lock-free: callers hold per-user locks, so this must never
+    acquire one itself (see the locking rules above)."""
+    if amount <= 0:
+        return
+    record_id = await _house_record_id()
+    if record_id is None:
+        return
+    await pb_client.update_record(record_id, {"balance+": amount})
+
+
+async def get_heist_global_cd() -> float:
+    """Return unix timestamp until which no new heist can start. Persisted on house record."""
+    if HOUSE_ID is None:
+        return 0.0
+    house = await get_user(HOUSE_ID)
+    return float(house.get("heist_global_cd_until") or 0)
+
+
+async def set_heist_global_cd(until: float) -> None:
+    """Persist heist global cooldown expiry to the house account in PocketBase."""
+    record_id = await _house_record_id()
+    if record_id is None:
+        return
+    await pb_client.update_record(record_id, {"heist_global_cd_until": until})
+
+
+async def _refund_house_safe(amount: int, context: str, related_uid: int) -> None:
+    """Best-effort refund of `amount` to the house. Logs critical if it fails."""
+    if HOUSE_ID is None or amount <= 0:
+        return
+    try:
+        await _credit_house(amount)
+    except DatabaseError as exc:
+        _log.critical(
+            "House compensation failed (%s, related uid %s, amount %s): %s",
+            context, related_uid, amount, exc,
+        )
+
+
+async def _refund_user_safe(_unused_house_id, amount: int, context: str, uid: int) -> None:
+    """Best-effort atomic debit of `amount` from the house (compensates a failed
+    user fine). Logs critical if it fails."""
+    if HOUSE_ID is None or amount <= 0:
+        return
+    try:
+        record_id = await _house_record_id()
+        if record_id:
+            await pb_client.update_record(record_id, {"balance-": amount})
+    except DatabaseError as exc:
+        _log.critical(
+            "House debit compensation failed (%s, related uid %s, amount %s): %s",
+            context, uid, amount, exc,
+        )

core/economy/income.py

@@ -0,0 +1,405 @@
+"""Income and social commands: daily, work, beg, crime, rob, give."""
+
+from __future__ import annotations
+
+import random
+from datetime import date, timedelta
+
+import strings
+
+from ..pb_client import DatabaseError
+from . import house
+from .store import (
+    COOLDOWNS, JAIL_DURATION, PRESTIGE_SHOP, _commit, _cooldown_remaining,
+    _is_jailed, _locked_by, _log, _now, _prestige_mult, _txn, get_user,
+)
+from .house import _credit_house
+from .consumables import earn_mult
+
+
+# ---------------------------------------------------------------------------
+# /daily
+# ---------------------------------------------------------------------------
+@_locked_by(0)
+async def do_daily(user_id: int) -> dict:
+    try:
+        user = await get_user(user_id)
+    except DatabaseError:
+        return {"ok": False, "reason": "db_error"}
+    if user.get("eco_banned"):
+        return {"ok": False, "reason": "banned"}
+
+    daily_cd = timedelta(hours=18) if "korvaklapid" in user["items"] else COOLDOWNS["daily"]
+    if cd := _cooldown_remaining(user, "daily", override_cd=daily_cd):
+        return {"ok": False, "reason": "cooldown", "remaining": cd}
+
+    today = _now().date()
+    last_str = user.get("last_streak_date")
+    last_date = date.fromisoformat(last_str) if last_str else None
+
+    if last_date is None:
+        streak = 1
+    elif (today - last_date).days == 1:
+        streak = user["daily_streak"] + 1
+    elif "karikas" in user["items"]:
+        streak = user["daily_streak"]  # karikas: streak survives missed days
+    else:
+        streak = 1  # streak broken
+
+    # Streak multiplier tiers
+    if streak >= 14:
+        streak_mult = 3.0
+    elif streak >= 7:
+        streak_mult = 2.0
+    elif streak >= 3:
+        streak_mult = 1.5
+    else:
+        streak_mult = 1.0
+
+    vip = "lan_pass" in user["items"]
+    vip_mult = 2.0 if vip else 1.0
+
+    daily_plus_level = (user.get("prestige_upgrades") or {}).get("daily_plus", 0)
+    base = int(150 * (1.0 + daily_plus_level * PRESTIGE_SHOP["daily_plus"]["effect"]))
+    earned = int(base * streak_mult * vip_mult)
+    if "korvaklapid" in user["items"]:
+        earned += 25
+    coin_mult, _ = _prestige_mult(user)
+    earned = int(earned * coin_mult)
+
+    # Investor interest (capped at 500/day to prevent runaway wealth)
+    interest = 0
+    if "gaming_laptop" in user["items"] and user["balance"] > 0:
+        interest = min(int(user["balance"] * 0.05), 500)
+        earned += interest
+
+    user["balance"] += earned
+    user["last_daily"] = _now().isoformat()
+    user["daily_streak"] = streak
+    user["last_streak_date"] = today.isoformat()
+    user["lifetime_earned"] = user.get("lifetime_earned", 0) + earned
+    user["best_daily_streak"] = max(user.get("best_daily_streak", 0), streak)
+    user["peak_balance"] = max(user.get("peak_balance", 0), user["balance"])
+    await _commit(user_id, user)
+    _txn("DAILY", user=user_id, earned=f"+{earned}", streak=streak, bal=user["balance"])
+
+    return {
+        "ok": True,
+        "earned": earned,
+        "interest": interest,
+        "streak": streak,
+        "streak_mult": streak_mult,
+        "vip": vip,
+        "balance": user["balance"],
+    }
+
+
+# ---------------------------------------------------------------------------
+# /work
+# ---------------------------------------------------------------------------
+_WORK_JOBS = strings.WORK_JOBS
+
+
+@_locked_by(0)
+async def do_work(user_id: int) -> dict:
+    try:
+        user = await get_user(user_id)
+    except DatabaseError:
+        return {"ok": False, "reason": "db_error"}
+    if user.get("eco_banned"):
+        return {"ok": False, "reason": "banned"}
+
+    work_cd = timedelta(minutes=40) if "monitor" in user["items"] else COOLDOWNS["work"]
+    if cd := _cooldown_remaining(user, "work", override_cd=work_cd):
+        return {"ok": False, "reason": "cooldown", "remaining": cd}
+    if jail := _is_jailed(user):
+        return {"ok": False, "reason": "jailed", "remaining": jail}
+
+    job, job_mult = random.choice(_WORK_JOBS)
+    base = random.randint(15, 75)
+    worker_mult = 1.5 if "gaming_hiir" in user["items"] else 1.0
+    desk_mult = 1.25 if "reguleeritav_laud" in user["items"] else 1.0
+
+    lucky = False
+    if "energiajook" in user["items"] and random.random() < 0.30:
+        lucky = True
+
+    work_plus_level = (user.get("prestige_upgrades") or {}).get("work_plus", 0)
+    work_plus_mult = 1.0 + work_plus_level * PRESTIGE_SHOP["work_plus"]["effect"]
+    coin_mult, _ = _prestige_mult(user)
+    earned = int(base * job_mult * worker_mult * desk_mult * (3.0 if lucky else 1.0) * work_plus_mult * coin_mult * earn_mult(user))
+    user["balance"] += earned
+    user["last_work"] = _now().isoformat()
+    user["work_count"] = user.get("work_count", 0) + 1
+    user["lifetime_earned"] = user.get("lifetime_earned", 0) + earned
+    user["peak_balance"] = max(user.get("peak_balance", 0), user["balance"])
+    await _commit(user_id, user)
+    _txn("WORK", user=user_id, earned=f"+{earned}", lucky=lucky, bal=user["balance"])
+
+    return {
+        "ok": True,
+        "earned": earned,
+        "job": job,
+        "lucky": lucky,
+        "hiir": worker_mult > 1.0,
+        "laud": desk_mult > 1.0,
+        "balance": user["balance"],
+    }
+
+
+# ---------------------------------------------------------------------------
+# /beg
+# ---------------------------------------------------------------------------
+_BEG_LINES = strings.BEG_LINES
+_BEG_JAIL_LINES = strings.BEG_JAIL_LINES
+
+
+@_locked_by(0)
+async def do_beg(user_id: int) -> dict:
+    try:
+        user = await get_user(user_id)
+    except DatabaseError:
+        return {"ok": False, "reason": "db_error"}
+    if user.get("eco_banned"):
+        return {"ok": False, "reason": "banned"}
+
+    beg_cd = timedelta(minutes=3) if "hiirematt" in user["items"] else COOLDOWNS["beg"]
+    if cd := _cooldown_remaining(user, "beg", override_cd=beg_cd):
+        return {"ok": False, "reason": "cooldown", "remaining": cd}
+
+    jailed = bool(_is_jailed(user))
+    beg_mult = 2 if "klaviatuur" in user["items"] else 1
+    coin_mult, _ = _prestige_mult(user)
+    earned = int(random.randint(10, 40) * beg_mult * coin_mult * earn_mult(user))
+    user["balance"] += earned
+    user["last_beg"] = _now().isoformat()
+    user["beg_count"] = user.get("beg_count", 0) + 1
+    user["lifetime_earned"] = user.get("lifetime_earned", 0) + earned
+    user["peak_balance"] = max(user.get("peak_balance", 0), user["balance"])
+    await _commit(user_id, user)
+    _txn("BEG", user=user_id, earned=f"+{earned}", jailed=jailed, bal=user["balance"])
+
+    return {
+        "ok": True,
+        "earned": earned,
+        "text": random.choice(_BEG_JAIL_LINES if jailed else _BEG_LINES),
+        "klaviatuur": beg_mult > 1,
+        "jailed": jailed,
+        "balance": user["balance"],
+    }
+
+
+# ---------------------------------------------------------------------------
+# /crime
+# ---------------------------------------------------------------------------
+_CRIME_WIN = strings.CRIME_WIN
+_CRIME_LOSE = strings.CRIME_LOSE
+
+
+@_locked_by(0)
+async def do_crime(user_id: int) -> dict:
+    try:
+        user = await get_user(user_id)
+    except DatabaseError:
+        return {"ok": False, "reason": "db_error"}
+    if user.get("eco_banned"):
+        return {"ok": False, "reason": "banned"}
+
+    if cd := _cooldown_remaining(user, "crime"):
+        return {"ok": False, "reason": "cooldown", "remaining": cd}
+    if jail := _is_jailed(user):
+        return {"ok": False, "reason": "jailed", "remaining": jail}
+
+    user["last_crime"] = _now().isoformat()
+
+    win_chance = 0.75 if "cat6" in user["items"] else 0.60
+    user["crimes_attempted"] = user.get("crimes_attempted", 0) + 1
+    if random.random() < win_chance:
+        earned = random.randint(200, 500)
+        if "mikrofon" in user["items"]:
+            earned = int(earned * 1.3)
+        earned = int(earned * earn_mult(user))
+        user["balance"] += earned
+        user["crimes_succeeded"] = user.get("crimes_succeeded", 0) + 1
+        user["lifetime_earned"] = user.get("lifetime_earned", 0) + earned
+        user["peak_balance"] = max(user.get("peak_balance", 0), user["balance"])
+        await _commit(user_id, user)
+        _txn("CRIME_WIN", user=user_id, earned=f"+{earned}", bal=user["balance"])
+        return {
+            "ok": True, "success": True,
+            "earned": earned, "text": random.choice(_CRIME_WIN),
+            "mikrofon": "mikrofon" in user["items"],
+            "balance": user["balance"],
+        }
+    else:
+        fine = random.randint(50, 150)
+        user["balance"] = max(0, user["balance"] - fine)
+        jailed = "gaming_tool" not in user["items"]
+        if jailed:
+            user["jailed_until"] = (_now() + JAIL_DURATION).isoformat()
+            user["jailbreak_used"] = False
+            user["times_jailed"] = user.get("times_jailed", 0) + 1
+        user["lifetime_lost"] = user.get("lifetime_lost", 0) + fine
+        await _commit(user_id, user)
+        await _credit_house(fine)
+        _txn("CRIME_FAIL", user=user_id, fine=f"-{fine}", jailed=jailed, bal=user["balance"])
+        return {
+            "ok": True, "success": False,
+            "fine": fine, "text": random.choice(_CRIME_LOSE),
+            "jailed": jailed,
+            "balance": user["balance"],
+        }
+
+
+# ---------------------------------------------------------------------------
+# /rob
+# ---------------------------------------------------------------------------
+@_locked_by(0, 1)
+async def do_rob(robber_id: int, target_id: int) -> dict:
+    try:
+        robber = await get_user(robber_id)
+    except DatabaseError:
+        return {"ok": False, "reason": "db_error"}
+    if robber.get("eco_banned"):
+        return {"ok": False, "reason": "banned"}
+    try:
+        target = await get_user(target_id)
+    except DatabaseError:
+        return {"ok": False, "reason": "db_error"}
+
+    if cd := _cooldown_remaining(robber, "rob"):
+        return {"ok": False, "reason": "cooldown", "remaining": cd}
+    target_jailed = bool(_is_jailed(target))
+    if jail := _is_jailed(robber):
+        if not target_jailed:
+            return {"ok": False, "reason": "jailed", "remaining": jail}
+    elif target_jailed:
+        return {"ok": False, "reason": "target_jailed"}
+    is_house = (house.HOUSE_ID is not None and target_id == house.HOUSE_ID)
+    if is_house and target["balance"] < 50:
+        return {"ok": False, "reason": "broke"}
+    if not is_house and target["balance"] < 100:
+        return {"ok": False, "reason": "broke"}
+
+    robber["last_rob"] = _now().isoformat()
+
+    if "anticheat" in target["items"] and not is_house:
+        fine = random.randint(100, 200)
+        robber["balance"] = max(0, robber["balance"] - fine)
+        # Decrement anticheat uses
+        uses = target.get("item_uses", {}).get("anticheat", 2) - 1
+        if "item_uses" not in target:
+            target["item_uses"] = {}
+        if uses <= 0:
+            target["items"] = [i for i in target["items"] if i != "anticheat"]
+            target["item_uses"].pop("anticheat", None)
+        else:
+            target["item_uses"]["anticheat"] = uses
+        robber["lifetime_lost"] = robber.get("lifetime_lost", 0) + fine
+        await _commit(robber_id, robber)
+        await _commit(target_id, target)
+        await _credit_house(fine)
+        _txn("ROB_BLOCKED", robber=robber_id, victim=target_id, fine=f"-{fine}", robber_bal=robber["balance"], ac_uses_left=uses)
+        return {"ok": True, "success": False, "reason": "valvur", "fine": fine}
+
+    # Robbing the house has lower success (35%) but jackpot chance
+    success_chance = 0.35 if is_house else (0.60 if "jellyfin" in robber["items"] else 0.45)
+    if random.random() < success_chance:
+        jackpot = is_house and random.random() < 0.10
+        if jackpot:
+            pct = 0.40
+        elif is_house:
+            pct = random.uniform(0.05, 0.15)
+        else:
+            pct = random.uniform(0.10, 0.25)
+        stolen = max(10, min(int(target["balance"] * pct), target["balance"]))
+        target["balance"] -= stolen
+        prev_lifetime_earned = robber.get("lifetime_earned", 0)
+        prev_biggest_win = robber.get("biggest_win", 0)
+        prev_peak_balance = robber.get("peak_balance", 0)
+        robber["balance"] += stolen
+        robber["lifetime_earned"] = prev_lifetime_earned + stolen
+        robber["biggest_win"] = max(prev_biggest_win, stolen)
+        robber["peak_balance"] = max(prev_peak_balance, robber["balance"])
+        try:
+            await _commit(robber_id, robber)
+        except DatabaseError:
+            return {"ok": False, "reason": "db_error"}
+        try:
+            await _commit(target_id, target)
+        except DatabaseError:
+            robber["balance"] -= stolen
+            robber["lifetime_earned"] = prev_lifetime_earned
+            robber["biggest_win"] = prev_biggest_win
+            robber["peak_balance"] = prev_peak_balance
+            try:
+                await _commit(robber_id, robber)
+            except DatabaseError as exc2:
+                _log.critical(
+                    "do_rob rollback failed for robber %s after target commit failed: %s",
+                    robber_id, exc2,
+                )
+            return {"ok": False, "reason": "db_error"}
+        _txn("ROB_WIN", robber=robber_id, victim=target_id, stolen=f"+{stolen}", jackpot=jackpot, robber_bal=robber["balance"], victim_bal=target["balance"])
+        return {"ok": True, "success": True, "stolen": stolen, "balance": robber["balance"], "jackpot": jackpot}
+    else:
+        fine = random.randint(100, 250)
+        robber["balance"] = max(0, robber["balance"] - fine)
+        robber["lifetime_lost"] = robber.get("lifetime_lost", 0) + fine
+        robber["biggest_loss"] = max(robber.get("biggest_loss", 0), fine)
+        await _commit(robber_id, robber)
+        await _credit_house(fine)
+        _txn("ROB_FAIL", robber=robber_id, victim=target_id, fine=f"-{fine}", robber_bal=robber["balance"])
+        return {"ok": True, "success": False, "reason": "caught", "fine": fine, "balance": robber["balance"]}
+
+
+# ---------------------------------------------------------------------------
+# /give
+# ---------------------------------------------------------------------------
+@_locked_by(0, 1)
+async def do_give(giver_id: int, receiver_id: int, amount: int) -> dict:
+    try:
+        giver = await get_user(giver_id)
+    except DatabaseError:
+        return {"ok": False, "reason": "db_error"}
+    if giver.get("eco_banned"):
+        return {"ok": False, "reason": "banned"}
+
+    if rem := _is_jailed(giver):
+        return {"ok": False, "reason": "jailed", "remaining": rem}
+
+    if giver["balance"] < amount:
+        return {"ok": False, "reason": "insufficient"}
+
+    try:
+        receiver = await get_user(receiver_id)
+    except DatabaseError:
+        return {"ok": False, "reason": "db_error"}
+    giver["balance"] -= amount
+    receiver["balance"] += amount
+    giver["total_given"] = giver.get("total_given", 0) + amount
+    receiver["total_received"] = receiver.get("total_received", 0) + amount
+    try:
+        await _commit(giver_id, giver)
+    except DatabaseError:
+        return {"ok": False, "reason": "db_error"}
+    try:
+        await _commit(receiver_id, receiver)
+    except DatabaseError:
+        giver["balance"] += amount
+        giver["total_given"] = max(0, giver.get("total_given", 0) - amount)
+        try:
+            await _commit(giver_id, giver)
+        except DatabaseError as exc2:
+            _log.critical(
+                "do_give rollback failed for giver %s after receiver commit failed: %s",
+                giver_id, exc2,
+            )
+        return {"ok": False, "reason": "db_error"}
+    _txn("GIVE", from_=giver_id, to=receiver_id, amount=amount, from_bal=giver["balance"], to_bal=receiver["balance"])
+
+    return {
+        "ok": True,
+        "giver_balance": giver["balance"],
+        "receiver_balance": receiver["balance"],
+    }

core/economy/jail.py

@@ -0,0 +1,85 @@
+"""Jail, jailbreak and bail."""
+
+from __future__ import annotations
+
+import random
+from datetime import timedelta
+
+from .store import (
+    _commit, _is_jailed, _locked_by, _now, _txn, get_all_users_raw, get_user,
+)
+
+
+@_locked_by(0)
+async def do_spam_jail(user_id: int) -> None:
+    """Jail a user for 30 minutes due to suspected automated command spam."""
+    user = await get_user(user_id)
+    user["jailed_until"] = (_now() + timedelta(minutes=30)).isoformat()
+    user["jailbreak_used"] = False
+    user["times_jailed"] = user.get("times_jailed", 0) + 1
+    await _commit(user_id, user)
+    _txn("SPAM_JAIL", user=user_id, until=user["jailed_until"])
+
+
+# ---------------------------------------------------------------------------
+# /jailbreak  (Monopoly-style dice rolls)
+# ---------------------------------------------------------------------------
+@_locked_by(0)
+async def set_jailbreak_used(user_id: int) -> None:
+    """Mark that the user has consumed their dice attempt for this jail sentence."""
+    user = await get_user(user_id)
+    user["jailbreak_used"] = True
+    await _commit(user_id, user)
+
+
+@_locked_by(0)
+async def do_jail_free(user_id: int) -> dict:
+    """Remove jail status after rolling doubles."""
+    user = await get_user(user_id)
+    user["jailed_until"] = None
+    user["jailbreak_used"] = False
+    await _commit(user_id, user)
+    _txn("JAIL_FREE", user=user_id, method="doubles")
+    return {"ok": True, "balance": user["balance"]}
+
+
+MIN_BAIL = 350
+
+@_locked_by(0)
+async def do_bail(user_id: int) -> dict:
+    """Charge bail fine after exhausting jailbreak rolls and free the user.
+    Fine = 20-30% of current balance, floored at 350. If balance < 350, stay jailed."""
+    user = await get_user(user_id)
+    # Idempotency guard: only an actively-jailed user can be charged bail. The
+    # first successful call clears jailed_until, so a rapid second click or a
+    # stale BailView from a re-run /jailbreak becomes a no-op instead of a
+    # second fine (bail is a pure sink - a double charge destroys coins).
+    if not _is_jailed(user):
+        return {"ok": False, "reason": "not_jailed", "balance": user["balance"]}
+    if user["balance"] < MIN_BAIL:
+        return {"ok": False, "reason": "broke", "balance": user["balance"]}
+    pct = random.uniform(0.20, 0.30)
+    fine = max(MIN_BAIL, int(user["balance"] * pct))
+    user["balance"] = max(0, user["balance"] - fine)
+    user["jailed_until"] = None
+    user["jailbreak_used"] = False
+    user["lifetime_lost"] = user.get("lifetime_lost", 0) + fine
+    user["total_bail_paid"] = user.get("total_bail_paid", 0) + fine
+    await _commit(user_id, user)
+    _txn("BAIL_PAID", user=user_id, fine=f"-{fine}", pct=f"{pct:.0%}", bal=user["balance"])
+    return {"ok": True, "fine": fine, "balance": user["balance"]}
+
+
+# ---------------------------------------------------------------------------
+# /jailed
+# ---------------------------------------------------------------------------
+
+async def do_get_jailed() -> list[tuple[int, timedelta]]:
+    """Return [(user_id, remaining)] for every user currently in jail."""
+    all_users = await get_all_users_raw()
+    result: list[tuple[int, timedelta]] = []
+    for uid_str, user in all_users.items():
+        if rem := _is_jailed(user):
+            result.append((int(uid_str), rem))
+    result.sort(key=lambda x: x[1])
+    return result

core/economy/leaderboards.py

@@ -0,0 +1,82 @@
+"""Leaderboard queries over the full collection."""
+
+from __future__ import annotations
+
+from .. import pb_client
+from .levels import get_level
+
+
+async def get_leaderboard(top_n: int | None = 10) -> list[tuple[str, int]]:
+    """Return top_n (user_id_str, balance) pairs sorted descending."""
+    records = await pb_client.list_all_records()
+    result = sorted(
+        ((r["user_id"], r.get("balance", 0)) for r in records if r.get("user_id")),
+        key=lambda x: x[1],
+        reverse=True,
+    )
+    return result if top_n is None else result[:top_n]
+
+
+async def get_leaderboard_exp(top_n: int | None = 10) -> list[tuple[str, int, int]]:
+    """Return top_n (user_id_str, exp, level) sorted by EXP descending."""
+    records = await pb_client.list_all_records()
+    result = sorted(
+        ((r["user_id"], r.get("exp", 0)) for r in records if r.get("user_id")),
+        key=lambda x: x[1],
+        reverse=True,
+    )
+    entries = [(uid, exp, get_level(exp)) for uid, exp in result]
+    return entries if top_n is None else entries[:top_n]
+
+
+# ---------------------------------------------------------------------------
+# Extended leaderboards
+# ---------------------------------------------------------------------------
+async def get_leaderboard_season_exp(top_n: int | None = 10) -> list[tuple[str, int, int]]:
+    """Return (user_id, season_total_exp, prestige_level) sorted by season EXP."""
+    records = await pb_client.list_all_records()
+    result = sorted(
+        (
+            (r["user_id"], r.get("season_total_exp", 0), r.get("prestige_level", 0))
+            for r in records if r.get("user_id")
+        ),
+        key=lambda x: x[1],
+        reverse=True,
+    )
+    return result if top_n is None else result[:top_n]
+
+
+async def get_leaderboard_prestige(top_n: int | None = 10) -> list[tuple[str, int, int]]:
+    """Return (user_id, prestige_level, prestige_points) sorted by prestige_level then PP."""
+    records = await pb_client.list_all_records()
+    result = sorted(
+        (
+            (r["user_id"], r.get("prestige_level", 0), r.get("prestige_points", 0))
+            for r in records if r.get("user_id")
+        ),
+        key=lambda x: (x[1], x[2]),
+        reverse=True,
+    )
+    return result if top_n is None else result[:top_n]
+
+
+async def get_leaderboard_wagered(top_n: int | None = 10) -> list[tuple[str, int]]:
+    """Return (user_id, total_wagered) sorted descending."""
+    records = await pb_client.list_all_records()
+    result = sorted(
+        ((r["user_id"], r.get("total_wagered", 0)) for r in records if r.get("user_id")),
+        key=lambda x: x[1],
+        reverse=True,
+    )
+    return result if top_n is None else result[:top_n]
+
+
+async def get_leaderboard_fish(top_n: int | None = 10) -> list[tuple[str, int]]:
+    """Return (user_id, total_fish_caught) sorted descending."""
+    records = await pb_client.list_all_records()
+    result = sorted(
+        ((r["user_id"], r.get("total_fish_caught", 0)) for r in records if r.get("user_id")),
+        key=lambda x: x[1],
+        reverse=True,
+    )
+    return result if top_n is None else result[:top_n]

core/economy/levels.py

@@ -0,0 +1,81 @@
+"""EXP, levels and vanity role thresholds."""
+
+from __future__ import annotations
+
+import math
+
+from .store import _locked_by, _prestige_mult, get_user, _commit
+from .consumables import exp_buff_mult
+
+
+# ---------------------------------------------------------------------------
+# EXP / Level system
+# ---------------------------------------------------------------------------
+# EXP awarded per successful action
+EXP_REWARDS: dict[str, int] = {
+    "daily":      50,
+    "work":       25,
+    "beg":         5,
+    "crime_win":  15,
+    "rob_win":    15,
+    "gamble_win": 10,
+    "heist_win":  25,
+}
+
+def gamble_exp(bet: int) -> int:
+    """Scale EXP for a gambling win by bet size.
+    Returns 0 for bets < 10 coins to close micro-bet EXP farming.
+    10-99 → 5, 100-999 → 10, 1 000-9 999 → 15, 10 000+ → 20, 100 000+ → 25 (cap).
+    """
+    return min(25, max(0, int(math.log10(max(1, bet))) * 5))
+
+
+ECONOMY_ROLE = "ECONOMY"
+
+# Vanity role milestones: (min_level, role_name) - highest first
+LEVEL_ROLES: list[tuple[int, str]] = [
+    (30, "TipiLEGEND"),
+    (20, "TipiCHAD"),
+    (10, "TipiHUSTLER"),
+    (5,  "TipiGRINDER"),
+    (1,  "TipiNOOB"),
+]
+
+
+def get_level(exp: int) -> int:
+    """Level = max(1, floor(sqrt(exp/10))).
+    Level 5 @ 250 EXP, 10 @ 1000, 20 @ 4000, 30 @ 9000."""
+    return max(1, int(math.sqrt(max(0, exp) / 10)))
+
+
+def exp_for_level(level: int) -> int:
+    """Minimum cumulative EXP to reach this level.
+    Recurrence: exp_for_level(L) = L*20 - 10 + exp_for_level(L-1), base 0.
+    Closed form: 10*level^2."""
+    if level <= 1:
+        return 0
+    return 10 * level * level
+
+
+def level_role_name(level: int) -> str:
+    """Return the vanity role name for a given level."""
+    for threshold, name in LEVEL_ROLES:
+        if level >= threshold:
+            return name
+    return LEVEL_ROLES[-1][1]
+
+
+@_locked_by(0)
+async def award_exp(user_id: int, amount: int) -> dict:
+    """Add EXP to a user. Applies prestige exp_mult. Returns old_level, new_level, total exp."""
+    user = await get_user(user_id)
+    _, exp_mult = _prestige_mult(user)
+    gained = max(1, int(amount * exp_mult * exp_buff_mult(user)))
+    old_exp = user.get("exp", 0)
+    new_exp = old_exp + gained
+    old_level = get_level(old_exp)
+    new_level = get_level(new_exp)
+    user["exp"] = new_exp
+    user["season_total_exp"] = user.get("season_total_exp", 0) + gained
+    await _commit(user_id, user)
+    return {"old_level": old_level, "new_level": new_level, "exp": new_exp, "gained": gained}

core/economy/prestige.py

@@ -0,0 +1,106 @@
+"""Prestige resets and the prestige upgrade shop."""
+
+from __future__ import annotations
+
+from ..pb_client import DatabaseError
+from ..emoji import EMOJI as E
+from .store import PRESTIGE_SHOP, _commit, _locked_by, _txn, get_user
+from .levels import get_level
+
+
+PRESTIGE_ROLE   = "TipiPRESTIGE"
+PRESTIGE_MIN_LEVEL = 30  # minimum level required to prestige
+
+
+# ---------------------------------------------------------------------------
+# /prestige
+# ---------------------------------------------------------------------------
+@_locked_by(0)
+async def do_prestige(user_id: int) -> dict:
+    """Prestige: requires level 30, earns PP, resets balance/exp/items/cooldowns."""
+    try:
+        user = await get_user(user_id)
+    except DatabaseError:
+        return {"ok": False, "reason": "db_error"}
+    if user.get("eco_banned"):
+        return {"ok": False, "reason": "banned"}
+
+    exp = user.get("exp", 0)
+    level = get_level(exp)
+    if level < PRESTIGE_MIN_LEVEL:
+        return {"ok": False, "reason": "level_too_low", "level": level, "required": PRESTIGE_MIN_LEVEL}
+
+    pp_earned = max(1, exp // 1000)
+    new_prestige_level = user.get("prestige_level", 0) + 1
+
+    # Preserve: fish_book, fish_inventory, lifetime stats, prestige_points, season_total_exp, prestige_upgrades
+    user["balance"] = 0
+    user["exp"] = 0
+    user["items"] = []
+    user["item_uses"] = {}
+    user["last_daily"] = None
+    user["last_work"] = None
+    user["last_beg"] = None
+    user["last_crime"] = None
+    user["last_rob"] = None
+    user["last_fish"] = None
+    user["last_heist"] = None
+    user["daily_streak"] = 0
+    user["last_streak_date"] = None
+    user["jailed_until"] = None
+    user["jailbreak_used"] = False
+    user["prestige_level"] = new_prestige_level
+    user["prestige_points"] = user.get("prestige_points", 0) + pp_earned
+
+    await _commit(user_id, user)
+    _txn("PRESTIGE", user=user_id, pp_earned=pp_earned, prestige=new_prestige_level, old_exp=exp)
+
+    return {
+        "ok": True,
+        "pp_earned": pp_earned,
+        "prestige_level": new_prestige_level,
+        "prestige_points": user["prestige_points"],
+        "old_exp": exp,
+    }
+
+
+@_locked_by(0)
+async def do_prestige_buy(user_id: int, upgrade_id: str) -> dict:
+    """Spend PP to buy a prestige upgrade level."""
+    if upgrade_id not in PRESTIGE_SHOP:
+        return {"ok": False, "reason": "not_found"}
+
+    try:
+        user = await get_user(user_id)
+    except DatabaseError:
+        return {"ok": False, "reason": "db_error"}
+    if user.get("eco_banned"):
+        return {"ok": False, "reason": "banned"}
+
+    upgrade = PRESTIGE_SHOP[upgrade_id]
+    upgrades: dict = user.get("prestige_upgrades") or {}
+    current_level = upgrades.get(upgrade_id, 0)
+
+    if current_level >= upgrade["max_level"]:
+        return {"ok": False, "reason": "maxed", "max": upgrade["max_level"]}
+
+    pp = user.get("prestige_points", 0)
+    cost = upgrade["pp_cost"]
+    if pp < cost:
+        return {"ok": False, "reason": "insufficient_pp", "have": pp, "need": cost}
+
+    upgrades[upgrade_id] = current_level + 1
+    user["prestige_upgrades"] = upgrades
+    user["prestige_points"] = pp - cost
+
+    await _commit(user_id, user)
+    _txn("PRESTIGE_BUY", user=user_id, upgrade=upgrade_id,
+         new_level=upgrades[upgrade_id], pp_left=user["prestige_points"])
+
+    return {
+        "ok": True,
+        "upgrade_id": upgrade_id,
+        "new_level": upgrades[upgrade_id],
+        "max_level": upgrade["max_level"],
+        "pp_remaining": user["prestige_points"],
+    }

core/economy/quests.py

@@ -0,0 +1,159 @@
+"""Daily/weekly quests tracked from lifetime counters."""
+
+from __future__ import annotations
+
+import random
+from typing import TypedDict
+
+from .store import (
+    UserData, _commit, _locked_by, _log, _now, _prestige_mult, get_user,
+)
+
+
+# ---------------------------------------------------------------------------
+# Quest system
+# ---------------------------------------------------------------------------
+# Quests reuse the monotonic lifetime counters already tracked on each user.
+# Progress = (current counter value) - (snapshot taken when the quest was rolled).
+# Reset is lazy & per-user: the active set is regenerated the first time a user
+# interacts after the day / ISO-week rolls over (mirrors the streak-date logic).
+# Rotation is seeded by user id + period key, so each player gets their own set.
+class QuestDef(TypedDict):
+    stat: str    # UserData counter field the quest tracks
+    goal: int
+    coins: int
+    exp: int
+
+
+QUESTS_DAILY: dict[str, QuestDef] = {
+    "work3":     {"stat": "work_count",        "goal": 3,     "coins": 150,  "exp": 20},
+    "beg5":      {"stat": "beg_count",         "goal": 5,     "coins": 100,  "exp": 15},
+    "wager500":  {"stat": "total_wagered",     "goal": 500,   "coins": 150,  "exp": 20},
+    "fish2":     {"stat": "total_fish_caught", "goal": 2,     "coins": 150,  "exp": 20},
+    "crime1":    {"stat": "crimes_succeeded",  "goal": 1,     "coins": 200,  "exp": 25},
+    "earn1000":  {"stat": "lifetime_earned",   "goal": 1000,  "coins": 150,  "exp": 20},
+    "give200":   {"stat": "total_given",       "goal": 200,   "coins": 250,  "exp": 20},
+}
+
+QUESTS_WEEKLY: dict[str, QuestDef] = {
+    "work20":    {"stat": "work_count",        "goal": 20,    "coins": 1000, "exp": 100},
+    "fish15":    {"stat": "total_fish_caught", "goal": 15,    "coins": 1200, "exp": 100},
+    "wager5000": {"stat": "total_wagered",     "goal": 5000,  "coins": 1000, "exp": 100},
+    "crime5":    {"stat": "crimes_succeeded",  "goal": 5,     "coins": 1200, "exp": 120},
+    "heist1":    {"stat": "heists_joined",     "goal": 1,     "coins": 800,  "exp": 80},
+    "earn10000": {"stat": "lifetime_earned",   "goal": 10000, "coins": 1500, "exp": 150},
+}
+
+DAILY_QUEST_COUNT  = 3
+WEEKLY_QUEST_COUNT = 2
+
+
+def _period_keys() -> tuple[str, str]:
+    """Return (day_key, week_key) for the current UTC time."""
+    today = _now().date()
+    iso = today.isocalendar()
+    return today.isoformat(), f"{iso[0]}-W{iso[1]:02d}"
+
+
+def _pick_quests(pool: dict[str, QuestDef], count: int, seed: str) -> list[str]:
+    """Deterministically choose `count` quest ids from `pool` for a period."""
+    rng = random.Random(seed)
+    return rng.sample(sorted(pool.keys()), min(count, len(pool)))
+
+
+def _new_quest_block(
+    user: UserData, user_id: int, pool: dict[str, QuestDef], count: int,
+    period_val: str, period_field: str
+) -> dict:
+    chosen = _pick_quests(pool, count, f"{user_id}:{period_field}:{period_val}")
+    return {
+        period_field: period_val,
+        "quests": {
+            qid: {"snap": int(user.get(pool[qid]["stat"], 0) or 0), "claimed": False}
+            for qid in chosen
+        },
+    }
+
+
+def _ensure_quests(user: UserData, user_id: int) -> bool:
+    """Roll fresh daily/weekly quest sets if their period elapsed.
+    Mutates `user` in place; returns True if anything changed (caller commits)."""
+    changed = False
+    day_key, week_key = _period_keys()
+    if (user.get("quest_daily") or {}).get("date") != day_key:
+        user["quest_daily"] = _new_quest_block(user, user_id, QUESTS_DAILY, DAILY_QUEST_COUNT, day_key, "date")
+        changed = True
+    if (user.get("quest_weekly") or {}).get("week") != week_key:
+        user["quest_weekly"] = _new_quest_block(user, user_id, QUESTS_WEEKLY, WEEKLY_QUEST_COUNT, week_key, "week")
+        changed = True
+    return changed
+
+
+def _quest_progress(user: UserData, pool: dict[str, QuestDef], qid: str, state: dict) -> int:
+    cur = int(user.get(pool[qid]["stat"], 0) or 0)
+    return max(0, cur - int(state.get("snap", 0)))
+
+
+def _quest_view(user: UserData) -> dict:
+    def build(pool: dict[str, QuestDef], block: dict) -> list[dict]:
+        out: list[dict] = []
+        for qid, state in (block.get("quests") or {}).items():
+            if qid not in pool:
+                continue
+            d = pool[qid]
+            prog = min(d["goal"], _quest_progress(user, pool, qid, state))
+            out.append({
+                "id": qid, "goal": d["goal"], "coins": d["coins"], "exp": d["exp"],
+                "progress": prog, "done": prog >= d["goal"], "claimed": bool(state.get("claimed")),
+            })
+        return out
+    return {
+        "daily":  build(QUESTS_DAILY,  user.get("quest_daily")  or {}),
+        "weekly": build(QUESTS_WEEKLY, user.get("quest_weekly") or {}),
+    }
+
+
+@_locked_by(0)
+async def get_quests(user_id: int) -> dict:
+    """Return the user's active quests, rolling new sets if the period elapsed."""
+    user = await get_user(user_id)
+    if _ensure_quests(user, user_id):
+        saved = await _commit(user_id, user)
+        if saved is not None and "quest_daily" not in saved:
+            _log.warning(
+                "PocketBase collection has no quest fields - quest state is not "
+                "persisted and progress will stay at 0. Run scripts/add_quest_fields.py."
+            )
+    return _quest_view(user)
+
+
+@_locked_by(0)
+async def claim_quests(user_id: int) -> dict:
+    """Grant coins for every completed-but-unclaimed quest and mark them claimed.
+    Coins (with prestige coin_mult) are paid here; EXP is returned raw for the
+    caller to award via the shared award_exp path (keeps level-up notices)."""
+    user = await get_user(user_id)
+    _ensure_quests(user, user_id)
+    coin_mult, _ = _prestige_mult(user)
+    total_coins = total_exp = claimed = 0
+    for pool, block in (
+        (QUESTS_DAILY,  user.get("quest_daily")  or {}),
+        (QUESTS_WEEKLY, user.get("quest_weekly") or {}),
+    ):
+        for qid, state in (block.get("quests") or {}).items():
+            if qid not in pool or state.get("claimed"):
+                continue
+            if _quest_progress(user, pool, qid, state) < pool[qid]["goal"]:
+                continue
+            total_coins += pool[qid]["coins"]
+            total_exp   += pool[qid]["exp"]
+            state["claimed"] = True
+            claimed += 1
+    if not claimed:
+        return {"ok": False, "reason": "nothing"}
+    coins_awarded = int(total_coins * coin_mult)
+    user["balance"] += coins_awarded
+    user["lifetime_earned"] = user.get("lifetime_earned", 0) + coins_awarded
+    user["peak_balance"] = max(user.get("peak_balance", 0), user["balance"])
+    await _commit(user_id, user)
+    return {"ok": True, "claimed": claimed, "coins": coins_awarded, "exp": total_exp, "balance": user["balance"]}

core/economy/shop.py

@@ -0,0 +1,208 @@
+"""Shop catalogue and purchases."""
+
+from __future__ import annotations
+
+from typing import TypedDict
+
+import strings
+
+from ..pb_client import DatabaseError
+from ..emoji import EMOJI as E
+from .store import _locked_by, _txn, get_user, _commit
+from .levels import get_level
+
+
+# ---------------------------------------------------------------------------
+# Shop catalogue
+# ---------------------------------------------------------------------------
+class ShopItem(TypedDict):
+    name: str
+    emoji: str
+    cost: int
+    description: str
+
+
+SHOP: dict[str, ShopItem] = {
+    "gaming_hiir": {
+        "name": "Mängurihiir",
+        "emoji": E["TipiHIIR"],
+        "cost": 500,
+        "description": strings.ITEM_DESCRIPTIONS["gaming_hiir"],
+    },
+    "hiirematt": {
+        "name": "Hiirematt",
+        "emoji": E["TipiMATT"],
+        "cost": 600,
+        "description": strings.ITEM_DESCRIPTIONS["hiirematt"],
+    },
+    "korvaklapid": {
+        "name": "K\u00f5rvaklapid",
+        "emoji": E["TipiKLAPID"],
+        "cost": 1200,
+        "description": strings.ITEM_DESCRIPTIONS["korvaklapid"],
+    },
+    "lan_pass": {
+        "name": "LAN pilet",
+        "emoji": E["TipiPILET"],
+        "cost": 1200,
+        "description": strings.ITEM_DESCRIPTIONS["lan_pass"],
+    },
+    "energiajook": {
+        "name": "Red Bull",
+        "emoji": E["TipiBULL"],
+        "cost": 800,
+        "description": strings.ITEM_DESCRIPTIONS["energiajook"],
+    },
+    "gaming_laptop": {
+        "name": "Bot Farm",
+        "emoji": E["TipiLAP"],
+        "cost": 1500,
+        "description": strings.ITEM_DESCRIPTIONS["gaming_laptop"],
+    },
+    "anticheat": {
+        "name": "Anticheat",
+        "emoji": E["TipiVAC"],
+        "cost": 1000,
+        "description": strings.ITEM_DESCRIPTIONS["anticheat"],
+    },
+    # ----- Tier 2 -----
+    "reguleeritav_laud": {
+        "name": "Reguleeritav laud",
+        "emoji": E["TipiLAUD"],
+        "cost": 3500,
+        "description": strings.ITEM_DESCRIPTIONS["reguleeritav_laud"],
+    },
+    "jellyfin": {
+        "name": "Jellyfin server",
+        "emoji": E["TipiSERVER"],
+        "cost": 4000,
+        "description": strings.ITEM_DESCRIPTIONS["jellyfin"],
+    },
+    "mikrofon": {
+        "name": "Eraldiseisev mikrofon",
+        "emoji": E["TipiMIC"],
+        "cost": 2800,
+        "description": strings.ITEM_DESCRIPTIONS["mikrofon"],
+    },
+    "klaviatuur": {
+        "name": "Mehaaniline klaviatuur",
+        "emoji": E["TipiKLAVA"],
+        "cost": 1800,
+        "description": strings.ITEM_DESCRIPTIONS["klaviatuur"],
+    },
+    "monitor": {
+        "name": "Ultralai monitor",
+        "emoji": E["TipiMONITOR"],
+        "cost": 2500,
+        "description": strings.ITEM_DESCRIPTIONS["monitor"],
+    },
+    "cat6": {
+        "name": "Cat6 kaabel",
+        "emoji": E["TipiCAT"],
+        "cost": 3500,
+        "description": strings.ITEM_DESCRIPTIONS["cat6"],
+    },
+    # ----- Tier 3 -----
+    "monitor_360": {
+        "name": "360Hz monitor",
+        "emoji": E["TipiMONITOR2"],
+        "cost": 7500,
+        "description": strings.ITEM_DESCRIPTIONS["monitor_360"],
+    },
+    "karikas": {
+        "name": "TipiLAN karikas",
+        "emoji": E["TipiKARIKAS"],
+        "cost": 6000,
+        "description": strings.ITEM_DESCRIPTIONS["karikas"],
+    },
+    "gaming_tool": {
+        "name": "Gaming tool",
+        "emoji": E["TipiTOOL"],
+        "cost": 9000,
+        "description": strings.ITEM_DESCRIPTIONS["gaming_tool"],
+    },
+    # ----- Fishing items -----
+    "ussipurk": {
+        "name": "Ussipurk",
+        "emoji": "🪣",
+        "cost": 3500,
+        "description": strings.ITEM_DESCRIPTIONS["ussipurk"],
+    },
+    "kalavork": {
+        "name": "Kalavõrk",
+        "emoji": "🪝",
+        "cost": 5000,
+        "description": strings.ITEM_DESCRIPTIONS["kalavork"],
+    },
+    "echolood": {
+        "name": "Echolood",
+        "emoji": "📡",
+        "cost": 8000,
+        "description": strings.ITEM_DESCRIPTIONS["echolood"],
+    },
+}
+
+# Tier grouping (used by /shop pagination)
+SHOP_TIERS: dict[int, list[str]] = {
+    1: ["gaming_hiir", "hiirematt", "korvaklapid", "lan_pass", "energiajook", "anticheat", "gaming_laptop"],
+    2: ["reguleeritav_laud", "jellyfin", "mikrofon", "klaviatuur", "monitor", "cat6", "ussipurk"],
+    3: ["monitor_360", "karikas", "gaming_tool", "kalavork", "echolood"],
+}
+
+# Minimum level required to purchase Tier 2 / Tier 3 shop items
+SHOP_LEVEL_REQ: dict[str, int] = {
+    "reguleeritav_laud": 10,
+    "jellyfin":          10,
+    "mikrofon":          10,
+    "klaviatuur":        10,
+    "monitor":           10,
+    "cat6":              10,
+    "ussipurk":          10,
+    "monitor_360":       20,
+    "karikas":           20,
+    "gaming_tool":       20,
+    "kalavork":          20,
+    "echolood":          20,
+}
+
+
+# ---------------------------------------------------------------------------
+# /buy
+# ---------------------------------------------------------------------------
+@_locked_by(0)
+async def do_buy(user_id: int, item_id: str) -> dict:
+    if item_id not in SHOP:
+        return {"ok": False, "reason": "not_found"}
+    try:
+        user = await get_user(user_id)
+    except DatabaseError:
+        return {"ok": False, "reason": "db_error"}
+    if user.get("eco_banned"):
+        return {"ok": False, "reason": "banned"}
+
+    item = SHOP[item_id]
+    if item_id in user["items"]:
+        # Allow repurchase of anticheat if uses are depleted
+        if item_id == "anticheat" and user.get("item_uses", {}).get("anticheat", 2) <= 0:
+            user["items"] = [i for i in user["items"] if i != "anticheat"]
+            user.get("item_uses", {}).pop("anticheat", None)
+        else:
+            return {"ok": False, "reason": "owned"}
+    min_level = SHOP_LEVEL_REQ.get(item_id, 0)
+    if min_level > 0:
+        user_level = get_level(user.get("exp", 0))
+        if user_level < min_level:
+            return {"ok": False, "reason": "level_required", "min_level": min_level, "user_level": user_level}
+    if user["balance"] < item["cost"]:
+        return {"ok": False, "reason": "insufficient", "need": item["cost"] - user["balance"]}
+
+    user["balance"] -= item["cost"]
+    user["items"].append(item_id)
+    if item_id == "anticheat":
+        if "item_uses" not in user:
+            user["item_uses"] = {}
+        user["item_uses"]["anticheat"] = 2
+    await _commit(user_id, user)
+    _txn("BUY", user=user_id, item=item_id, cost=f"-{item['cost']}", bal=user["balance"])
+
+    return {"ok": True, "item": item, "balance": user["balance"]}

core/economy/store.py

@@ -0,0 +1,386 @@
+"""Shared foundation: user records, locks, time, cooldowns, txn log."""
+
+from __future__ import annotations
+
+import asyncio
+import functools
+import logging
+from datetime import datetime, timedelta, timezone
+from typing import TypedDict
+
+import aiohttp
+
+from .. import pb_client
+from ..pb_client import DatabaseError
+from ..emoji import EMOJI as E
+
+
+def _clock() -> datetime:
+    """Actual time source - a seam so tests can freeze time everywhere at once."""
+    return datetime.now(tz=timezone.utc)
+
+
+def _now() -> datetime:
+    return _clock()
+
+
+_txn_log = logging.getLogger("tipiCOIN.txn")
+
+
+def _txn(event: str, **fields) -> None:
+    """Log a single economy transaction to the transactions logger."""
+    body = "  ".join(f"{k}={v}" for k, v in fields.items())
+    _txn_log.info("%-16s  %s", event, body)
+
+
+# Per-profile emoji values live in core/emoji.py; add new IDs there.
+COIN            = E["TipiCOIN"]
+PP_EMOJI        = E["TipiFIRE"]
+
+# ---------------------------------------------------------------------------
+# Prestige shop catalogue
+# ---------------------------------------------------------------------------
+class PrestigeItem(TypedDict):
+    emoji: str
+    max_level: int
+    pp_cost: int
+    effect: float
+
+
+PRESTIGE_SHOP: dict[str, PrestigeItem] = {
+    "coin_mult": {
+        "emoji": E["TipiCOIN"],
+        "max_level": 5,
+        "pp_cost": 5,
+        "effect": 0.08,
+    },
+    "exp_mult": {
+        "emoji": "✨",
+        "max_level": 5,
+        "pp_cost": 5,
+        "effect": 0.08,
+    },
+    "daily_plus": {
+        "emoji": "📅",
+        "max_level": 3,
+        "pp_cost": 7,
+        "effect": 0.20,
+    },
+    "work_plus": {
+        "emoji": "💼",
+        "max_level": 3,
+        "pp_cost": 7,
+        "effect": 0.20,
+    },
+}
+
+
+# ---------------------------------------------------------------------------
+# Cooldowns
+# ---------------------------------------------------------------------------
+COOLDOWNS: dict[str, timedelta] = {
+    "daily":  timedelta(hours=20),
+    "work":   timedelta(hours=1),
+    "beg":    timedelta(minutes=5),
+    "crime":  timedelta(hours=2),
+    "rob":    timedelta(hours=2),
+    "fish":   timedelta(minutes=2),
+}
+
+JAIL_DURATION  = timedelta(minutes=30)
+HEIST_JAIL     = timedelta(hours=1, minutes=30)
+
+# ---------------------------------------------------------------------------
+# User schema
+# ---------------------------------------------------------------------------
+class UserData(TypedDict, total=False):
+    balance: int
+    exp: int                        # lifetime EXP (resets each season)
+    last_daily: str | None
+    last_work: str | None
+    last_beg: str | None
+    last_crime: str | None
+    last_rob: str | None
+    last_heist: str | None
+    daily_streak: int
+    last_streak_date: str | None   # ISO date "YYYY-MM-DD"
+    items: list[str]
+    item_uses: dict                 # {item_id: remaining_uses} for consumables
+    active_buffs: dict              # {buff_kind: expiry_iso} for timed consumable boosts
+    jailed_until: str | None       # ISO datetime or None
+    jailbreak_used: bool
+    reminders: list[str]           # command names user wants DM reminders for
+    eco_banned: bool                # if True, user cannot use any economy commands
+    # Lifetime statistics
+    peak_balance: int
+    lifetime_earned: int
+    lifetime_lost: int
+    work_count: int
+    beg_count: int
+    total_wagered: int
+    biggest_win: int
+    biggest_loss: int
+    slots_jackpots: int
+    crimes_attempted: int
+    crimes_succeeded: int
+    times_jailed: int
+    total_bail_paid: int
+    heists_joined: int
+    heists_won: int
+    total_given: int
+    total_received: int
+    best_daily_streak: int
+    heist_global_cd_until: float
+    # Prestige system
+    prestige_level: int
+    prestige_points: int
+    season_total_exp: int           # cumulative EXP this season (survives prestige resets)
+    prestige_upgrades: dict         # {upgrade_id: level}
+    # Fishing system
+    last_fish: str | None
+    fish_book: dict                 # {fish_id: times_caught}
+    total_fish_caught: int
+    fish_inventory: list            # [{fish_id, weight, value}] - survives prestige
+    # Quest system
+    quest_daily: dict               # {"date": "YYYY-MM-DD", "quests": {qid: {snap, claimed}}}
+    quest_weekly: dict              # {"week": "YYYY-Www",   "quests": {qid: {snap, claimed}}}
+
+
+def _default_user() -> UserData:
+    return {
+        "balance": 0,
+        "exp": 0,
+        "last_daily": None,
+        "last_work": None,
+        "last_beg": None,
+        "last_crime": None,
+        "last_rob": None,
+        "last_heist": None,
+        "daily_streak": 0,
+        "last_streak_date": None,
+        "items": [],
+        "item_uses": {},
+        "active_buffs": {},
+        "jailed_until": None,
+        "jailbreak_used": False,
+        "reminders": ["daily", "work", "beg", "crime", "rob"],
+        "eco_banned": False,
+        # ── Lifetime stats ──────────────────────────────────────────────────
+        "peak_balance":    0,
+        "lifetime_earned": 0,
+        "lifetime_lost":   0,
+        "work_count":      0,
+        "beg_count":       0,
+        "total_wagered":   0,
+        "biggest_win":     0,
+        "biggest_loss":    0,
+        "slots_jackpots":  0,
+        "crimes_attempted":  0,
+        "crimes_succeeded":  0,
+        "times_jailed":    0,
+        "total_bail_paid": 0,
+        "heists_joined":   0,
+        "heists_won":      0,
+        "total_given":     0,
+        "total_received":  0,
+        "best_daily_streak": 0,
+        "heist_global_cd_until": 0.0,
+        # ── Prestige ─────────────────────────────────────────────────────────
+        "prestige_level":    0,
+        "prestige_points":   0,
+        "season_total_exp":  0,
+        "prestige_upgrades": {},
+        # ── Fishing ──────────────────────────────────────────────────────────
+        "last_fish":         None,
+        "fish_book":         {},
+        "total_fish_caught": 0,
+        "fish_inventory":    [],
+        # ── Quests ───────────────────────────────────────────────────────────
+        "quest_daily":       {},
+        "quest_weekly":      {},
+    }
+
+
+# ---------------------------------------------------------------------------
+# Persistence  (PocketBase backend)
+# ---------------------------------------------------------------------------
+_log = logging.getLogger("tipiCOIN.economy")
+
+# ---------------------------------------------------------------------------
+# Per-user write locks
+# ---------------------------------------------------------------------------
+# Every mutation is a read-modify-write cycle (get_user → mutate → _commit);
+# without serialization, two concurrent commands for the same user overwrite
+# each other's commit. Locking rules that keep this deadlock-free:
+#   - a decorated function must never call another decorated function
+#   - house balance changes go through _credit_house (an atomic PocketBase
+#     increment, no lock), so they are safe while holding user locks
+_user_locks: dict[int, asyncio.Lock] = {}
+
+
+def _user_lock(user_id: int) -> asyncio.Lock:
+    lock = _user_locks.get(user_id)
+    if lock is None:
+        lock = _user_locks[user_id] = asyncio.Lock()
+    return lock
+
+
+def _locked_by(*arg_positions: int):
+    """Serialize the decorated function per user id found at the given
+    positional-argument indices. Multiple ids are acquired in sorted order so
+    two-user functions (do_give, do_rob) cannot deadlock each other."""
+    def decorator(fn):
+        @functools.wraps(fn)
+        async def wrapper(*args, **kwargs):
+            locks = [_user_lock(uid) for uid in sorted({args[pos] for pos in arg_positions})]
+            for lock in locks:
+                await lock.acquire()
+            try:
+                return await fn(*args, **kwargs)
+            finally:
+                for lock in reversed(locks):
+                    lock.release()
+        return wrapper
+    return decorator
+
+
+# ---------------------------------------------------------------------------
+# Public helpers
+# ---------------------------------------------------------------------------
+async def missing_schema_fields() -> list[str]:
+    """Compare the live PocketBase collection schema against every field the
+    bot persists. PocketBase silently drops writes to undeclared fields, so
+    any name returned here means broken features without error messages."""
+    live = await pb_client.get_collection_fields()
+    expected = set(_default_user()) | {"user_id"}
+    return sorted(expected - live)
+
+
+async def get_all_users_raw() -> dict[str, "UserData"]:
+    """Return a snapshot of all user records."""
+    records = await pb_client.list_all_records()
+    result: dict[str, UserData] = {}
+    for record in records:
+        uid = record.get("user_id", "")
+        if not uid:
+            continue
+        user = _default_user()
+        for key in list(user.keys()):
+            if key in record:
+                user[key] = record[key]  # type: ignore[literal-required]
+        user["_pb_id"] = record["id"]  # type: ignore[typeddict-unknown-key]
+        result[uid] = user
+    return result
+
+
+def _parse_dt(s: str | None) -> datetime | None:
+    if not s:
+        return None
+    dt = datetime.fromisoformat(s)
+    # Ensure timezone-aware
+    return dt if dt.tzinfo else dt.replace(tzinfo=timezone.utc)
+
+
+def _cooldown_remaining(
+    user: UserData, action: str, override_cd: timedelta | None = None
+) -> timedelta | None:
+    """Return remaining cooldown, or None if the action is ready."""
+    last = _parse_dt(user.get(f"last_{action}"))
+    if last is None:
+        return None
+    cd = override_cd if override_cd is not None else COOLDOWNS[action]
+    remaining = cd - (_now() - last)
+    return remaining if remaining.total_seconds() > 0 else None
+
+
+def _is_jailed(user: UserData) -> timedelta | None:
+    """Return remaining jail time, or None if free."""
+    until = _parse_dt(user.get("jailed_until"))
+    if until is None:
+        return None
+    remaining = until - _now()
+    return remaining if remaining.total_seconds() > 0 else None
+
+
+def jailed_remaining(user: UserData) -> timedelta | None:
+    """Public wrapper - return remaining jail time, or None if free."""
+    return _is_jailed(user)
+
+
+# ---------------------------------------------------------------------------
+# Helpers
+# ---------------------------------------------------------------------------
+def format_td(td: timedelta) -> str:
+    """Human-readable timedelta: '1t 23m' / '45m 12s' / '8s'."""
+    total = int(td.total_seconds())
+    h, rem = divmod(total, 3600)
+    m, s = divmod(rem, 60)
+    if h:
+        return f"{h}t {m}m"
+    if m:
+        return f"{m}m {s}s"
+    return f"{s}s"
+
+
+async def get_user(user_id: int) -> UserData:
+    """Fetch user data from PocketBase, creating a default record if first seen."""
+    uid = str(user_id)
+    try:
+        record = await pb_client.get_record(uid)
+        if record is None:
+            default = _default_user()
+            default["user_id"] = uid  # type: ignore[typeddict-unknown-key]
+            record = await pb_client.create_record(default)
+    except (aiohttp.ClientError, asyncio.TimeoutError, RuntimeError) as exc:
+        _log.error("PocketBase unreachable for user %s: %s", user_id, exc)
+        raise DatabaseError(f"Database unavailable: {exc}") from exc
+    user = _default_user()
+    for key in list(user.keys()):
+        if key in record:
+            user[key] = record[key]  # type: ignore[literal-required]
+    user["_pb_id"] = record["id"]  # type: ignore[typeddict-unknown-key]
+    return user
+
+
+def _prestige_mult(user: UserData) -> tuple[float, float]:
+    """Return (coin_mult, exp_mult) based on prestige upgrades. Both ≥1.0."""
+    upgrades: dict = user.get("prestige_upgrades") or {}  # type: ignore[assignment]
+    coin_level = upgrades.get("coin_mult", 0)
+    exp_level  = upgrades.get("exp_mult",  0)
+    return (
+        1.0 + coin_level * PRESTIGE_SHOP["coin_mult"]["effect"],
+        1.0 + exp_level  * PRESTIGE_SHOP["exp_mult"]["effect"],
+    )
+
+
+# ---------------------------------------------------------------------------
+# Internal write helper
+# ---------------------------------------------------------------------------
+async def _commit(user_id: int, user: UserData) -> dict | None:
+    """Persist the full user record. Returns the record as PocketBase stored it
+    (fields absent from the collection schema are silently dropped by PB)."""
+    record_id = user.get("_pb_id")  # type: ignore[typeddict-item]
+    clean = {k: v for k, v in user.items() if k != "_pb_id"}
+    clean["user_id"] = str(user_id)
+    try:
+        if record_id:
+            return await pb_client.update_record(record_id, clean)
+        else:
+            _log.warning("_commit for user %s had no _pb_id; creating new record", user_id)
+            created = await pb_client.create_record(clean)
+            user["_pb_id"] = created["id"]  # type: ignore[typeddict-unknown-key]
+            return created
+    except (aiohttp.ClientError, asyncio.TimeoutError, RuntimeError) as exc:
+        _log.error("_commit failed for user %s: %s", user_id, exc)
+        raise DatabaseError(f"Failed to persist user {user_id}: {exc}") from exc
+
+
+# ---------------------------------------------------------------------------
+# /reminders
+# ---------------------------------------------------------------------------
+@_locked_by(0)
+async def do_set_reminders(user_id: int, commands: list[str]) -> None:
+    """Overwrite the user's reminder list with the given command names."""
+    user = await get_user(user_id)
+    user["reminders"] = list(commands)
+    await _commit(user_id, user)

core/emoji.py

@@ -0,0 +1,97 @@
+"""Custom Discord emoji registry, keyed by symbolic name and resolved per BOT_PROFILE.
+
+Emojis are uploaded as application emojis via the Discord Developer Portal
+and are scoped to a single bot application. Dev and production are separate
+applications, so the same logical emoji has a different ID in each — hence
+two dicts below, selected by BOT_PROFILE.
+
+To add a new emoji: upload it to both applications in the dev portal, grab
+the two IDs, and add one line to each dict.
+"""
+
+from __future__ import annotations
+
+from config import BOT_PROFILE
+
+
+_DEV: dict[str, str] = {
+    "TipiCOIN":     "<:TipiCOIN:1483000209188589628>",
+    "TipiFIRE":     "<:TipiFIRE:1483431381668335687>",
+    "TipiHIIR":     "<:TipiHIIR:1483004306012504128>",
+    "TipiMATT":     "<:TipiMATT:1483387697132208128>",
+    "TipiKLAPID":   "<:TipiKLAPID:1483387694083084349>",
+    "TipiPILET":    "<:TipiPILET:1483004308353060904>",
+    "TipiBULL":     "<:TipiBULL:1483004310924300409>",
+    "TipiLAP":      "<:TipiLAP:1483004307161874566>",
+    "TipiVAC":      "<:TipiVAC:1483004309510819860>",
+    "TipiLAUD":     "<:TipiLAUD:1483387695576125440>",
+    "TipiSERVER":   "<:TipiSERVER:1483387701032910969>",
+    "TipiMIC":      "<:TipiMIC:1483387698499551313>",
+    "TipiKLAVA":    "<:TipiKLAVA:1483014339228078140>",
+    "TipiMONITOR":  "<:TipiMONITOR:1483014340327243908>",
+    "TipiCAT":      "<:TipiCAT:1483014337663602718>",
+    "TipiMONITOR2": "<:TipiMONITOR2:1483387699514839162>",
+    "TipiKARIKAS":  "<:TipiKARIKAS:1483014841148112977>",
+    "TipiTOOL":     "<:TipiTOOL:1483014341648187613>",
+    "TipiHEART":    "<:TipiHEART:1483431377561976853>",
+    "TipiTROLL":    "<:TipiTROLL:1483431380166774895>",
+    "TipICRY":      "<:TipICRY:1483431288852709387>",
+    "TipiSKULL":    "<:TipiSKULL:1483431378929451028>",
+    "TipiDICE":     "<a:TipiDICE:1485923107108556950>",
+    "TipiYKS":      "<:TipiYKS:1483103190491856916>",
+    "TipiKAKS":     "<:TipiKAKS:1483103215841972404>",
+    "TipiKOLM":     "<:TipiKOLM:1483103217846980781>",
+    "TipiNELI":     "<:TipiNELI:1483103237585240114>",
+    "TipiVIIS":     "<:TipiVIIS:1483103239036469289>",
+    "TipiKUUS":     "<:TipiKUUS:1483103253163020348>",
+    "TipiSLOTS":    "<a:TipiSLOTS:1483444233863037101>",
+}
+
+# Production application emoji IDs (from the TipiBOT application's dev-portal
+# Emojis tab). The display name in <:name:id> is cosmetic — Discord resolves
+# by ID — so we keep the same logical names as _DEV even when the prod portal
+# uses a different upload name (e.g. prod's "TipiFIVE" → key "TipiVIIS").
+_ECONOMY: dict[str, str] = {
+    "TipiCOIN":     "<:TipiCOIN:1511754551747940485>",
+    "TipiFIRE":     "<:TipiFIRE:1511754615761272862>",
+    "TipiHIIR":     "<:TipiHIIR:1511754556105822218>",
+    "TipiMATT":     "<:TipiMATT:1511754595448131665>",
+    "TipiKLAPID":   "<:TipiKLAPID:1511754589798666433>",
+    "TipiPILET":    "<:TipiPILET:1511754560593727652>",
+    "TipiBULL":     "<:TipiBULL:1511754564179595264>",
+    "TipiLAP":      "<:TipiLAP:1511754558970269907>",
+    "TipiVAC":      "<:TipiVAC:1511754562413924442>",
+    "TipiLAUD":     "<:TipiLAUD:1511754592759713985>",
+    "TipiSERVER":   "<:TipiSERVER:1511754601186066534>",
+    "TipiMIC":      "<:TipiMIC:1511754597016801310>",
+    "TipiKLAVA":    "<:TipiKLAVA:1511754567648542780>",
+    "TipiMONITOR":  "<:TipiMONITOR:1511754570722971868>",
+    "TipiCAT":      "<:TipiCAT:1511754566092193853>",
+    "TipiMONITOR2": "<:TipiMONITOR2:1511754598732402689>",
+    "TipiKARIKAS":  "<:TipiKARIKAS:1511754574405435502>",
+    "TipiTOOL":     "<:TipiTOOL:1511754572522061874>",
+    "TipiHEART":    "<:TipiHEART:1511754608299737139>",
+    "TipiTROLL":    "<:TipiTROLL:1511754612775063832>",
+    "TipICRY":      "<:TipICRY:1511754603308515368>",
+    "TipiSKULL":    "<:TipiSKULL:1511754610195566622>",
+    "TipiDICE":     "<a:TipiDICE:1511753607119376504>",
+    "TipiYKS":      "<:TipiYKS:1511754576368373951>",
+    "TipiKAKS":     "<:TipiKAKS:1511754577928523997>",
+    "TipiKOLM":     "<:TipiKOLM:1511754581078442005>",
+    "TipiNELI":     "<:TipiNELI:1511754582571880509>",
+    "TipiVIIS":     "<:TipiVIIS:1511754584182227005>",
+    "TipiKUUS":     "<:TipiKUUS:1511754586262736977>",
+    "TipiSLOTS":    "<a:TipiSLOTS:1511754521188106431>",
+}
+
+
+_EMOJI_SETS = {
+    "dev":     _DEV,
+    "economy": _ECONOMY,
+}
+
+EMOJI: dict[str, str] = _EMOJI_SETS[BOT_PROFILE]
+
+_missing = set(_DEV) - set(EMOJI)
+if _missing:
+    raise RuntimeError(f"Emoji set {BOT_PROFILE!r} missing keys: {sorted(_missing)}")

core/fienta.py

@@ -0,0 +1,190 @@
+"""Fienta ticketing integration - authoritative Discord -> team mapping.
+
+The tournament registration on Fienta collects, per competitor ticket, the
+player's Discord username (and sometimes Discord user ID), their team name
+(order-level, echoed onto each attendee), and the ticket type (which names the
+game). That gives a reliable Discord-identity -> team mapping the nickname-only
+registration sheet cannot, so this is the PRIMARY source for team-role sync,
+with :mod:`core.sheets` kept as a fallback.
+
+Enabled by ``FIENTA_API_TOKEN`` + ``FIENTA_EVENT_ID``; when either is unset all
+caches stay empty and every getter is a no-op, so team sync silently falls back
+to the sheet. Only real team members get roles - competitor, coach/manager and
+substitute tickets are included; visitors, supporters, LAN-access, early-bird
+and waiting-list tickets are excluded.
+"""
+
+from __future__ import annotations
+
+import logging
+
+import aiohttp
+
+import config
+
+log = logging.getLogger(__name__)
+
+_API_BASE = "https://fienta.com/api/v1"
+_PAGE_SIZE = 1000  # Fienta's max per page; one page covers a whole tournament
+
+# Ticket-type titles that represent an actual team member who should get a role.
+_INCLUDED_KEYWORDS = ("competitor", "coach", "manager", "substitute")
+# ...unless the title also matches one of these (visitors etc. are never players).
+_EXCLUDED_KEYWORDS = (
+    "visitor", "supporter", "lan area", "early bird", "waiting list", "waitlist",
+)
+
+# Attendee custom-field keys. Fienta appends the field id to the machine name;
+# these come from GET /events/{id}/custom-fields for event 176532.
+_F_DISCORD_USERNAME = "discord_username_134871"
+_F_DISCORD_USERID = "discord_user_id_135840"
+_F_TEAM_NAME = "team_name_134821"
+
+_GAME_KEYWORDS: list[tuple[str, tuple[str, ...]]] = [
+    ("CS2", ("counter-strike", "counter strike", "cs2", "csgo", "cs:go")),
+    ("LoL", ("league of legends", "league", "lol")),
+]
+
+# Caches, rebuilt by refresh_teams()/parse_tickets().
+_by_username: dict[str, str] = {}   # discord username (lower) -> team name
+_by_userid: dict[str, str] = {}     # discord user id (str)    -> team name
+_team_game: dict[str, str] = {}     # team name -> "CS2" / "LoL"
+_team_names: set[str] = set()
+
+
+def _norm_username(name: str) -> str:
+    """Normalise a Discord username for matching: lowercased, no leading @."""
+    return name.strip().lower().lstrip("@")
+
+
+def _detect_game(ticket_type_title: str) -> str | None:
+    """Return the game code for a ticket-type title, or None if unrecognised."""
+    title = ticket_type_title.lower()
+    for game, keywords in _GAME_KEYWORDS:
+        if any(k in title for k in keywords):
+            return game
+    return None
+
+
+def _is_included(ticket_type_title: str) -> bool:
+    """True when this ticket type is an actual team member (not a visitor etc.)."""
+    title = ticket_type_title.lower()
+    if any(k in title for k in _EXCLUDED_KEYWORDS):
+        return False
+    return any(k in title for k in _INCLUDED_KEYWORDS)
+
+
+def _game_divider_ids() -> dict[str, int]:
+    """Map game code -> divider role id, derived from ``config.TEAM_DIVIDERS``.
+
+    Reuses the same ``TEAM_DIVIDER_<SUFFIX>`` role IDs the sheet path uses: a
+    suffix like ``cs2_2026`` contributes its id to game ``CS2``.
+    """
+    out: dict[str, int] = {}
+    for suffix, rid in config.TEAM_DIVIDERS.items():
+        parts = suffix.split("_")
+        if any(p in ("cs2", "cs", "csgo") for p in parts):
+            out.setdefault("CS2", rid)
+        if any(p in ("lol", "league") for p in parts):
+            out.setdefault("LoL", rid)
+    return out
+
+
+def parse_tickets(tickets: list[dict]) -> None:
+    """Rebuild the caches from a list of Fienta ticket objects.
+
+    Pure/synchronous so it can be unit-tested without hitting the API.
+    """
+    global _by_username, _by_userid, _team_game, _team_names
+    by_username: dict[str, str] = {}
+    by_userid: dict[str, str] = {}
+    team_game: dict[str, str] = {}
+    for ticket in tickets:
+        rows = ticket.get("rows") or []
+        if not rows:
+            continue
+        row = rows[0]
+        title = (row.get("ticket_type") or {}).get("title", "")
+        if not _is_included(title):
+            continue
+        attendee = row.get("attendee") or {}
+        team = (attendee.get(_F_TEAM_NAME) or "").strip()
+        if not team:
+            continue
+        game = _detect_game(title)
+        # Keep the first non-None game seen for a team (all its tickets agree).
+        team_game[team] = game or team_game.get(team)
+        uname = _norm_username(attendee.get(_F_DISCORD_USERNAME) or "")
+        uid = (attendee.get(_F_DISCORD_USERID) or "").strip()
+        if uname:
+            by_username[uname] = team
+        if uid.isdigit():
+            by_userid[uid] = team
+    _by_username = by_username
+    _by_userid = by_userid
+    _team_game = team_game
+    _team_names = set(team_game)
+
+
+async def refresh_teams() -> set[str]:
+    """Fetch competitor tickets from Fienta and rebuild the caches.
+
+    No-op returning an empty set when ``FIENTA_API_TOKEN`` / ``FIENTA_EVENT_ID``
+    are unset, so the caller transparently falls back to the sheet.
+    """
+    if not config.FIENTA_API_TOKEN or not config.FIENTA_EVENT_ID:
+        parse_tickets([])
+        return set()
+
+    url = f"{_API_BASE}/events/{config.FIENTA_EVENT_ID}/tickets"
+    headers = {"Authorization": f"Bearer {config.FIENTA_API_TOKEN}"}
+    tickets: list[dict] = []
+    async with aiohttp.ClientSession() as session:
+        page = 1
+        while True:
+            params = {"attendees": "true", "per_page": str(_PAGE_SIZE), "page": str(page)}
+            async with session.get(url, headers=headers, params=params) as resp:
+                resp.raise_for_status()
+                data = await resp.json()
+            batch = data.get("tickets") or []
+            tickets.extend(batch)
+            if len(batch) < _PAGE_SIZE:
+                break
+            page += 1
+
+    parse_tickets(tickets)
+    log.info(
+        "Fienta: %d tickets -> %d teams, %d discord usernames, %d discord ids",
+        len(tickets), len(_team_names), len(_by_username), len(_by_userid),
+    )
+    return set(_team_names)
+
+
+def get_team_for_username(username: str) -> str | None:
+    """Team the given Discord username is registered on, or None."""
+    return _by_username.get(_norm_username(username))
+
+
+def get_team_for_userid(user_id: int) -> str | None:
+    """Team the given Discord user ID is registered on, or None (IDs are sparse)."""
+    return _by_userid.get(str(user_id))
+
+
+def all_team_names() -> set[str]:
+    """Every team name seen in the included Fienta tickets."""
+    return set(_team_names)
+
+
+def get_team_game(team: str) -> str | None:
+    """Game code ("CS2"/"LoL") for a team, or None."""
+    return _team_game.get(team)
+
+
+def get_team_dividers() -> dict[str, int]:
+    """{team name -> divider role id}, via each team's game and config dividers."""
+    game_div = _game_divider_ids()
+    return {
+        team: game_div[game]
+        for team, game in _team_game.items()
+        if game and game in game_div
+    }

core/member_sync.py

@@ -0,0 +1,559 @@
+"""Member synchronization logic - roles, nicknames, birthdays."""
+
+from __future__ import annotations
+
+import calendar
+import logging
+from datetime import datetime, date
+from dataclasses import dataclass, field
+from zoneinfo import ZoneInfo
+
+import discord
+
+import config
+from . import fienta, sheets
+
+log = logging.getLogger(__name__)
+
+
+def resolve_team(member: discord.Member) -> str | None:
+    """Team a member is registered on: Fienta first (by ID, then username),
+    then the sheet by username. Fienta is authoritative; the sheet is fallback."""
+    return (
+        fienta.get_team_for_userid(member.id)
+        or fienta.get_team_for_username(member.name)
+        or sheets.get_team_for_username(member.name)
+    )
+
+
+def all_managed_team_names() -> set[str]:
+    """Union of every team name from Fienta and the sheet - the only role names
+    team sync ever adds or removes."""
+    return fienta.all_team_names() | sheets.all_team_names()
+
+
+def team_dividers() -> dict[str, int]:
+    """{team -> divider role id} merged from both sources; Fienta wins on overlap."""
+    merged = dict(sheets.get_team_dividers())
+    merged.update(fienta.get_team_dividers())
+    return merged
+_PLACEHOLDER = {"-", "x", "n/a", "none", "ei"}
+_TZ = ZoneInfo("Europe/Tallinn")
+
+
+def today_local() -> date:
+    """Today's date in Europe/Tallinn — the bot's operational timezone, independent of host TZ."""
+    return datetime.now(_TZ).date()
+
+
+def _shift_year_safe(d: date, year: int) -> date:
+    """Move `d` to `year`; Feb 29 falls back to Feb 28 when the target year is non-leap."""
+    try:
+        return d.replace(year=year)
+    except ValueError:
+        return d.replace(year=year, day=28)
+
+
+def _is_placeholder(val: str) -> bool:
+    """Return True if a sheet cell value is an intentional empty marker."""
+    return not val.strip() or val.strip().lower() in _PLACEHOLDER
+
+
+# Maps sheet role values to Discord role names where they differ
+ROLE_NAME_MAP: dict[str, str] = {
+    "Juht": "Tiimijuht",
+    "Admin": "+",
+}
+
+
+@dataclass
+class SyncResult:
+    """Tracks what happened during a sync operation."""
+    nickname_changed: bool = False
+    roles_added: list[str] = field(default_factory=list)
+    birthday_soon: bool = False
+    birthday_today: bool = False
+    not_found: bool = False
+    errors: list[str] = field(default_factory=list)
+    synced: bool = False  # True when no errors; caller writes this to the sheet
+
+    @property
+    def changed(self) -> bool:
+        return self.nickname_changed or self.roles_added
+
+
+@dataclass
+class TeamSyncResult:
+    """What happened when syncing one member's tournament team role."""
+    added: str | None = None       # team role name granted, if any
+    removed: list[str] = field(default_factory=list)  # stale team roles taken away
+    created: str | None = None     # team role name auto-created in the guild, if any
+    divider_added: str | None = None  # game divider role granted as participant tag
+    divider_removed: list[str] = field(default_factory=list)  # stale divider roles taken away
+    errors: list[str] = field(default_factory=list)
+
+    @property
+    def changed(self) -> bool:
+        return bool(self.added or self.removed or self.divider_added or self.divider_removed)
+
+
+@dataclass
+class TeamSyncSummary:
+    """Aggregate outcome of a whole-guild team-role sync."""
+    scanned: int = 0
+    assigned: int = 0
+    removed: int = 0
+    created: list[str] = field(default_factory=list)
+    positioned: int = 0                               # team roles moved under a divider
+    divider_assigned: int = 0                         # members given their game divider role
+    divider_removed: int = 0                          # stale game divider roles taken away
+    changes: list[str] = field(default_factory=list)  # human-readable per-member lines
+    errors: list[str] = field(default_factory=list)
+
+
+def _format_nickname(full_name: str) -> str:
+    """Format a nickname from a full name: first name + last name initial.
+
+    Examples:
+        'Mari Tamm'       -> 'Mari T'
+        'Mari-Liis Tamm'  -> 'Mari-Liis T'
+        'Jaan'            -> 'Jaan'
+    """
+    parts = full_name.strip().split()
+    if len(parts) < 2:
+        return full_name.strip()
+    first = parts[0]  # preserves hyphenated names like Mari-Liis
+    last_initial = parts[-1][0].upper()
+    return f"{first} {last_initial}"
+
+
+def _parse_roles(roles_str: str) -> list[str]:
+    """Parse comma-separated role names from the sheet."""
+    if not roles_str:
+        return []
+    return [r.strip().rstrip(".,;:!?") for r in str(roles_str).split(",") if r.strip()]
+
+
+def _parse_birthday(raw: str) -> date | None:
+    """Parse a birthday string robustly. Returns None for garbage/placeholder values."""
+    raw = str(raw).strip()
+    if _is_placeholder(raw):
+        return None
+    today = today_local()
+    for fmt, has_year in [("%d/%m/%Y", True), ("%Y-%m-%d", True), ("%m-%d", False)]:
+        try:
+            parsed = datetime.strptime(raw, fmt).date()
+            if has_year and not (1920 <= parsed.year <= today.year):
+                return None  # unrealistic year (formula artefact, future year, etc.)
+            return parsed if has_year else parsed.replace(year=today.year)
+        except ValueError:
+            continue
+    return None
+
+
+def _is_birthday_soon(birthday_str: str, window_days: int | None = None) -> bool:
+    """Check if a birthday falls within the configured window."""
+    bday = _parse_birthday(birthday_str)
+    if bday is None:
+        return False
+    window = window_days or config.BIRTHDAY_WINDOW_DAYS
+    today = today_local()
+    this_year_bday = _shift_year_safe(bday, today.year)
+    if this_year_bday < today:
+        this_year_bday = _shift_year_safe(bday, today.year + 1)
+    delta = (this_year_bday - today).days
+    return 0 <= delta <= window
+
+
+def is_birthday_today(birthday_str: str) -> bool:
+    """Return True if today is the member's birthday (any supported date format).
+
+    Feb 29 babies are observed on Feb 28 in non-leap years.
+    """
+    bday = _parse_birthday(birthday_str)
+    if bday is None:
+        return False
+    today = today_local()
+    if bday.month == today.month and bday.day == today.day:
+        return True
+    if (
+        bday.month == 2 and bday.day == 29
+        and today.month == 2 and today.day == 28
+        and not calendar.isleap(today.year)
+    ):
+        return True
+    return False
+
+
+async def sync_member(
+    member: discord.Member,
+    guild: discord.Guild,
+) -> SyncResult:
+    """Synchronize a single member's nickname and roles based on sheet data.
+
+    Also populates Discord ID in the sheet if missing, and updates username.
+    Returns a SyncResult describing what happened.
+    """
+    result = SyncResult()
+
+    # Look up member in sheet cache
+    row = sheets.find_member(member.id, member.name)
+    if row is None:
+        result.not_found = True
+        return result
+
+    # --- Backfill User ID if missing ---
+    raw_id = str(row.get("User ID", "")).strip()
+    if not raw_id or raw_id == "0":
+        await sheets.set_user_id(member.name, member.id)
+
+    # --- Update Discord username in sheet if it changed ---
+    sheet_username = str(row.get("Discord", "")).strip()
+    if sheet_username.lower() != member.name.lower():
+        await sheets.update_username(member.id, member.name)
+
+    # --- Nickname (Nimi = real name, formatted as first name + last initial) ---
+    nimi = str(row.get("Nimi", "")).strip()
+    desired_nick = _format_nickname(nimi) if nimi else None
+    if desired_nick and member.nick != desired_nick:
+        try:
+            await member.edit(nick=desired_nick)
+            result.nickname_changed = True
+        except discord.Forbidden:
+            log.debug("No permission to set nickname for %s (likely admin), skipping", member)
+        except discord.HTTPException as e:
+            result.errors.append(f"Hüüdnime viga kasutajale {member}: {e}")
+
+    # --- Roles (from Organisatsioon, Valdkond, Roll columns; values may be comma-separated) ---
+    desired_role_names: list[str] = []
+    for col in ("Organisatsioon", "Valdkond", "Roll"):
+        val = str(row.get(col, "")).strip()
+        if not _is_placeholder(val):
+            desired_role_names.extend(
+                r for r in _parse_roles(val)
+                if not _is_placeholder(r)
+            )
+    desired_roles: list[discord.Role] = []
+    for rname in desired_role_names:
+        rname = ROLE_NAME_MAP.get(rname, rname)
+        role = discord.utils.get(guild.roles, name=rname)
+        if role:
+            desired_roles.append(role)
+        else:
+            result.errors.append(f"Rolli '{rname}' ei leitud serverist")
+
+    # Base roles that every synced member must have
+    for rid in config.BASE_ROLE_IDS:
+        role = guild.get_role(rid)
+        if role:
+            desired_roles.append(role)
+        else:
+            result.errors.append(f"Baasrolli ID {rid} ei leitud serverist")
+
+    # Roles to add (desired but member doesn't have)
+    to_add = [r for r in desired_roles if r not in member.roles]
+    # (we currently only ADD the desired roles, not remove extras - safe default)
+
+    if to_add:
+        try:
+            await member.add_roles(*to_add, reason="Sheet sync")
+            result.roles_added = [r.name for r in to_add]
+        except discord.Forbidden:
+            log.debug("No permission to add roles for %s (likely admin), skipping", member)
+        except discord.HTTPException as e:
+            result.errors.append(f"Rolli viga kasutajale {member}: {e}")
+
+    # --- Birthday check ---
+    birthday_str = str(row.get("Sünnipäev", "")).strip()
+    if not _is_placeholder(birthday_str):
+        result.birthday_today = is_birthday_today(birthday_str)
+        result.birthday_soon = _is_birthday_soon(birthday_str)
+
+    # --- Mark synced (caller is responsible for writing to sheet) ---
+    result.synced = not bool(result.errors)
+
+    return result
+
+
+async def sync_team_role(
+    member: discord.Member,
+    guild: discord.Guild,
+) -> TeamSyncResult:
+    """Give one member their tournament team role from the registration sheet.
+
+    Roster-INDEPENDENT: unlike :func:`sync_member` this does not touch the
+    internal member sheet at all. It matches the member's Discord username
+    against the team sheet caches (populated by ``sheets.refresh_teams``) and:
+
+    * grants the role for the team they're registered on (auto-creating that
+      role in the guild when it does not exist yet);
+    * removes any *other* team role they still carry (left / switched teams);
+    * grants their game's divider role as a participant tag (and strips any
+      other configured divider role they still carry, i.e. switched game).
+
+    Only team role NAMES present in the team sheet and the configured divider
+    role IDs (``config.TEAM_DIVIDERS``) are ever added or removed, so no
+    unrelated role is ever at risk. When ``TEAM_SHEET_ID`` is unset the caches
+    are empty and this is a no-op returning an unchanged result.
+    """
+    result = TeamSyncResult()
+
+    team_name = resolve_team(member)
+    all_teams = all_managed_team_names()
+    if not all_teams:
+        return result  # feature switched off (no Fienta token and no team sheet)
+
+    desired: discord.Role | None = None
+    if team_name:
+        desired = discord.utils.get(guild.roles, name=team_name)
+        if desired is None:
+            try:
+                desired = await guild.create_role(name=team_name, reason="Team sync: uus tiim")
+                result.created = team_name
+                log.info("Created team role %r for %s", team_name, member)
+            except discord.Forbidden:
+                result.errors.append(f"Tiimirolli '{team_name}' loomiseks puudub õigus")
+            except discord.HTTPException as e:
+                result.errors.append(f"Tiimirolli '{team_name}' loomine ebaõnnestus: {e}")
+
+    # Team roles held but no longer registered for (switched teams / dropped out).
+    to_remove = [r for r in member.roles if r.name in all_teams and r.name != team_name]
+
+    if desired is not None and desired not in member.roles:
+        try:
+            await member.add_roles(desired, reason="Team sync")
+            result.added = desired.name
+        except discord.Forbidden:
+            log.debug("No permission to add team role for %s, skipping", member)
+        except discord.HTTPException as e:
+            result.errors.append(f"Tiimirolli viga kasutajale {member}: {e}")
+
+    if to_remove:
+        try:
+            await member.remove_roles(*to_remove, reason="Team sync: tiim vahetus")
+            result.removed = [r.name for r in to_remove]
+        except discord.Forbidden:
+            log.debug("No permission to remove team roles for %s, skipping", member)
+        except discord.HTTPException as e:
+            result.errors.append(f"Tiimirolli eemaldamise viga kasutajale {member}: {e}")
+
+    # --- Participant divider role (the game's divider role doubles as a tag) ---
+    # Grant the divider role for the member's team's game, and strip any other
+    # configured divider role (switched game / dropped out). Matched by ID, so
+    # only the roles named in config.TEAM_DIVIDERS are ever touched.
+    divider_ids = set(config.TEAM_DIVIDERS.values())
+    want_divider_id = team_dividers().get(team_name) if team_name else None
+    want_divider = guild.get_role(want_divider_id) if want_divider_id else None
+
+    if want_divider is not None and want_divider not in member.roles:
+        try:
+            await member.add_roles(want_divider, reason="Team sync: mänguosaleja")
+            result.divider_added = want_divider.name
+        except discord.Forbidden:
+            log.debug("No permission to add divider role for %s, skipping", member)
+        except discord.HTTPException as e:
+            result.errors.append(f"Eraldajarolli viga kasutajale {member}: {e}")
+
+    stale_dividers = [
+        r for r in member.roles if r.id in divider_ids and r.id != want_divider_id
+    ]
+    if stale_dividers:
+        try:
+            await member.remove_roles(*stale_dividers, reason="Team sync: mäng vahetus")
+            result.divider_removed = [r.name for r in stale_dividers]
+        except discord.Forbidden:
+            log.debug("No permission to remove divider roles for %s, skipping", member)
+        except discord.HTTPException as e:
+            result.errors.append(f"Eraldajarolli eemaldamise viga kasutajale {member}: {e}")
+
+    return result
+
+
+def plan_team_positions(
+    ordered_names: list[str],
+    managed: set[str],
+    placements: dict[str, list[str]],
+) -> dict[str, int]:
+    """Work out the new position of every team role that needs to move.
+
+    ``ordered_names`` is every role name ascending by Discord position, so index
+    0 is the bottom of the role list (@everyone) and the last entry is the top.
+    ``placements`` maps a divider role name to the team roles that belong under
+    it. Roles in ``managed`` are never moved (integration-managed roles, and
+    anything at or above the bot's own role, cannot be repositioned).
+
+    Teams are pulled out of the list and re-inserted immediately below their
+    divider, sorted so they read alphabetically top-to-bottom in the Discord UI.
+    Everything else keeps its relative order; a role only appears in the result
+    when its position actually changed. Roles are matched by name, mirroring the
+    rest of the team sync - with duplicate role names the lowest one wins.
+    """
+    present = set(ordered_names)
+    placeable: dict[str, list[str]] = {}
+    for divider, teams in placements.items():
+        if divider not in present or divider in managed:
+            continue
+        # Descending here because the list is bottom-up: reversing it renders
+        # alphabetically downwards from the divider.
+        block = sorted({t for t in teams if t in present and t not in managed}, reverse=True)
+        if block:
+            placeable[divider] = block
+    if not placeable:
+        return {}
+
+    movable = {t for block in placeable.values() for t in block}
+    remaining = [n for n in ordered_names if n not in movable]
+    for divider, block in placeable.items():
+        idx = remaining.index(divider)
+        remaining[idx:idx] = block
+
+    old_pos = {name: i for i, name in enumerate(ordered_names)}
+    return {
+        name: i
+        for i, name in enumerate(remaining)
+        if name not in managed and old_pos.get(name) != i
+    }
+
+
+async def apply_team_role_positions(
+    guild: discord.Guild,
+    log: logging.Logger = log,
+) -> tuple[int, list[str]]:
+    """Move every team role directly beneath its configured divider role.
+
+    Driven by the ``TEAM_DIVIDER_*`` config: teams whose sheet section matched
+    one are placed under that divider role, the rest are left exactly where they
+    are. Dividers are configured by role ID, so a rename never breaks placement;
+    the ID is resolved to the role's current name here, and the ordering maths
+    downstream is name-based. Returns ``(roles_moved, errors)``; a no-op returns
+    ``(0, [])``.
+    """
+    team_divider_ids = team_dividers()  # {team: divider role ID}, both sources
+    if not team_divider_ids:
+        return 0, []  # no dividers configured, or nothing matched
+
+    errors: list[str] = []
+    # Resolve each configured divider ID to its role once, then key placements by
+    # that role's current name for the name-based positioning maths below.
+    placements: dict[str, list[str]] = {}
+    resolved: dict[int, discord.Role | None] = {}
+    for team, divider_id in team_divider_ids.items():
+        if divider_id not in resolved:
+            resolved[divider_id] = guild.get_role(divider_id)
+            if resolved[divider_id] is None:
+                errors.append(f"Eraldajarolli ID {divider_id} ei leitud serverist")
+        divider = resolved[divider_id]
+        if divider is not None:
+            placements.setdefault(divider.name, []).append(team)
+    if not placements:
+        return 0, errors
+
+    by_name: dict[str, discord.Role] = {}
+    for role in sorted(guild.roles, key=lambda r: r.position):
+        by_name.setdefault(role.name, role)
+
+    # The bot can only reorder roles strictly below its own highest role.
+    bot_top = max((r.position for r in guild.me.roles), default=0)
+    for divider in list(placements):
+        role = by_name.get(divider)
+        if role is None:
+            errors.append(f"Eraldajarolli '{divider}' ei leitud serverist")
+            placements.pop(divider)
+        elif role.position >= bot_top:
+            errors.append(f"Eraldaja '{divider}' on boti rollist kõrgemal - ei saa liigutada")
+            placements.pop(divider)
+    if not placements:
+        return 0, errors
+
+    ordered = sorted(guild.roles, key=lambda r: r.position)
+    ordered_names = [r.name for r in ordered]
+    managed = {r.name for r in ordered if r.managed or r.position >= bot_top}
+    plan = plan_team_positions(ordered_names, managed, placements)
+    if not plan:
+        return 0, errors  # already in the right place
+
+    positions = {by_name[n]: p for n, p in plan.items() if n in by_name}
+    try:
+        await guild.edit_role_positions(positions=positions)
+    except discord.Forbidden:
+        errors.append("Tiimirollide järjestamiseks puudub õigus")
+        return 0, errors
+    except discord.HTTPException as e:
+        errors.append(f"Tiimirollide järjestamine ebaõnnestus: {e}")
+        # 50013 here despite Manage Roles usually means a role in the batch sits
+        # at/above the bot's top role. Log the batch vs bot_top to pinpoint it.
+        log.warning(
+            "edit_role_positions failed (%s); bot_top=%d; batch=%s",
+            e, bot_top,
+            sorted(
+                ((r.name, r.position, target) for r, target in positions.items()),
+                key=lambda x: -x[1],
+            ),
+        )
+        return 0, errors
+    log.info("Positioned %d team role(s) under their dividers", len(positions))
+    return len(positions), errors
+
+
+async def sync_all_team_roles(
+    guild: discord.Guild,
+    log: logging.Logger = log,
+) -> TeamSyncSummary:
+    """Run :func:`sync_team_role` for every human member of ``guild``.
+
+    Assumes the team caches are already fresh (caller runs ``refresh_teams``
+    first). Returns an aggregate summary for reporting.
+    """
+    summary = TeamSyncSummary()
+    for member in guild.members:
+        if member.bot:
+            continue
+        summary.scanned += 1
+        res = await sync_team_role(member, guild)
+        if res.created:
+            summary.created.append(res.created)
+        if res.errors:
+            summary.errors.extend(res.errors)
+        if res.added:
+            summary.assigned += 1
+        if res.removed:
+            summary.removed += len(res.removed)
+        if res.divider_added:
+            summary.divider_assigned += 1
+        if res.divider_removed:
+            summary.divider_removed += len(res.divider_removed)
+        if res.changed:
+            bits: list[str] = []
+            if res.added:
+                bits.append(f"+{res.added}")
+            if res.removed:
+                bits.append("-" + ", -".join(res.removed))
+            if res.divider_added:
+                bits.append(f"+[{res.divider_added}]")
+            if res.divider_removed:
+                bits.append("-[" + "], -[".join(res.divider_removed) + "]")
+            summary.changes.append(f"{member.display_name}: {', '.join(bits)}")
+
+    # Placement runs after the grant/remove pass so roles created this run are
+    # positioned in the same sweep rather than waiting for the next one.
+    summary.positioned, position_errors = await apply_team_role_positions(guild, log)
+    summary.errors.extend(position_errors)
+    return summary
+
+
+async def announce_birthday(
+    member: discord.Member,
+    bot: discord.Client,
+) -> None:
+    """Send a birthday-coming-soon announcement to the configured channel."""
+    channel = bot.get_channel(config.BIRTHDAY_CHANNEL_ID)
+    if channel is None:
+        log.warning("Birthday channel %s not found", config.BIRTHDAY_CHANNEL_ID)
+        return
+
+    row = sheets.find_member(member.id, member.name)
+    bday_str = str(row.get("Sünnipäev", "")) if row else "?"
+
+    await channel.send(
+        f"🎂 @here **{member.display_name}** sünnipäev on täna! 🥳 Palju-palju õnne sünnipäevaks! 🎉"
+    )

core/pb_client.py

@@ -0,0 +1,180 @@
+"""Async PocketBase REST client for TipiLAN Bot.
+
+Handles admin authentication (auto-refreshed), and CRUD operations on the
+economy_users collection.  Uses aiohttp, which discord.py already depends on.
+
+Environment variables (set in .env):
+    PB_URL              Base URL of PocketBase  (default: http://127.0.0.1:8090)
+    PB_ADMIN_EMAIL      PocketBase admin e-mail
+    PB_ADMIN_PASSWORD   PocketBase admin password
+    PB_ECONOMY_COLLECTION_DEV / PB_ECONOMY_COLLECTION_ECONOMY
+"""
+
+from __future__ import annotations
+
+import asyncio
+import logging
+import time
+from typing import Any
+
+import aiohttp
+
+import config
+
+
+class DatabaseError(Exception):
+    """Raised when PocketBase is unreachable or returns an error."""
+    pass
+
+_log = logging.getLogger("tipiCOIN.pb")
+
+PB_URL = config.PB_URL
+PB_ADMIN_EMAIL = config.PB_ADMIN_EMAIL
+PB_ADMIN_PASSWORD = config.PB_ADMIN_PASSWORD
+ECONOMY_COLLECTION = config.PB_ECONOMY_COLLECTION
+
+_TIMEOUT = aiohttp.ClientTimeout(total=4)
+
+# ---------------------------------------------------------------------------
+# Persistent session (created once, reused for the lifetime of the process)
+# ---------------------------------------------------------------------------
+_session: aiohttp.ClientSession | None = None
+
+
+def _get_session() -> aiohttp.ClientSession:
+    global _session
+    if _session is None or _session.closed:
+        _session = aiohttp.ClientSession(timeout=_TIMEOUT)
+    return _session
+
+
+# ---------------------------------------------------------------------------
+# Auth token cache
+# ---------------------------------------------------------------------------
+_token: str = ""
+_token_expiry: float = 0.0
+_auth_lock = asyncio.Lock()
+
+
+async def _ensure_auth() -> str:
+    global _token, _token_expiry
+    async with _auth_lock:
+        if time.monotonic() < _token_expiry:
+            return _token
+        session = _get_session()
+        try:
+            async with session.post(
+                f"{PB_URL}/api/collections/_superusers/auth-with-password",
+                json={"identity": PB_ADMIN_EMAIL, "password": PB_ADMIN_PASSWORD},
+            ) as resp:
+                if resp.status != 200:
+                    text = await resp.text()
+                    raise DatabaseError(f"PocketBase auth failed ({resp.status}): {text}")
+                data = await resp.json()
+                _token = data["token"]
+                _token_expiry = time.monotonic() + 13 * 24 * 3600  # refresh well before expiry
+                _log.debug("PocketBase admin token refreshed")
+        except (aiohttp.ClientConnectorError, asyncio.TimeoutError) as e:
+            raise DatabaseError(f"Database unavailable: {e}") from e
+    return _token
+
+
+async def _hdrs() -> dict[str, str]:
+    return {"Authorization": await _ensure_auth()}
+
+
+def _invalidate_token() -> None:
+    global _token_expiry
+    _token_expiry = 0.0
+
+
+# ---------------------------------------------------------------------------
+# Request helper with auth-retry and error wrapping
+# ---------------------------------------------------------------------------
+
+async def _request(method: str, url: str, **kwargs: Any) -> Any:
+    """Make an authenticated request, retrying once on 401/403 by re-authing.
+
+    Returns the parsed JSON body. Raises DatabaseError on connection issues or
+    non-2xx responses after retrying.
+    """
+    session = _get_session()
+    for attempt in range(2):
+        kwargs["headers"] = await _hdrs()
+        try:
+            async with session.request(method, url, **kwargs) as resp:
+                if resp.status in (401, 403) and attempt == 0:
+                    _invalidate_token()
+                    continue
+                if not resp.ok:
+                    text = await resp.text()
+                    raise DatabaseError(f"Database unavailable: {resp.status}, {text}")
+                return await resp.json()
+        except (aiohttp.ClientConnectorError, asyncio.TimeoutError) as e:
+            raise DatabaseError(f"Database unavailable: {e}") from e
+
+
+# ---------------------------------------------------------------------------
+# CRUD helpers
+# ---------------------------------------------------------------------------
+
+async def get_record(user_id: str) -> dict[str, Any] | None:
+    """Fetch one economy record by Discord user_id. Returns None if not found."""
+    data = await _request(
+        "GET",
+        f"{PB_URL}/api/collections/{ECONOMY_COLLECTION}/records",
+        params={"filter": f'user_id="{user_id}"', "perPage": 1},
+    )
+    items = data.get("items", [])
+    return items[0] if items else None
+
+
+async def create_record(record: dict[str, Any]) -> dict[str, Any]:
+    """Create a new economy record. Returns the created record (includes PB id)."""
+    return await _request(
+        "POST",
+        f"{PB_URL}/api/collections/{ECONOMY_COLLECTION}/records",
+        json=record,
+    )
+
+
+async def update_record(record_id: str, data: dict[str, Any]) -> dict[str, Any]:
+    """PATCH an existing record by its PocketBase record id."""
+    return await _request(
+        "PATCH",
+        f"{PB_URL}/api/collections/{ECONOMY_COLLECTION}/records/{record_id}",
+        json=data,
+    )
+
+
+async def get_collection_fields() -> set[str]:
+    """Return the field names defined on the economy collection's schema."""
+    data = await _request("GET", f"{PB_URL}/api/collections/{ECONOMY_COLLECTION}")
+    return {f["name"] for f in data.get("fields", [])}
+
+
+async def count_records() -> int:
+    """Return the total number of records in the collection (single cheap request)."""
+    data = await _request(
+        "GET",
+        f"{PB_URL}/api/collections/{ECONOMY_COLLECTION}/records",
+        params={"perPage": 1, "page": 1},
+    )
+    return int(data.get("totalItems", 0))
+
+
+async def list_all_records(page_size: int = 500) -> list[dict[str, Any]]:
+    """Fetch every record in the collection, handling PocketBase pagination."""
+    results: list[dict[str, Any]] = []
+    page = 1
+    while True:
+        data = await _request(
+            "GET",
+            f"{PB_URL}/api/collections/{ECONOMY_COLLECTION}/records",
+            params={"perPage": page_size, "page": page},
+        )
+        batch = data.get("items", [])
+        results.extend(batch)
+        if len(batch) < page_size:
+            return results
+        page += 1

core/sheets.py

@@ -0,0 +1,499 @@
+"""Google Sheets integration - read/write member data via gspread.
+
+Public network-hitting functions are async and delegate the blocking gspread
+work to `asyncio.to_thread` so the discord.py event loop is not stalled
+(stalled loops drop gateway heartbeats and can disconnect the bot).
+Pure-cache helpers (get_cache, find_*) remain sync.
+"""
+
+import asyncio
+import logging
+import re
+from dataclasses import dataclass, field
+
+import gspread
+from google.oauth2.service_account import Credentials
+
+import config
+
+log = logging.getLogger(__name__)
+
+# Scopes needed: read + write to Sheets
+SCOPES = [
+    "https://www.googleapis.com/auth/spreadsheets",
+    "https://www.googleapis.com/auth/drive",
+]
+
+# ---------------------------------------------------------------------------
+# Expected sheet columns (header row):
+#   Nimi | Organisatsioon | Meil | Discord | User ID | Sünnipäev |
+#   Telefon | Valdkond | Roll | Discordis synced? | Groupi lisatud?
+#
+# - Nimi              : member's real name (used as Discord nickname)
+# - Organisatsioon    : organisation value - maps to a Discord role
+# - Meil              : email address (read-only for bot)
+# - Discord           : Discord username for initial matching
+# - User ID           : numeric Discord user ID (bot can populate this)
+# - Sünnipäev         : birthday date string (YYYY-MM-DD or MM-DD)
+# - Telefon           : phone number (read-only for bot)
+# - Valdkond          : field/area value - maps to a Discord role
+# - Roll              : role value - maps to a Discord role
+# - Discordis synced? : TRUE/FALSE - bot writes this after confirming sync
+# - Groupi lisatud?   : group membership flag (managed externally)
+# ---------------------------------------------------------------------------
+
+EXPECTED_HEADERS = [
+    "Nimi",
+    "Organisatsioon",
+    "Meil",
+    "Discord",
+    "User ID",
+    "Sünnipäev",
+    "Telefon",
+    "Valdkond",
+    "Roll",
+    "Discordis synced?",
+    "Groupi lisatud?",
+]
+
+_client: gspread.Client | None = None
+_worksheet: gspread.Worksheet | None = None
+
+# In-memory cache: list of dicts (one per row)
+_cache: list[dict] = []
+
+
+def _get_worksheet() -> gspread.Worksheet:
+    """Authenticate and return the first worksheet of the configured sheet."""
+    global _client, _worksheet
+    creds = Credentials.from_service_account_file(config.GOOGLE_CREDS_PATH, scopes=SCOPES)
+    _client = gspread.authorize(creds)
+    spreadsheet = _client.open_by_key(config.SHEET_ID)
+    _worksheet = spreadsheet.sheet1
+    return _worksheet
+
+
+def _ensure_headers(ws: gspread.Worksheet) -> None:
+    """Verify the header row matches what we expect.
+
+    The production sheet is owner-managed and its header row (row 1) is a
+    protected range, so the bot must NOT write to it — attempting to do so
+    raises `APIError [400]: You are trying to edit a protected cell or object`
+    and aborts the whole refresh. We only log a mismatch so it can be fixed
+    by hand; column lookups still work as long as the headers we rely on exist.
+    """
+    existing = ws.row_values(1)
+    if existing != EXPECTED_HEADERS:
+        missing = [h for h in EXPECTED_HEADERS if h not in existing]
+        log.warning(
+            "Sheet header row does not match EXPECTED_HEADERS "
+            "(missing/renamed: %s). Expected %s, found %s. "
+            "Not writing to the (protected) header row; fix it manually if needed.",
+            missing or "none — order/whitespace differs",
+            EXPECTED_HEADERS,
+            existing,
+        )
+
+
+def _refresh_sync() -> list[dict]:
+    global _cache
+    ws = _get_worksheet()
+    _ensure_headers(ws)
+    # head=1: row 1 is the header; row 2 is a formula/stats row - skip it
+    records = ws.get_all_records(head=1)
+    _cache = records[1:]  # drop the formula row (row 2) from the cache
+    return _cache
+
+
+async def refresh() -> list[dict]:
+    """Pull all rows from the sheet into the in-memory cache (non-blocking)."""
+    return await asyncio.to_thread(_refresh_sync)
+
+
+def get_cache() -> list[dict]:
+    """Return the current in-memory cache without re-querying."""
+    return _cache
+
+
+def find_member_by_id(discord_id: int) -> dict | None:
+    """Look up a member row by Discord user ID."""
+    for row in _cache:
+        raw = row.get("User ID", "")
+        if str(raw).strip() == str(discord_id):
+            return row
+    return None
+
+
+def find_member_by_username(username: str) -> dict | None:
+    """Look up a member row by Discord username (case-insensitive)."""
+    for row in _cache:
+        if str(row.get("Discord", "")).strip().lower() == username.lower():
+            return row
+    return None
+
+
+def find_member(discord_id: int, username: str) -> dict | None:
+    """Try ID first, fall back to username."""
+    return find_member_by_id(discord_id) or find_member_by_username(username)
+
+
+# ---- Write helpers --------------------------------------------------------
+
+def _row_index_for_member(discord_id: int | None = None, username: str | None = None) -> int | None:
+    """Return the 1-based sheet row index for a member (header = row 2, data from row 3)."""
+    for idx, row in enumerate(_cache):
+        if discord_id and str(row.get("User ID", "")).strip() == str(discord_id):
+            return idx + 3  # +3 because header is row 2, data starts row 3, idx is 0-based
+        if username and str(row.get("Discord", "")).strip().lower() == username.lower():
+            return idx + 3
+    return None
+
+
+def _update_cell_for_member_sync(
+    discord_id: int | None,
+    username: str | None,
+    column_name: str,
+    value: str,
+) -> bool:
+    ws = _worksheet or _get_worksheet()
+    row_idx = _row_index_for_member(discord_id=discord_id, username=username)
+    if row_idx is None:
+        return False
+
+    try:
+        col_idx = EXPECTED_HEADERS.index(column_name) + 1
+    except ValueError:
+        return False
+
+    ws.update([[value]], gspread.utils.rowcol_to_a1(row_idx, col_idx),
+               value_input_option="USER_ENTERED")
+
+    cache_idx = row_idx - 3
+    if 0 <= cache_idx < len(_cache):
+        _cache[cache_idx][column_name] = value
+
+    return True
+
+
+async def update_cell_for_member(
+    discord_id: int | None,
+    username: str | None,
+    column_name: str,
+    value: str,
+) -> bool:
+    """Write a value to a specific column for a member row (non-blocking)."""
+    return await asyncio.to_thread(
+        _update_cell_for_member_sync, discord_id, username, column_name, value
+    )
+
+
+def _batch_set_synced_sync(updates: list[tuple[int, bool]]) -> None:
+    ws = _worksheet or _get_worksheet()
+    col_idx = EXPECTED_HEADERS.index("Discordis synced?") + 1
+    cells = []
+    for discord_id, synced in updates:
+        row_idx = _row_index_for_member(discord_id=discord_id)
+        if row_idx is None:
+            continue
+        cells.append(gspread.Cell(row_idx, col_idx, "TRUE" if synced else "FALSE"))
+        cache_idx = row_idx - 3
+        if 0 <= cache_idx < len(_cache):
+            _cache[cache_idx]["Discordis synced?"] = "TRUE" if synced else "FALSE"
+    if cells:
+        ws.update_cells(cells, value_input_option="USER_ENTERED")
+
+
+async def batch_set_synced(updates: list[tuple[int, bool]]) -> None:
+    """Batch-write 'Discordis synced?' for multiple members (non-blocking)."""
+    await asyncio.to_thread(_batch_set_synced_sync, updates)
+
+
+async def set_user_id(username: str, discord_id: int) -> bool:
+    """Write a Discord user ID for a row matched by Discord username."""
+    return await update_cell_for_member(
+        discord_id=None,
+        username=username,
+        column_name="User ID",
+        value=str(discord_id),
+    )
+
+
+async def set_synced(discord_id: int, synced: bool) -> bool:
+    """Mark a member as synced (TRUE) or not (FALSE)."""
+    return await update_cell_for_member(
+        discord_id=discord_id,
+        username=None,
+        column_name="Discordis synced?",
+        value="TRUE" if synced else "FALSE",
+    )
+
+
+async def update_username(discord_id: int, new_username: str) -> bool:
+    """Update the Discord column for a member (keeps sheet in sync with Discord)."""
+    return await update_cell_for_member(
+        discord_id=discord_id,
+        username=None,
+        column_name="Discord",
+        value=new_username,
+    )
+
+
+def _add_new_member_row_sync(username: str, discord_id: int) -> None:
+    ws = _worksheet or _get_worksheet()
+    row = [""] * len(EXPECTED_HEADERS)
+    row[EXPECTED_HEADERS.index("Discord")] = username
+    row[EXPECTED_HEADERS.index("User ID")] = str(discord_id)
+    row[EXPECTED_HEADERS.index("Discordis synced?")] = "FALSE"
+    ws.append_row(row, value_input_option="USER_ENTERED")
+    new_entry = {h: row[i] for i, h in enumerate(EXPECTED_HEADERS)}
+    _cache.append(new_entry)
+
+
+async def add_new_member_row(username: str, discord_id: int) -> None:
+    """Append a new row pre-filled with Discord username and User ID (non-blocking)."""
+    await asyncio.to_thread(_add_new_member_row_sync, username, discord_id)
+
+
+# ===========================================================================
+# Team registration sheet (a SEPARATE spreadsheet, config.TEAM_SHEET_ID)
+# ---------------------------------------------------------------------------
+# Unlike the member roster this sheet is NOT a single clean table: it stacks
+# several game sections (CS2, LoL, ...) - each with merged title/description
+# rows, its own header row, and a block of team rows - across one or more tabs.
+# So we read raw cell values (get_all_values) and scan for header rows rather
+# than relying on get_all_records, which requires one rectangular table.
+#
+# Each team's players live in one "Lineup" cell, comma-joined, every nickname
+# suffixed with a citizenship marker like "(EST)". Those nicknames ARE the
+# players' Discord usernames; the citizenship is used only as a delimiter
+# (a nickname may itself contain commas) and then discarded.
+# ===========================================================================
+
+# Matches a citizenship marker such as "(EST)" / "(LAT)". Used to split a
+# lineup cell into individual players, then thrown away.
+_CITIZENSHIP_RE = re.compile(r"\(\s*[A-Za-z]{2,4}\s*\)")
+
+_TEAM_NAME_HEADER = "team name"
+_LINEUP_HEADER_PREFIX = "lineup"
+
+# Team-sheet caches (mirrors the member-roster cache above)
+_team_roster: dict[str, list[str]] = {}   # team name -> [Discord username, ...]
+_team_by_username: dict[str, str] = {}     # normalized username -> team name
+_team_names: set[str] = set()              # universe of all team names
+_team_divider: dict[str, int] = {}         # team name -> divider role ID
+
+
+@dataclass(frozen=True)
+class TeamSection:
+    """One game's block of teams within a tab, plus the title row above it.
+
+    The title ("TipiLAN 2026 CS2 Registration Log") is the only thing that says
+    which game and year a block belongs to - the header and team rows below it
+    carry neither - so it is what :func:`resolve_divider` matches against.
+    """
+    title: str = ""
+    rosters: dict[str, list[str]] = field(default_factory=dict)
+
+
+def parse_lineup(cell: str) -> list[str]:
+    """Split one 'Lineup' cell into player nicknames (Discord usernames).
+
+    Players are delimited by their trailing citizenship marker, e.g.
+        'TFT (EST), nqmm (EST), sn1rk (EST)' -> ['TFT', 'nqmm', 'sn1rk']
+    Splitting on the marker (not on commas) keeps nicknames that themselves
+    contain commas or semicolons intact. Falls back to comma-splitting when a
+    cell carries no citizenship markers at all.
+    """
+    cell = str(cell).strip()
+    if not cell:
+        return []
+    names: list[str] = []
+    last = 0
+    matched = False
+    for m in _CITIZENSHIP_RE.finditer(cell):
+        matched = True
+        chunk = cell[last:m.start()].strip().strip(",;").strip()
+        if chunk:
+            names.append(chunk)
+        last = m.end()
+    if not matched:
+        return [p.strip() for p in cell.split(",") if p.strip()]
+    tail = cell[last:].strip().strip(",;").strip()  # stray name after last marker
+    if tail:
+        names.append(tail)
+    return names
+
+
+def _find_col(row: list, matches) -> int | None:
+    for idx, cell in enumerate(row):
+        if matches(str(cell)):
+            return idx
+    return None
+
+
+def _cell(row: list, idx: int) -> str:
+    return str(row[idx]) if 0 <= idx < len(row) else ""
+
+
+def _merged_title(row: list) -> str | None:
+    """Return a row's lone non-empty cell - a merged section title - else None.
+
+    A fully blank row returns None rather than "", so blank separators between
+    sections do not wipe the title we are holding for the next header row.
+    """
+    values = [str(c).strip() for c in row if str(c).strip()]
+    return values[0] if len(values) == 1 else None
+
+
+def parse_team_sections(rows: list[list]) -> list[TeamSection]:
+    """Extract each game's block of teams from a tab's raw rows, with its title.
+
+    Scans for every header row that has both a 'Team Name' and a 'Lineup...'
+    column, then reads the rows beneath it (using that section's own column
+    positions) until the team-name column goes blank or a new header appears.
+    Handles multiple stacked sections with differing layouts in one tab, and
+    tags each with the most recent merged title row seen above it.
+    """
+    sections: list[TeamSection] = []
+    title = ""
+    i, n = 0, len(rows)
+    while i < n:
+        name_col = _find_col(rows[i], lambda c: c.strip().lower() == _TEAM_NAME_HEADER)
+        lineup_col = _find_col(rows[i], lambda c: c.strip().lower().startswith(_LINEUP_HEADER_PREFIX))
+        if name_col is None or lineup_col is None:
+            if (text := _merged_title(rows[i])) is not None:
+                # Accumulate every single-cell row above the header, not just the
+                # last one: sheets stack the "TipiLAN 2026 CS2" title above notice
+                # rows ("If a team withdraws..."), and the later notices must not
+                # clobber the title whose keywords resolve_divider needs.
+                title = f"{title} {text}".strip() if title else text
+            i += 1
+            continue
+        rosters: dict[str, list[str]] = {}
+        i += 1  # move past the header into the data block
+        while i < n:
+            team = _cell(rows[i], name_col).strip()
+            if not team or team.lower() == _TEAM_NAME_HEADER:
+                break  # blank team-name (or a new header) ends this section
+            players = parse_lineup(_cell(rows[i], lineup_col))
+            if players:
+                rosters.setdefault(team, []).extend(players)
+            i += 1
+        if rosters:
+            sections.append(TeamSection(title=title, rosters=rosters))
+        title = ""  # consumed - do not leak it onto the next section
+    return sections
+
+
+def parse_team_rosters(rows: list[list]) -> dict[str, list[str]]:
+    """Flatten every section in a tab into {team_name: [nickname, ...]}."""
+    rosters: dict[str, list[str]] = {}
+    for section in parse_team_sections(rows):
+        for team, players in section.rosters.items():
+            rosters.setdefault(team, []).extend(players)
+    return rosters
+
+
+def resolve_divider(title: str, dividers: dict[str, int] | None = None) -> int | None:
+    """Return the divider role ID configured for a section title, if any.
+
+    A ``TEAM_DIVIDER_<SUFFIX>`` entry matches when every underscore-separated
+    part of its suffix appears as a whole word in the title, so ``CS2`` matches
+    a CS2 section from any year while ``CS2_2026`` matches only the 2026 one.
+    The most specific match (most parts) wins, which lets a year-scoped entry
+    override a general one for the same game.
+    """
+    if dividers is None:
+        dividers = config.TEAM_DIVIDERS
+    haystack = title.lower()
+    best_id: int | None = None
+    best_parts = 0
+    for suffix, role_id in dividers.items():
+        parts = [p for p in suffix.split("_") if p]
+        if not parts or len(parts) <= best_parts:
+            continue
+        if all(re.search(rf"\b{re.escape(p)}\b", haystack) for p in parts):
+            best_id, best_parts = role_id, len(parts)
+    return best_id
+
+
+def build_username_index(rosters: dict[str, list[str]]) -> dict[str, str]:
+    """Invert {team: [usernames]} into {normalized username: team}.
+
+    If the same username appears on two teams the last one wins and a warning
+    is logged (a person is expected to be on exactly one team).
+    """
+    index: dict[str, str] = {}
+    for team, players in rosters.items():
+        for player in players:
+            key = player.strip().lower()
+            if not key:
+                continue
+            if key in index and index[key] != team:
+                log.warning(
+                    "Player %r appears on both %r and %r; using %r",
+                    player, index[key], team, team,
+                )
+            index[key] = team
+    return index
+
+
+def _refresh_teams_sync() -> dict[str, list[str]]:
+    global _team_roster, _team_by_username, _team_names, _team_divider
+    creds = Credentials.from_service_account_file(config.GOOGLE_CREDS_PATH, scopes=SCOPES)
+    client = gspread.authorize(creds)
+    spreadsheet = client.open_by_key(config.TEAM_SHEET_ID)
+
+    rosters: dict[str, list[str]] = {}
+    dividers: dict[str, int] = {}
+    for ws in spreadsheet.worksheets():
+        for section in parse_team_sections(ws.get_all_values()):
+            # Match on the tab name too ("CS2"/"LoL"): it names the game reliably
+            # even when the game/year title row is shadowed by notice rows, while
+            # the section title still supplies the year for year-scoped dividers.
+            divider = resolve_divider(f"{ws.title} {section.title}")
+            for team, players in section.rosters.items():
+                rosters.setdefault(team, []).extend(players)
+                if divider:
+                    dividers[team] = divider
+
+    _team_roster = rosters
+    _team_by_username = build_username_index(rosters)
+    _team_names = set(rosters)
+    _team_divider = dividers
+    return rosters
+
+
+async def refresh_teams() -> dict[str, list[str]]:
+    """Reload the team registration sheet into the in-memory team caches.
+
+    No-op returning {} when TEAM_SHEET_ID is not configured, so the whole
+    feature can be left switched off without touching sync behaviour.
+    """
+    if not config.TEAM_SHEET_ID:
+        return {}
+    return await asyncio.to_thread(_refresh_teams_sync)
+
+
+def get_team_for_username(username: str) -> str | None:
+    """Return the team a Discord username is registered on, or None."""
+    return _team_by_username.get(str(username).strip().lower())
+
+
+def all_team_names() -> set[str]:
+    """Every team name known from the registration sheet (the role universe)."""
+    return set(_team_names)
+
+
+def get_team_rosters() -> dict[str, list[str]]:
+    """Current {team: [usernames]} cache (mainly for diagnostics/tests)."""
+    return _team_roster
+
+
+def get_team_dividers() -> dict[str, int]:
+    """Current {team: divider role ID} cache.
+
+    Only teams whose section title matched a configured TEAM_DIVIDER_* entry
+    appear here, so an empty dict means positioning is switched off.
+    """
+    return dict(_team_divider)

data/birthday_sent.json

@@ -1,5 +0,0 @@
-{
-    "2026-03-14": [
-        "650046190972305409"
-    ]
-}

data/bot_config.json

@@ -1,5 +0,0 @@
-{
-  "allowed_channels": [
-    "1482398641699291357"
-  ]
-}

docs/CHANGELOG.md

@@ -1,904 +0,0 @@
-## v0.36.7
-
-- Fixed high memory usage with large file uploads ([#7572](https://github.com/pocketbase/pocketbase/discussions/7572)).
-
-- Updated the rate limiter reset rules to follow a more traditional fixed window strategy _(aka. to be more close to how it is presented in the UI - allow max X user requests under Ys)_ since several users complained that the older algorithm was not intuitive and not suitable for large intervals.
-    _Approximated sliding window strategy was also suggested as a better compromise option to help minimize traffic spikes right after reset but the additional tracking could introduce some overhead and for now it is left aside until we have more tests._
-
-- Updated `modernc.org/sqlite` to v1.46.2 and SQLite 3.51.3.
-    _⚠️ SQLite 3.51.3 fixed a [database corruption bug](https://sqlite.org/wal.html#walresetbug) that is very unlikely to happen (with PocketBase even more so because we queue on app level all writes and explicit transactions through a single db connection), but still it is advised to upgrade._
-
-- Updated other minor Go and npm deps.
-    _The min Go version in the go.mod of the package was also bumped to Go 1.25.0 because some of the newer dep versions require it._
-
-
-## v0.36.6
-
-- Set `NumberField.OnlyInt:true` for the generated View collection schema fields when a view column expression is known to return int-only values ([#7538](https://github.com/pocketbase/pocketbase/issues/7538)).
-
-- Documented the `unmarshal` JSVM helper ([#7543](https://github.com/pocketbase/pocketbase/issues/7543)).
-
-- Added extra read check after the `Store.GetOrSet` write lock to prevent races overwriting an already existing value.
-
-- Added empty records check for the additional client-side filter's ListRule constraint that was introduced in v0.32.0 ([presentator#206](https://github.com/presentator/presentator/issues/206)).
-
-- Set a fixed `routine.FireAndForget()` debug stack trace limit to 2KB.
-
-- Bumped min Go GitHub action version to 1.26.1 because it comes with some [minor bug and security fixes](https://github.com/golang/go/issues?q=milestone%3AGo1.26.1).
-
-- Typos and other minor doc fixes.
-
-
-## v0.36.5
-
-- Disabled collection and fields name normalization while in IME mode ([#7532](https://github.com/pocketbase/pocketbase/pull/7532); thanks @miaopan607).
-
-- Updated `modernc.org/sqlite` to v1.46.1 _(resets connection state on Tx.Commit failure)_.
-
-
-## v0.36.4
-
-- Made the optional `Bearer` token prefix case-insensitive ([#7525](https://github.com/pocketbase/pocketbase/pull/7525); thanks @benjamesfleming).
-
-- Enabled `$filesystem.s3(...)` and `$filesystem.local(...)` JSVM bindings ([#7526](https://github.com/pocketbase/pocketbase/issues/7526)).
-
-
-## v0.36.3
-
-- Added `Accept-Encoding: identity` to the S3 requests per the suggestion in [#7523](https://github.com/pocketbase/pocketbase/issues/7523).
-    _This should help fixing the 0-bytes file response when S3 API compression is enabled._
-
-- Bumped min Go GitHub action version to 1.26.0 _(it comes with minor [GC performance improvements](https://go.dev/doc/go1.26#runtime))_.
-
-- Other minor fixes _(updated `modernc.org/sqlite` to v1.45.0, updated `goja_nodejs` adding `Buffer.concat`, updated the arguments of `app.DeleteTable(...)`, `app.DeleteView(...)` and other similar methods to make it more clear that they are dangerous and shouldn't be used with untrusted input, etc.)_.
-
-
-## v0.36.2
-
-- Updated `modernc.org/sqlite` to v1.44.3 _(race check fix)_, `goja` _(circular references fix)_ and other go deps.
-
-- Other minor fixes _(updated tests to silence some of the race detector errors, updated `FindFirstRecordByData` with more clear error message when missing or invalid key is used, etc.)_.
-
-
-## v0.36.1
-
-- Reverted the `DISTINCT` with `GROUP BY` replacement optimization from v0.36.0 as it was reported to negatively impact the indexes utilization for some queries
-and the minor performance boost that you may get when used on large records is not enough to justify the more common use ([#7461](https://github.com/pocketbase/pocketbase/discussions/7461)).
-    _A better generic deduplication optimization for large records (aka. records with large `text`/`json` fields or many small ones) will be researched but there are no ETAs._
-
-- Updated `modernc.org/sqlite` to v1.44.2 _(SQLite 3.51.2)_.
-
-- Fixed code comment typos.
-
-
-## v0.36.0
-
-- List query and API rules optimizations:
-    - Removed unnecessary correlated subquery expression when using back-relations via single `relation` field.
-    - Replaced `DISTINCT` with `GROUP BY id` when rows deduplication is needed and when deemed safe.
-        _This should help with having a more stable and predictable performance even if the collection records are on the larger side._
-
-    For some queries and data sets the above 2 optimizations have shown significant improvements but if you notice a performance degradation after upgrading,
-    please open a Q&A discussion with export of your collections structure and the problematic request so that it can be analyzed.
-
-- Added [`strftime(format, timevalue, modifiers...)`](https://pocketbase.io/docs/api-rules-and-filters/#strftimeformat-time-value-modifiers-) date formatting filter and API rules function.
-    It works similarly to the [SQLite `strftime` builtin function](https://sqlite.org/lang_datefunc.html)
-    with the main difference that NULL results will be normalized for consistency with the non-nullable PocketBase `text` and `date` fields.
-    Multi-match expressions are also supported and works the same as if the collection field is referenced, for example:
-    ```js
-    // requires ANY/AT-LEAST-ONE-OF multiRel records to have "created" date matching the formatted string "2026-01"
-    strftime('%Y-%m', multiRel.created) ?= '2026-01'
-
-    // requires ALL multiRel records to have "created" date matching the formatted string "2026-01"
-    strftime('%Y-%m', multiRel.created) = '2026-01'
-    ```
-
-- ⚠️ Minor changes to the `search.ResolverResult` struct _(mostly used internally)_:
-    - Replaced `NoCoalesce` field with the more explicit `NullFallback` _(`NullFallbackDisabled` is the same as `NoCoalesce:true`)_.
-    - Replaced the expression interface of the `MultiMatchSubQuery` field with the concrete struct type `search.MultiMatchSubquery` to avoid excessive type assertions and allow direct mutations of the field.
-
-- Updated `modernc.org/sqlite` to v1.44.1 _(SQLite 3.51.1)_.
-
-- Bumped min Go GitHub action version to 1.25.6 because it comes with some [minor security fixes](https://github.com/golang/go/issues?q=milestone%3AGo1.25.6).
-
-
-## v0.35.1
-
-- Updated `modernc.org/sqlite` to v1.43.0 _(query cancellation race fix)_.
-
-- Other minor UI fixes (normalized relations picker selection and confirmation message when `maxSelect=0/1`, updated node deps).
-
-
-## v0.35.0
-
-- Added `nullString()`, `nullInt()`, `nullFloat()`, `nullBool`, `nullArray()`, `nullObject()` JSVM helpers for scanning nullable columns ([#7396](https://github.com/pocketbase/pocketbase/issues/7396)).
-
-- Store the correct `image/png` as attrs content type when generating a thumb fallback _(e.g. for `webp`)_.
-
-- Trimmed custom uploaded file name and extension from leftover `.` characters after `filesystem.File` normalization.
-    _This was done to prevent issues with external files sync programs that may have special handling for "invisible" files._
-
-- Updated `modernc.org/sqlite` _(v1.41.0 includes prepared statements optimization)_ and other minor Go deps.
-
-
-## v0.34.2
-
-- Bumped JS SDK to v0.26.5 to fix Safari AbortError detection introduced with the previous release ([#7369](https://github.com/pocketbase/pocketbase/issues/7369)).
-
-
-## v0.34.1
-
-- Added missing `:` char to the autocomplete regex ([#7353](https://github.com/pocketbase/pocketbase/pull/7353); thanks @ouvreboite).
-
-- Added "Copy raw JSON" collection dropdown option ([#7357](https://github.com/pocketbase/pocketbase/issues/7357)).
-
-- Updated Go deps and JS SDK.
-
-- Bumped min Go GitHub action version to 1.25.5 because it comes with some [minor security fixes](https://github.com/golang/go/issues?q=milestone%3AGo1.25.5).
-    _The runner action was also updated to `actions/setup-go@v6` since the previous v5 Go source seems [no longer accessible](https://github.com/actions/setup-go/pull/665#issuecomment-3416693714)._
-
-
-## v0.34.0
-
-- Added `@request.body.someField:changed` modifier.
-    It could be used when you want to ensure that a body field either wasn't submitted or was submitted with the same value.
-    Or in other words, if you want to disallow a field change the below 2 expressions would be equivalent:
-    ```js
-    // (old)
-    (@request.body.someField:isset = false || @request.body.someField = someField)
-
-    // (new)
-    @request.body.someField:changed = false
-    ```
-
-- Added `MailerRecordEvent.Meta["info"]` property for the `OnMailerRecordAuthAlertSend` hook.
-
-- Updated the backup restore popup with a short info about the performed restore steps.
-
-- Updated Go deps.
-
-
-## v0.33.0
-
-- Added extra `id` characters validation in addition to the user specified regex pattern ([#7312](https://github.com/pocketbase/pocketbase/issues/7312)).
-    _The following special characters are always forbidden: `./\|"'``<>:?*%$\n\r\t\0 `. Common reserved Windows file names such as `aux`, `prn`, `con`, `nul`, `com1-9`, `lpt1-9` are also not allowed._
-    _The list is not exhaustive but it should help minimizing eventual filesystem compatibility issues in case of wildcards or other loose regex patterns._
-
-- Added `{ALERT_INFO}` placeholder to the auth alert mail template ([#7314](https://github.com/pocketbase/pocketbase/issues/7314)).
-    _⚠️ `mails.SendRecordAuthAlert(app, authRecord, info)` also now accepts a 3rd `info` string argument._
-
-- Updated Go deps.
-
-
-## v0.32.0
-
-- ⚠️ Added extra List/Search API rules checks for the client-side `filter`/`sort` relations.
-
-    This is continuation of the effort to eliminate the risk of information disclosure _(and eventually the side-channel attacks that may originate from that)_.
-
-    So far this was accepted tradeoff between performance, usability and correctness since the solutions at the time weren't really practical _(especially with the back-relations as mentioned in ["Security and performance" section in #4417](https://github.com/pocketbase/pocketbase/discussions/4417))_, but with v0.23+ changes we can implement the extra checks without littering the code too much, with very little impact on the performance and at the same time ensuring better out of the box security _(especially for the cases where users operate with sensitive fields like "code", "token", "secret", etc.)_.
-
-    Similar to the previous release, probably for most users with already configured API rules this change won't be breaking, but if you have an _intermediate/junction collection_ that is "locked" (superusers-only) we no longer will allow the client-side relation filter to pass through it and you'll have to set its List/Search API rule to enable the current user to search in it.
-
-    For example, if you have a client-side filter that targets `rel1.rel2.token`, the client must have not only List/Search API rule access to the main collection BUT also to the collections referenced by "rel1" and "rel2" relation fields.
-
-    Note that this change is only for the **client-side** `filter`/`sort` and doesn't affect the execution of superuser requests, API rules and `expand` - they continue to work the same as it is.
-
-    An optional environment variable to toggle this behavior was considered but for now I think having 2 ways of resolving client-side filters would introduce maintenance burden and can even cause confusion (this change should actually make things more intuitive and clear because we can simply say something like _"you can search by a collection X field only if you have List/Search API rule access to it"_ no matter whether the targeted collection is the request's main collection, the first or last relation from the filter chain, etc.).
-
-    If you stumble on an error or extreme query performance degradation as a result of the extra checks, please open a Q&A discussion with the failing request and export of your collections configuration as JSON (_Settings > Export collections_) and I'll try to investigate it.
-
-- Increased the default SQLite `PRAGMA cache_size` to ~32MB.
-
-- Fixed deadlock when manually triggering the `OnTerminate` hook ([#7305](https://github.com/pocketbase/pocketbase/pull/7305); thanks @yerTools).
-
-- Fixed some code comment typos, regenerated the JSVM types and updated npm dependencies.
-
-- Updated `modernc.org/sqlite` to 1.40.0.
-
-
-## v0.31.0
-
-- Visualize presentable multiple `relation` fields ([#7260](https://github.com/pocketbase/pocketbase/issues/7260)).
-
-- Support Ed25519 in the optional OIDC `id_token` signature validation ([#7252](https://github.com/pocketbase/pocketbase/issues/7252); thanks @shynome).
-
-- Added `ApiScenario.DisableTestAppCleanup` optional field to skip the auto test app cleanup and leave it up to the developers to do the cleanup manually ([#7267](https://github.com/pocketbase/pocketbase/discussions/7267)).
-
-- Added `FileDownloadRequestEvent.ThumbError` field that is populated in case of a thumb generation failure (e.g. unsupported format, timing out, etc.), allowing developers to reject the thumb fallback and/or supply their own custom thumb generation ([#7268](https://github.com/pocketbase/pocketbase/discussions/7268)).
-
-- ⚠️ Disallow client-side filtering and sorting of relations where the collection of the last targeted relation field has superusers-only List/Search API rule to further minimize the risk of eventual side-channel attack.
-    _This should be a non-breaking change for most users, but if you want the old behavior, please open a new Q&A discussion with details about your use case to evaluate making it configurable._
-    _Note also that as mentioned in the "Security and performance" section of [#4417](https://github.com/pocketbase/pocketbase/discussions/4417) and [#5863](https://github.com/pocketbase/pocketbase/discussions/5863), the easiest and recommended solution to protect security sensitive fields (tokens, codes, passwords, etc.) is to mark them as "Hidden" (aka. make them non-API filterable)._
-
-- Regenerated JSVM types and updated npm and Go deps.
-
-
-## v0.30.4
-
-- Fixed `json` field CSS regression introduced with the overflow workaround in v0.30.3 ([#7259](https://github.com/pocketbase/pocketbase/issues/7259)).
-
-
-## v0.30.3
-
-- Fixed legacy identitity field priority check when a username is a valid email address ([#7256](https://github.com/pocketbase/pocketbase/issues/7256)).
-
-- Workaround autocomplete overflow issue with Firefox 144 ([#7223](https://github.com/pocketbase/pocketbase/issues/7223)).
-
-- Updated `modernc.org/sqlite` to 1.39.1 (SQLite 3.50.4).
-
-
-## v0.30.2
-
-- Bumped min Go GitHub action version to 1.24.8 since it comes with some [minor security fixes](https://github.com/golang/go/issues?q=milestone%3AGo1.24.8+label%3ACherryPickApproved).
-
-
-## v0.30.1
-
-- ⚠️ Excluded the `lost+found` directory from the backups ([#7208](https://github.com/pocketbase/pocketbase/pull/7208); thanks @lbndev).
-    _If for some reason you want to keep it, you can restore it by editing the `e.Exclude` list of the `OnBackupCreate` and `OnBackupRestore` hooks._
-
-- Minor tests improvements (disabled initial superuser creation for the test app to avoid cluttering the std output, added more tests for the `s3.Uploader.MaxConcurrency`, etc.).
-
-- Updated `modernc.org/sqlite` and other Go dependencies.
-
-
-## v0.30.0
-
-- Eagerly escape the S3 request path following the same rules as in the S3 signing header ([#7153](https://github.com/pocketbase/pocketbase/issues/7153)).
-
-- Added Lark OAuth2 provider ([#7130](https://github.com/pocketbase/pocketbase/pull/7130); thanks @mashizora).
-
-- Increased test tokens `exp` claim to minimize eventual issues with reproducible builds ([#7123](https://github.com/pocketbase/pocketbase/issues/7123)).
-
-- Added `os.Root` bindings to the JSVM ([`$os.openRoot`](https://pocketbase.io/jsvm/functions/_os.openRoot.html), [`$os.openInRoot`](https://pocketbase.io/jsvm/functions/_os.openInRoot.html)).
-
-- Added `osutils.IsProbablyGoRun()` helper to loosely check if the program was started using `go run`.
-
-- Various minor UI improvements (updated collections indexes UI, enabled seconds in the datepicker, updated helper texts, etc.).
-
-- ⚠️ Updated the minimum package Go version to 1.24.0 and bumped Go dependencies.
-
-
-## v0.29.3
-
-- Try to forward Apple OAuth2 POST redirect user's name so that it can be returned (and eventually assigned) with the success response of the all-in-one auth call ([#7090](https://github.com/pocketbase/pocketbase/issues/7090)).
-
-- Fixed `RateLimitRule.Audience` code comment ([#7098](https://github.com/pocketbase/pocketbase/pull/7098); thanks @iustin05).
-
-- Mocked `syscall.Exec` when building for WASM ([#7116](https://github.com/pocketbase/pocketbase/pull/7116); thanks @joas8211).
-    _Note that WASM is not officially supported PocketBase build target and many things may not work as expected._
-
-- Registered missing `$filesystem`, `$mails`, `$template` and `__hooks` bindings in the JSVM migrations ([#7125](https://github.com/pocketbase/pocketbase/issues/7125)).
-
-- Regenerated JSVM types to include methods from structs with single generic parameter.
-
-- Updated Go dependencies.
-
-
-## v0.29.2
-
-- Bumped min Go GitHub action version to 1.23.12 since it comes with some [minor fixes for the runtime and `database/sql` package](https://github.com/golang/go/issues?q=milestone%3AGo1.23.12+label%3ACherryPickApproved).
-
-
-## v0.29.1
-
-- Updated the X/Twitter provider to return the `confirmed_email` field and to use the `x.com` domain ([#7035](https://github.com/pocketbase/pocketbase/issues/7035)).
-
-- Added Box.com OAuth2 provider ([#7056](https://github.com/pocketbase/pocketbase/pull/7056); thanks @blakepatteson).
-
-- Updated `modernc.org/sqlite` to 1.38.2 (SQLite 3.50.3).
-
-- Fixed example List API response ([#7049](https://github.com/pocketbase/pocketbase/pull/7049); thanks @williamtguerra).
-
-
-## v0.29.0
-
-- Enabled calling the `/auth-refresh` endpoint with nonrenewable tokens.
-    _When used with nonrenewable tokens (e.g. impersonate) the endpoint will simply return the same token with the up-to-date user data associated with it._
-
-- Added the triggered rate rimit rule in the error log `details`.
-
-- Added optional `ServeEvent.Listener` field to initialize a custom network listener (e.g. `unix`) instead of the default `tcp` ([#3233](https://github.com/pocketbase/pocketbase/discussions/3233)).
-
-- Fixed request data unmarshalization for the `DynamicModel` array/object fields ([#7022](https://github.com/pocketbase/pocketbase/discussions/7022)).
-
-- Fixed Dashboard page title `-` escaping ([#6982](https://github.com/pocketbase/pocketbase/issues/6982)).
-
-- Other minor improvements (updated first superuser console text when running with `go run`, clarified trusted IP proxy header label, wrapped the backup restore in a transaction as an extra precaution, updated deps, etc.).
-
-
-## v0.28.4
-
-- Added global JSVM `toBytes()` helper to return the bytes slice representation of a value such as io.Reader or string, _other types are first serialized to Go string_ ([#6935](https://github.com/pocketbase/pocketbase/issues/6935)).
-
-- Fixed `security.RandomStringByRegex` random distribution ([#6947](https://github.com/pocketbase/pocketbase/pull/6947); thanks @yerTools).
-
-- Minor docs and typos fixes.
-
-
-## v0.28.3
-
-- Skip sending empty `Range` header when fetching blobs from S3 ([#6914](https://github.com/pocketbase/pocketbase/pull/6914)).
-
-- Updated Go deps and particularly `modernc.org/sqlite` to 1.38.0 (SQLite 3.50.1).
-
-- Bumped GitHub action min Go version to 1.23.10 as it comes with some [minor security `net/http` fixes](https://github.com/golang/go/issues?q=milestone%3AGo1.23.10+label%3ACherryPickApproved).
-
-
-## v0.28.2
-
-- Loaded latin-ext charset for the default text fonts ([#6869](https://github.com/pocketbase/pocketbase/issues/6869)).
-
-- Updated view query CAST regex to properly recognize multiline expressions ([#6860](https://github.com/pocketbase/pocketbase/pull/6860); thanks @azat-ismagilov).
-
-- Updated Go and npm dependencies.
-
-
-## v0.28.1
-
-- Fixed `json_each`/`json_array_length` normalizations to properly check for array values ([#6835](https://github.com/pocketbase/pocketbase/issues/6835)).
-
-
-## v0.28.0
-
-- Write the default response body of `*Request` hooks that are wrapped in a transaction after the related transaction completes to allow propagating the transaction error ([#6462](https://github.com/pocketbase/pocketbase/discussions/6462#discussioncomment-12207818)).
-
-- Updated `app.DB()` to automatically routes raw write SQL statements to the nonconcurrent db pool ([#6689](https://github.com/pocketbase/pocketbase/discussions/6689)).
-    _For the rare cases when it is needed users still have the option to explicitly target the specific pool they want using `app.ConcurrentDB()`/`app.NonconcurrentDB()`._
-
-- ⚠️ Changed the default `json` field max size to 1MB.
-    _Users still have the option to adjust the default limit from the collection field options but keep in mind that storing large strings/blobs in the database is known to cause performance issues and should be avoided when possible._
-
-- ⚠️ Soft-deprecated and replaced `filesystem.System.GetFile(fileKey)` with `filesystem.System.GetReader(fileKey)` to avoid the confusion with `filesystem.File`.
-    _The old method will still continue to work for at least until v0.29.0 but you'll get a console warning to replace it with `GetReader`._
-
-- Added new `filesystem.System.GetReuploadableFile(fileKey, preserveName)` method to return an existing blob as a `*filesystem.File` value ([#6792](https://github.com/pocketbase/pocketbase/discussions/6792)).
-    _This method could be useful in case you want to clone an existing Record file and assign it to a new Record (e.g. in a Record duplicate action)._
-
-- Other minor improvements (updated the GitHub release min Go version to 1.23.9, updated npm and Go deps, etc.)
-
-
-## v0.27.2
-
-- Added workers pool when cascade deleting record files to minimize _"thread exhaustion"_ errors ([#6780](https://github.com/pocketbase/pocketbase/discussions/6780)).
-
-- Updated the `:excerpt` fields modifier to properly account for multibyte characters ([#6778](https://github.com/pocketbase/pocketbase/issues/6778)).
-
-- Use `rowid` as count column for non-view collections to minimize the need of having the id field in a covering index ([#6739](https://github.com/pocketbase/pocketbase/discussions/6739))
-
-
-## v0.27.1
-
-- Updated example `geoPoint` API preview body data.
-
-- Added JSVM `new GeoPointField({ ... })` constructor.
-
-- Added _partial_ WebP thumbs generation (_the thumbs will be stored as PNG_; [#6744](https://github.com/pocketbase/pocketbase/pull/6744)).
-
-- Updated npm dev dependencies.
-
-
-## v0.27.0
-
-- ⚠️ Moved the Create and Manage API rule checks out of the `OnRecordCreateRequest` hook finalizer, **aka. now all CRUD API rules are checked BEFORE triggering their corresponding `*Request` hook**.
-    This was done to minimize the confusion regarding the firing order of the request operations, making it more predictable and consistent with the other record List/View/Update/Delete request actions.
-    It could be a minor breaking change if you are relying on the old behavior and have a Go `tests.ApiScenario` that is testing a Create API rule failure and expect `OnRecordCreateRequest` to be fired. In that case for example you may have to update your test scenario like:
-    ```go
-    tests.ApiScenario{
-        Name:   "Example test that checks a Create API rule failure"
-        Method: http.MethodPost,
-        URL:    "/api/collections/example/records",
-        ...
-        // old:
-        ExpectedEvents:  map[string]int{
-            "*":                     0,
-            "OnRecordCreateRequest": 1,
-        },
-        // new:
-        ExpectedEvents:  map[string]int{"*": 0},
-    }
-    ```
-    If you are having difficulties adjusting your code, feel free to open a [Q&A discussion](https://github.com/pocketbase/pocketbase/discussions) with the failing/problematic code sample.
-
-- Added [new `geoPoint` field](https://pocketbase.io/docs/collections/#geopoint) for storing `{"lon":x,"lat":y}` geographic coordinates.
-    In addition, a new [`geoDistance(lonA, lotA, lonB, lotB)` function](https://pocketbase.io/docs/api-rules-and-filters/#geodistancelona-lata-lonb-latb) was also implemented that could be used to apply an API rule or filter constraint based on the distance (in km) between 2 geo points.
-
-- Updated the `select` field UI to accommodate better larger lists and RTL languages ([#4674](https://github.com/pocketbase/pocketbase/issues/4674)).
-
-- Updated the mail attachments auto MIME type detection to use `gabriel-vasile/mimetype` for consistency and broader sniffing signatures support.
-
-- Forced `text/javascript` Content-Type when serving `.js`/`.mjs` collection uploaded files with the `/api/files/...` endpoint ([#6597](https://github.com/pocketbase/pocketbase/issues/6597)).
-
-- Added second optional JSVM `DateTime` constructor argument for specifying a default timezone as TZ identifier when parsing the date string as alternative to a fixed offset in order to better handle daylight saving time nuances ([#6688](https://github.com/pocketbase/pocketbase/discussions/6688)):
-    ```js
-    // the same as with CET offset: new DateTime("2025-10-26 03:00:00 +01:00")
-    new DateTime("2025-10-26 03:00:00", "Europe/Amsterdam") // 2025-10-26 02:00:00.000Z
-
-    // the same as with CEST offset: new DateTime("2025-10-26 01:00:00 +02:00")
-    new DateTime("2025-10-26 01:00:00", "Europe/Amsterdam") // 2025-10-25 23:00:00.000Z
-    ```
-
-- Soft-deprecated the `$http.send`'s `result.raw` field in favor of `result.body` that contains the response body as plain bytes slice to avoid the discrepancies between Go and the JSVM when casting binary data to string.
-
-- Updated `modernc.org/sqlite` to 1.37.0.
-
-- Other minor improvements (_removed the superuser fields from the auth record create/update body examples, allowed programmatically updating the auth record password from the create/update hooks, fixed collections import error response, etc._).
-
-
-## v0.26.6
-
-- Allow OIDC `email_verified` to be int or boolean string since some OIDC providers like AWS Cognito has non-standard userinfo response ([#6657](https://github.com/pocketbase/pocketbase/pull/6657)).
-
-- Updated `modernc.org/sqlite` to 1.36.3.
-
-
-## v0.26.5
-
-- Fixed canonical URI parts escaping when generating the S3 request signature ([#6654](https://github.com/pocketbase/pocketbase/issues/6654)).
-
-
-## v0.26.4
-
-- Fixed `RecordErrorEvent.Error` and `CollectionErrorEvent.Error` sync with `ModelErrorEvent.Error` ([#6639](https://github.com/pocketbase/pocketbase/issues/6639)).
-
-- Fixed logs details copy to clipboard action.
-
-- Updated `modernc.org/sqlite` to 1.36.2.
-
-
-## v0.26.3
-
-- Fixed and normalized logs error serialization across common types for more consistent logs error output ([#6631](https://github.com/pocketbase/pocketbase/issues/6631)).
-
-
-## v0.26.2
-
-- Updated `golang-jwt/jwt` dependency because it comes with a [minor security fix](https://github.com/golang-jwt/jwt/security/advisories/GHSA-mh63-6h87-95cp).
-
-
-## v0.26.1
-
-- Removed the wrapping of `io.EOF` error when reading files since currently `io.ReadAll` doesn't check for wrapped errors ([#6600](https://github.com/pocketbase/pocketbase/issues/6600)).
-
-
-## v0.26.0
-
-- ⚠️ Replaced `aws-sdk-go-v2` and `gocloud.dev/blob` with custom lighter implementation ([#6562](https://github.com/pocketbase/pocketbase/discussions/6562)).
-    As a side-effect of the dependency removal, the binary size has been reduced with ~10MB and builds ~30% faster.
-    _Although the change is expected to be backward-compatible, I'd recommend to test first locally the new version with your S3 provider (if you use S3 for files storage and backups)._
-
-- ⚠️ Prioritized the user submitted non-empty `createData.email` (_it will be unverified_) when creating the PocketBase user during the first OAuth2 auth.
-
-- Load the request info context during password/OAuth2/OTP authentication ([#6402](https://github.com/pocketbase/pocketbase/issues/6402)).
-    This could be useful in case you want to target the auth method as part of the MFA and Auth API rules.
-    For example, to disable MFA for the OAuth2 auth could be expressed as `@request.context != "oauth2"` MFA rule.
-
-- Added `store.Store.SetFunc(key, func(old T) new T)` to set/update a store value with the return result of the callback in a concurrent safe manner.
-
-- Added `subscription.Message.WriteSSE(w, id)` for writing an SSE formatted message into the provided writer interface (_used mostly to assist with the unit testing_).
-
-- Added `$os.stat(file)` JSVM helper ([#6407](https://github.com/pocketbase/pocketbase/discussions/6407)).
-
-- Added log warning for `async` marked JSVM handlers and resolve when possible the returned `Promise` as fallback ([#6476](https://github.com/pocketbase/pocketbase/issues/6476)).
-
-- Allowed calling `cronAdd`, `cronRemove` from inside other JSVM handlers ([#6481](https://github.com/pocketbase/pocketbase/discussions/6481)).
-
-- Bumped the default request read and write timeouts to 5mins (_old 3mins_) to accommodate slower internet connections and larger file uploads/downloads.
-    _If you want to change them you can modify the `OnServe` hook's `ServeEvent.ReadTimeout/WriteTimeout` fields as shown in [#6550](https://github.com/pocketbase/pocketbase/discussions/6550#discussioncomment-12364515)._
-
-- Normalized the `@request.auth.*` and `@request.body.*` back relations resolver to always return `null` when the relation field is pointing to a different collection ([#6590](https://github.com/pocketbase/pocketbase/discussions/6590#discussioncomment-12496581)).
-
-- Other minor improvements (_fixed query dev log nested parameters output, reintroduced `DynamicModel` object/array props reflect types caching, updated Go and npm deps, etc._)
-
-
-## v0.25.9
-
-- Fixed `DynamicModel` object/array props reflect type caching ([#6563](https://github.com/pocketbase/pocketbase/discussions/6563)).
-
-
-## v0.25.8
-
-- Added a default leeway of 5 minutes for the Apple/OIDC `id_token` timestamp claims check to account for clock-skew ([#6529](https://github.com/pocketbase/pocketbase/issues/6529)).
-    It can be further customized if needed with the `PB_ID_TOKEN_LEEWAY` env variable (_the value must be in seconds, e.g. "PB_ID_TOKEN_LEEWAY=60" for 1 minute_).
-
-
-## v0.25.7
-
-- Fixed `@request.body.jsonObjOrArr.*` values extraction ([#6493](https://github.com/pocketbase/pocketbase/discussions/6493)).
-
-
-## v0.25.6
-
-- Restore the missing `meta.isNew` field of the OAuth2 success response ([#6490](https://github.com/pocketbase/pocketbase/issues/6490)).
-
-- Updated npm dependencies.
-
-
-## v0.25.5
-
-- Set the current working directory as a default goja script path when executing inline JS strings to allow `require(m)` traversing parent `node_modules` directories.
-
-- Updated `modernc.org/sqlite` and `modernc.org/libc` dependencies.
-
-
-## v0.25.4
-
-- Downgraded `aws-sdk-go-v2` to the version before the default data integrity checks because there have been reports for non-AWS S3 providers in addition to Backblaze (IDrive, R2) that no longer or partially work with the latest AWS SDK changes.
-
-    While we try to enforce `when_required` by default, it is not enough to disable the new AWS SDK integrity checks entirely and some providers will require additional manual adjustments to make them compatible with the latest AWS SDK (e.g. removing the `x-aws-checksum-*` headers, unsetting the checksums calculation or reinstantiating the old MD5 checksums for some of the required operations, etc.) which as a result leads to a configuration mess that I'm not sure it would be a good idea to introduce.
-
-    This unfornuatelly is not a PocketBase or Go specific issue and the official AWS SDKs for other languages are in the same situation (even the latest aws-cli).
-
-    For those of you that extend PocketBase with Go: if your S3 vendor doesn't support the [AWS Data integrity checks](https://docs.aws.amazon.com/sdkref/latest/guide/feature-dataintegrity.html) and you are updating with `go get -u`, then make sure that the `aws-sdk-go-v2` dependencies in your `go.mod` are the same as in the repo:
-    ```
-    // go.mod
-    github.com/aws/aws-sdk-go-v2 v1.36.1
-    github.com/aws/aws-sdk-go-v2/config v1.28.10
-    github.com/aws/aws-sdk-go-v2/credentials v1.17.51
-    github.com/aws/aws-sdk-go-v2/feature/s3/manager v1.17.48
-    github.com/aws/aws-sdk-go-v2/service/s3 v1.72.2
-
-    // after that run
-    go clean -modcache && go mod tidy
-    ```
-    _The versions pinning is temporary until the non-AWS S3 vendors patch their implementation or until I manage to find time to remove/replace the `aws-sdk-go-v2` dependency (I'll consider prioritizing it for the v0.26 or v0.27 release)._
-
-
-## v0.25.3
-
-- Added a temporary exception for Backblaze S3 endpoints to exclude the new `aws-sdk-go-v2` checksum headers ([#6440](https://github.com/pocketbase/pocketbase/discussions/6440)).
-
-
-## v0.25.2
-
-- Fixed realtime delete event not being fired for `RecordProxy`-ies and added basic realtime record resolve automated tests ([#6433](https://github.com/pocketbase/pocketbase/issues/6433)).
-
-
-## v0.25.1
-
-- Fixed the batch API Preview success sample response.
-
-- Bumped GitHub action min Go version to 1.23.6 as it comes with a [minor security fix](https://github.com/golang/go/issues?q=milestone%3AGo1.23.6+label%3ACherryPickApproved) for the ppc64le build.
-
-
-## v0.25.0
-
-- ⚠️ Upgraded Google OAuth2 auth, token and userinfo endpoints to their latest versions.
-    _For users that don't do anything custom with the Google OAuth2 data or the OAuth2 auth URL, this should be a non-breaking change. The exceptions that I could find are:_
-    - `/v3/userinfo` auth response changes:
-        ```
-        meta.rawUser.id             => meta.rawUser.sub
-        meta.rawUser.verified_email => meta.rawUser.email_verified
-        ```
-    - `/v2/auth` query parameters changes:
-        If you are specifying custom `approval_prompt=force` query parameter for the OAuth2 auth URL, you'll have to replace it with **`prompt=consent`**.
-
-- Added Trakt OAuth2 provider ([#6338](https://github.com/pocketbase/pocketbase/pull/6338); thanks @aidan-)
-
-- Added support for case-insensitive password auth based on the related UNIQUE index field collation ([#6337](https://github.com/pocketbase/pocketbase/discussions/6337)).
-
-- Enforced `when_required` for the new AWS SDK request and response checksum validations to allow other non-AWS vendors to catch up with new AWS SDK changes (see [#6313](https://github.com/pocketbase/pocketbase/discussions/6313) and [aws/aws-sdk-go-v2#2960](https://github.com/aws/aws-sdk-go-v2/discussions/2960)).
-    _You can set the environment variables `AWS_REQUEST_CHECKSUM_CALCULATION` and `AWS_RESPONSE_CHECKSUM_VALIDATION` to `when_supported` if your S3 vendor supports the [new default integrity protections](https://docs.aws.amazon.com/sdkref/latest/guide/feature-dataintegrity.html)._
-
-- Soft-deprecated `Record.GetUploadedFiles` in favor of `Record.GetUnsavedFiles` to minimize the ambiguities what the method do ([#6269](https://github.com/pocketbase/pocketbase/discussions/6269)).
-
-- Replaced archived `github.com/AlecAivazis/survey` dependency with a simpler  `osutils.YesNoPrompt(message, fallback)` helper.
-
-- Upgraded to `golang-jwt/jwt/v5`.
-
-- Added JSVM `new Timezone(name)` binding for constructing `time.Location` value ([#6219](https://github.com/pocketbase/pocketbase/discussions/6219)).
-
-- Added `inflector.Camelize(str)` and `inflector.Singularize(str)` helper methods.
-
-- Use the non-transactional app instance during the realtime records delete access checks to ensure that cascade deleted records with API rules relying on the parent will be resolved.
-
-- Other minor improvements (_replaced all `bool` exists db scans with `int` for broader drivers compatibility, updated API Preview sample error responses, updated UI dependencies, etc._)
-
-
-## v0.24.4
-
-- Fixed fields extraction for view query with nested comments ([#6309](https://github.com/pocketbase/pocketbase/discussions/6309)).
-
-- Bumped GitHub action min Go version to 1.23.5 as it comes with some [minor security fixes](https://github.com/golang/go/issues?q=milestone%3AGo1.23.5).
-
-
-## v0.24.3
-
-- Fixed incorrectly reported unique validator error for fields starting with name of another field ([#6281](https://github.com/pocketbase/pocketbase/pull/6281); thanks @svobol13).
-
-- Reload the created/edited records data in the RecordsPicker UI.
-
-- Updated Go dependencies.
-
-
-## v0.24.2
-
-- Fixed display fields extraction when there are multiple "Presentable" `relation` fields in a single related collection ([#6229](https://github.com/pocketbase/pocketbase/issues/6229)).
-
-
-## v0.24.1
-
-- Added missing time macros in the UI autocomplete.
-
-- Fixed JSVM types for structs and functions with multiple generic parameters.
-
-
-## v0.24.0
-
-- ⚠️ Removed the "dry submit" when executing the collections Create API rule
-    (you can find more details why this change was introduced and how it could affect your app in https://github.com/pocketbase/pocketbase/discussions/6073).
-    For most users it should be non-breaking change, BUT if you have Create API rules that uses self-references or view counters you may have to adjust them manually.
-    With this change the "multi-match" operators are also normalized in case the targeted collection doesn't have any records
-    (_or in other words, `@collection.example.someField != "test"` will result to `true` if `example` collection has no records because it satisfies the condition that all available "example" records mustn't have `someField` equal to "test"_).
-    As a side-effect of all of the above minor changes, the record create API performance has been also improved ~4x times in high concurrent scenarios (500 concurrent clients inserting total of 50k records - [old (58.409064001s)](https://github.com/pocketbase/benchmarks/blob/54140be5fb0102f90034e1370c7f168fbcf0ddf0/results/hetzner_cax41_cgo.md#creating-50000-posts100k-reqs50000-conc500-rulerequestauthid----requestdatapublicisset--true) vs [new (13.580098262s)](https://github.com/pocketbase/benchmarks/blob/7df0466ac9bd62fe0a1056270d20ef82012f0234/results/hetzner_cax41_cgo.md#creating-50000-posts100k-reqs50000-conc500-rulerequestauthid----requestbodypublicisset--true)).
-
-- ⚠️ Changed the type definition of `store.Store[T any]` to `store.Store[K comparable, T any]` to allow support for custom store key types.
-    For most users it should be non-breaking change, BUT if you are calling `store.New[any](nil)` instances you'll have to specify the store key type, aka. `store.New[string, any](nil)`.
-
-- Added `@yesterday` and `@tomorrow` datetime filter macros.
-
-- Added `:lower` filter modifier (e.g. `title:lower = "lorem"`).
-
-- Added `mailer.Message.InlineAttachments` field for attaching inline files to an email (_aka. `cid` links_).
-
-- Added cache for the JSVM `arrayOf(m)`, `DynamicModel`, etc. dynamic `reflect` created types.
-
-- Added auth collection select for the settings "Send test email" popup ([#6166](https://github.com/pocketbase/pocketbase/issues/6166)).
-
-- Added `record.SetRandomPassword()` to simplify random password generation usually used in the OAuth2 or OTP record creation flows.
-    _The generated ~30 chars random password is assigned directly as bcrypt hash and ignores the `password` field plain value validators like min/max length or regex pattern._
-
-- Added option to list and trigger the registered app level cron jobs via the Web API and UI.
-
-- Added extra validators for the collection field `int64` options (e.g. `FileField.MaxSize`) restricting them to the max safe JSON number (2^53-1).
-
-- Added option to unset/overwrite the default PocketBase superuser installer using `ServeEvent.InstallerFunc`.
-
-- Added `app.FindCachedCollectionReferences(collection, excludeIds)` to speedup records cascade delete almost twice for projects with many collections.
-
-- Added `tests.NewTestAppWithConfig(config)` helper if you need more control over the test configurations like `IsDev`, the number of allowed connections, etc.
-
-- Invalidate all record tokens when the auth record email is changed programmatically or by a superuser ([#5964](https://github.com/pocketbase/pocketbase/issues/5964)).
-
-- Eagerly interrupt waiting for the email alert send in case it takes longer than 15s.
-
-- Normalized the hidden fields filter checks and allow targetting hidden fields in the List API rule.
-
-- Fixed "Unique identify fields" input not refreshing on unique indexes change ([#6184](https://github.com/pocketbase/pocketbase/issues/6184)).
-
-
-## v0.23.12
-
-- Added warning logs in case of mismatched `modernc.org/sqlite` and `modernc.org/libc` versions ([#6136](https://github.com/pocketbase/pocketbase/issues/6136#issuecomment-2556336962)).
-
-- Skipped the default body size limit middleware for the backup upload endpoint ([#6152](https://github.com/pocketbase/pocketbase/issues/6152)).
-
-
-## v0.23.11
-
-- Upgraded `golang.org/x/net` to 0.33.0 to fix [CVE-2024-45338](https://www.cve.org/CVERecord?id=CVE-2024-45338).
-  _PocketBase uses the vulnerable functions primarily for the auto html->text mail generation, but most applications shouldn't be affected unless you are manually embedding unrestricted user provided value in your mail templates._
-
-
-## v0.23.10
-
-- Renew the superuser file token cache when clicking on the thumb preview or download link ([#6137](https://github.com/pocketbase/pocketbase/discussions/6137)).
-
-- Upgraded `modernc.org/sqlite` to 1.34.3 to fix "disk io" error on arm64 systems.
-    _If you are extending PocketBase with Go and upgrading with `go get -u` make sure to manually set in your go.mod the `modernc.org/libc` indirect dependency to v1.55.3, aka. the exact same version the driver is using._
-
-
-## v0.23.9
-
-- Replaced `strconv.Itoa` with `strconv.FormatInt` to avoid the int64->int conversion overflow on 32-bit platforms ([#6132](https://github.com/pocketbase/pocketbase/discussions/6132)).
-
-
-## v0.23.8
-
-- Fixed Model->Record and Model->Collection hook events sync for nested and/or inner-hook transactions ([#6122](https://github.com/pocketbase/pocketbase/discussions/6122)).
-
-- Other minor improvements (updated Go and npm deps, added extra escaping for the default mail record params in case the emails are stored as html files, fixed code comment typos, etc.).
-
-
-## v0.23.7
-
-- Fixed JSVM exception -> Go error unwrapping when throwing errors from non-request hooks ([#6102](https://github.com/pocketbase/pocketbase/discussions/6102)).
-
-
-## v0.23.6
-
-- Fixed `$filesystem.fileFromURL` documentation and generated type ([#6058](https://github.com/pocketbase/pocketbase/issues/6058)).
-
-- Fixed `X-Forwarded-For` header typo in the suggested UI "Common trusted proxy" headers ([#6063](https://github.com/pocketbase/pocketbase/pull/6063)).
-
-- Updated the `text` field max length validator error message to make it more clear ([#6066](https://github.com/pocketbase/pocketbase/issues/6066)).
-
-- Other minor fixes (updated Go deps, skipped unnecessary validator check when the default primary key pattern is used, updated JSVM types, etc.).
-
-
-## v0.23.5
-
-- Fixed UI logs search not properly accounting for the "Include requests by superusers" toggle when multiple search expressions are used.
-
-- Fixed `text` field max validation error message ([#6053](https://github.com/pocketbase/pocketbase/issues/6053)).
-
-- Other minor fixes (comment typos, JSVM types update).
-
-- Updated Go deps and the min Go release GitHub action version to 1.23.4.
-
-
-## v0.23.4
-
-- Fixed `autodate` fields not refreshing when calling `Save` multiple times on the same `Record` instance ([#6000](https://github.com/pocketbase/pocketbase/issues/6000)).
-
-- Added more descriptive test OTP id and failure log message ([#5982](https://github.com/pocketbase/pocketbase/discussions/5982)).
-
-- Moved the default UI CSP from meta tag to response header ([#5995](https://github.com/pocketbase/pocketbase/discussions/5995)).
-
-- Updated Go and npm dependencies.
-
-
-## v0.23.3
-
-- Fixed Gzip middleware not applying when serving static files.
-
-- Fixed `Record.Fresh()`/`Record.Clone()` methods not properly cloning `autodate` fields ([#5973](https://github.com/pocketbase/pocketbase/discussions/5973)).
-
-
-## v0.23.2
-
-- Fixed `RecordQuery()` custom struct scanning ([#5958](https://github.com/pocketbase/pocketbase/discussions/5958)).
-
-- Fixed `--dev` log query print formatting.
-
-- Added support for passing more than one id in the `Hook.Unbind` method for consistency with the router.
-
-- Added collection rules change list in the confirmation popup
-  (_to avoid getting anoying during development, the rules confirmation currently is enabled only when using https_).
-
-
-## v0.23.1
-
-- Added `RequestEvent.Blob(status, contentType, bytes)` response write helper ([#5940](https://github.com/pocketbase/pocketbase/discussions/5940)).
-
-- Added more descriptive error messages.
-
-
-## v0.23.0
-
-> [!NOTE]
-> You don't have to upgrade to PocketBase v0.23.0 if you are not planning further developing
-> your existing app and/or are satisfied with the v0.22.x features set. There are no identified critical issues
-> with PocketBase v0.22.x yet and in the case of critical bugs and security vulnerabilities, the fixes
-> will be backported for at least until Q1 of 2025 (_if not longer_).
->
-> **If you don't plan upgrading make sure to pin the SDKs version to their latest PocketBase v0.22.x compatible:**
-> - JS SDK: `<0.22.0`
-> - Dart SDK: `<0.19.0`
-
-> [!CAUTION]
-> This release introduces many Go/JSVM and Web APIs breaking changes!
->
-> Existing `pb_data` will be automatically upgraded with the start of the new executable,
-> but custom Go or JSVM (`pb_hooks`, `pb_migrations`) and JS/Dart SDK code will have to be migrated manually.
-> Please refer to the below upgrade guides:
-> - Go:   https://pocketbase.io/v023upgrade/go/.
-> - JSVM: https://pocketbase.io/v023upgrade/jsvm/.
->
-> If you had already switched to some of the earlier `<v0.23.0-rc14` versions and have generated a full collections snapshot migration (aka. `./pocketbase migrate collections`), then you may have to regenerate the migration file to ensure that it includes the latest changes.
-
-PocketBase v0.23.0 is a major refactor of the internals with the overall goal of making PocketBase an easier to use Go framework.
-There are a lot of changes but to highlight some of the most notable ones:
-
-- New and more [detailed documentation](https://pocketbase.io/docs/).
-  _The old documentation could be accessed at [pocketbase.io/old](https://pocketbase.io/old/)._
-- Replaced `echo` with a new router built on top of the Go 1.22 `net/http` mux enhancements.
-- Merged `daos` packages in `core.App` to simplify the DB operations (_the `models` package structs are also migrated in `core`_).
-- Option to specify custom `DBConnect` function as part of the app configuration to allow different `database/sql` SQLite drivers (_turso/libsql, sqlcipher, etc._) and custom builds.
-  _Note that we no longer loads the `mattn/go-sqlite3` driver by default when building with `CGO_ENABLED=1` to avoid `multiple definition` linker errors in case different CGO SQLite drivers or builds are used. You can find an example how to enable it back if you want to in the [new documentation](https://pocketbase.io/docs/go-overview/#github-commattngo-sqlite3)._
-- New hooks allowing better control over the execution chain and error handling (_including wrapping an entire hook chain in a single DB transaction_).
-- Various `Record` model improvements (_support for get/set modifiers, simplfied file upload by treating the file(s) as regular field value like `record.Set("document", file)`, etc._).
-- Dedicated fields structs with safer defaults to make it easier creating/updating collections programmatically.
-- Option to mark field as "Hidden", disallowing regular users to read or modify it (_there is also a dedicated Record hook to hide/unhide Record fields programmatically from a single place_).
-- Option to customize the default system collection fields (`id`, `email`, `password`, etc.).
-- Admins are now system `_superusers` auth records.
-- Builtin rate limiter (_supports tags, wildcards and exact routes matching_).
-- Batch/transactional Web API endpoint.
-- Impersonate Web API endpoint (_it could be also used for generating fixed/nonrenewable superuser tokens, aka. "API keys"_).
-- Support for custom user request activity log attributes.
-- One-Time Password (OTP) auth method (_via email code_).
-- Multi-Factor Authentication (MFA) support (_currently requires any 2 different auth methods to be used_).
-- Support for Record "proxy/projection" in preparation for the planned autogeneration of typed Go record models.
-- Linear OAuth2 provider ([#5909](https://github.com/pocketbase/pocketbase/pull/5909); thanks @chnfyi).
-- WakaTime OAuth2 provider ([#5829](https://github.com/pocketbase/pocketbase/pull/5829); thanks @tigawanna).
-- Notion OAuth2 provider ([#4999](https://github.com/pocketbase/pocketbase/pull/4999); thanks @s-li1).
-- monday.com OAuth2 provider ([#5346](https://github.com/pocketbase/pocketbase/pull/5346); thanks @Jaytpa01).
-- New Instagram provider compatible with the new Instagram Login APIs ([#5588](https://github.com/pocketbase/pocketbase/pull/5588); thanks @pnmcosta).
-    _The provider key is `instagram2` to prevent conflicts with existing linked users._
-- Option to retrieve the OIDC OAuth2 user info from the `id_token` payload for the cases when the provider doesn't have a dedicated user info endpoint.
-- Various minor UI improvements (_recursive `Presentable` view, slightly different collection options organization, zoom/pan for the logs chart, etc._)
-- and many more...
-
-#### Go/JSVM APIs changes
-
-> - Go:   https://pocketbase.io/v023upgrade/go/.
-> - JSVM: https://pocketbase.io/v023upgrade/jsvm/.
-
-#### SDKs changes
-
-- [JS SDK v0.22.0](https://github.com/pocketbase/js-sdk/blob/master/CHANGELOG.md)
-- [Dart SDK v0.19.0](https://github.com/pocketbase/dart-sdk/blob/master/CHANGELOG.md)
-
-#### Web APIs changes
-
-- New `POST /api/batch` endpoint.
-
-- New `GET /api/collections/meta/scaffolds` endpoint.
-
-- New `DELETE /api/collections/{collection}/truncate` endpoint.
-
-- New `POST /api/collections/{collection}/request-otp` endpoint.
-
-- New `POST /api/collections/{collection}/auth-with-otp` endpoint.
-
-- New `POST /api/collections/{collection}/impersonate/{id}` endpoint.
-
-- ⚠️ If you are constructing requests to `/api/*` routes manually remove the trailing slash (_there is no longer trailing slash removal middleware registered by default_).
-
-- ⚠️ Removed `/api/admins/*` endpoints because admins are converted to `_superusers` auth collection records.
-
-- ⚠️ Previously when uploading new files to a multiple `file` field, new files were automatically appended to the existing field values.
-     This behaviour has changed with v0.23+ and for consistency with the other multi-valued fields when uploading new files they will replace the old ones. If you want to prepend or append new files to an existing multiple `file` field value you can use the `+` prefix or suffix:
-     ```js
-     "documents": [file1, file2]  // => [file1_name, file2_name]
-     "+documents": [file1, file2] // => [file1_name, file2_name, old1_name, old2_name]
-     "documents+": [file1, file2] // => [old1_name, old2_name, file1_name, file2_name]
-     ```
-
-- ⚠️ Removed `GET /records/{id}/external-auths` and `DELETE /records/{id}/external-auths/{provider}` endpoints because this is now handled by sending list and delete requests to the `_externalAuths` collection.
-
-- ⚠️ Changes to the app settings model fields and response (+new options such as `trustedProxy`, `rateLimits`, `batch`, etc.). The app settings Web APIs are mostly used by the Dashboard UI and rarely by the end users, but if you want to check all settings changes please refer to the [Settings Go struct](https://github.com/pocketbase/pocketbase/blob/develop/core/settings_model.go#L121).
-
-- ⚠️ New flatten Collection model and fields structure. The Collection model Web APIs are mostly used by the Dashboard UI and rarely by the end users, but if you want to check all changes please refer to the [Collection Go struct](https://github.com/pocketbase/pocketbase/blob/develop/core/collection_model.go#L308).
-
-- ⚠️ The top level error response `code` key was renamed to `status` for consistency with the Go APIs.
-    The error field key remains `code`:
-    ```js
-    {
-        "status": 400, // <-- old: "code"
-        "message": "Failed to create record.",
-        "data": {
-            "title": {
-                "code": "validation_required",
-                "message": "Missing required value."
-            }
-        }
-    }
-    ```
-
-- ⚠️ New fields in the `GET /api/collections/{collection}/auth-methods` response.
-    _The old `authProviders`, `usernamePassword`, `emailPassword` fields are still returned in the response but are considered deprecated and will be removed in the future._
-    ```js
-    {
-        "mfa": {
-            "duration": 100,
-            "enabled": true
-        },
-        "otp": {
-            "duration": 0,
-            "enabled": false
-        },
-        "password": {
-            "enabled": true,
-            "identityFields": ["email", "username"]
-        },
-        "oauth2": {
-            "enabled": true,
-            "providers": [{"name": "gitlab", ...}, {"name": "google", ...}]
-        },
-        // old fields...
-    }
-    ```
-
-- ⚠️ Soft-deprecated the OAuth2 auth success `meta.avatarUrl` field in favour of `meta.avatarURL`.

docs/DEV_NOTES.md

@@ -2,37 +2,75 @@
 
 ## File Structure
 
+The codebase is split into **`core/`** (domain logic), **`commands/`** (Discord slash command handlers), and a thin **`bot.py`** that wires everything together.
+
+### Top level
+
 | File | Purpose |
 |---|---|
-| `bot.py` | All Discord commands, views (UI components), event handlers, reminder system |
+| `bot.py` | Discord client, event handlers (`on_ready`, `on_member_join`, ...), background tasks (presence rotation, daily birthday loop), shared helpers (`_award_exp`, `_maybe_remind`, `_parse_amount`, `_PAUSED`), and `register_*_commands(...)` wiring for every command module |
-| `economy.py` | All economy logic, data model, constants (SHOP, COOLDOWNS, LEVEL_ROLES, etc.) |
+| `strings/` | **Single source of truth for all user-facing text**, split into domain submodules (`common`, `commands`, `member`, `economy`, `admin`, `games`, `fishing`) and re-exported via `strings/__init__.py` so `import strings` / `strings.NAME` works unchanged. Edit the relevant submodule to change any message. |
-| `pb_client.py` | Async PocketBase REST client - auth token cache, CRUD on `economy_users` collection |
-| `strings.py` | **Single source of truth for all user-facing text.** Edit here to change any message. |
-| `sheets.py` | Google Sheets integration (member sync) |
-| `member_sync.py` | Birthday/member sync background task |
 | `config.py` | Environment variables (TOKEN, GUILD_ID, PB_URL, etc.) |
-| `scripts/migrate_to_pb.py` | One-time utility: migrate `data/economy.json` → PocketBase |
+
+### `core/` - domain logic, no Discord coupling
+
+| File | Purpose |
+|---|---|
+| `core/economy/` | Economy business logic **package**, re-exported via `core/economy/__init__.py` so callers use `from core import economy` + attribute access (`economy.do_daily`, `economy.SHOP`, ...). Submodules: `store.py` (user records, per-user locks, `COOLDOWNS`, `JAIL_DURATION`, `COIN`, `get_user`/`_commit`/`_txn`), `income.py`, `gambling.py`, `fishing.py`, `jail.py`, `heist.py`, `prestige.py`, `shop.py`, `levels.py`, `quests.py`, `leaderboards.py`, `house.py`, `admin.py` |
+| `core/pb_client.py` | Async PocketBase REST client - auth token cache, CRUD on `economy_users` collection |
+| `core/sheets.py` | Google Sheets integration (member sync) |
+| `core/member_sync.py` | Birthday/member sync helpers, plus tournament team-role sync + divider placement |
+
+### `commands/` - one slash-command group per file
+
+Each file exposes a `register_<group>_commands(tree, bot, ...)` function. `bot.py` calls them all once on startup, passing in shared helpers (`coin`, `cd_ts`, `award_exp`, `maybe_remind`, `parse_amount`, ...).
+
+| File | Commands / Responsibility |
+|---|---|
+| `commands/dev_member_commands.py` | `/check`, `/member` (dev profile only) |
+| `commands/dev_member_runtime.py` | `on_member_join` flow + `birthday_daily` task body |
+| `commands/economy_income_commands.py` | `/daily`, `/work`, `/beg`, `/crime`, `/rob` |
+| `commands/economy_games_commands.py` | `/roulette`, `/slots`, `/blackjack`, `/rps` |
+| `commands/economy_extra_commands.py` | `/heist`, `/jailbreak`, `/reminders`, `/request`, ... |
+| `commands/economy_fish_commands.py` | `/fish`, `/fishbook`, `/fishsell` |
+| `commands/economy_profile_commands.py` | `/balance`, `/rank`, `/stats`, `/cooldowns`, `/leaderboard` |
+| `commands/economy_support_commands.py` | `/shop`, `/buy`, `/give`, `/economysetup` |
+| `commands/economy_prestige_commands.py` | `/prestige`, `/prestigeshop`, `/prestigebuy` |
+| `commands/economy_admin_commands.py` | `/admincoins`, `/adminexp`, `/adminitem`, `/adminjail`, `/adminban`, `/adminreset`, `/adminview` |
+| `commands/ops_admin_commands.py` | `/sync`, `/restart`, `/shutdown`, `/pause`, `/send`, `/status` |
+| `commands/ops_channel_commands.py` | Channel allowlist commands |
+| `commands/info_commands.py` | `/patchnotes` and other lightweight info commands |
+
+### `scripts/`
+
+| File | Purpose |
+|---|---|
+| `scripts/migrate_to_pb.py` | One-time legacy migration: `data/economy.json` → PocketBase. Only relevant if you still have a pre-PB JSON store. |
+| `scripts/add_stats_fields.py` | Schema migration: adds new fields to the `economy_users` collection. Idempotent. |
+| `scripts/reset_pb_collections.py` | **Destructive** - deletes and recreates the dev + economy collections. Requires `--confirm`. Use only in dev. |
 
 ---
 
 ## Adding a New Economy Command
 
+Pick the `commands/economy_*_commands.py` file that matches the new command's category (income, games, profile, ...) and add the handler inside its `register_*_commands` function. If none fit, create a new module and register it from `bot.py`.
+
 Checklist - do all of these, in order:
 
-1. **`economy.py`** - add the `do_<cmd>` async function with cooldown check, logic, `_commit`, and `_txn` logging
+1. **`core/economy/<area>.py`** (e.g. `income.py`, `gambling.py`, `fishing.py`) - add the `do_<cmd>` async function with cooldown check, logic, `_commit`, and `_txn` logging (`get_user`/`_commit`/`_txn` live in `store.py`)
-2. **`economy.py`** - add the cooldown to `COOLDOWNS` dict if it has one
+2. **`core/economy/store.py`** - add the cooldown to `COOLDOWNS` dict if it has one
-3. **`economy.py`** - add the EXP reward to `EXP_REWARDS` dict
+3. **`core/economy/levels.py`** - add the EXP reward to `EXP_REWARDS` dict
-4. **`strings.py` `CMD`** - add the slash command description
+4. **`strings/commands.py` `CMD`** - add the slash command description
-5. **`strings.py` `OPT`** - add any parameter descriptions
+5. **`strings/commands.py` `OPT`** - add any parameter descriptions
-6. **`strings.py` `TITLE`** - add embed title(s) for success/fail states
+6. **`strings/common.py` `TITLE`** - add embed title(s) for success/fail states
-7. **`strings.py` `ERR`** - add any error messages (banned, cooldown uses `CD_MSG`, jailed uses `CD_MSG["jailed"]`)
+7. **`strings/common.py` `ERR`** - add any error messages (banned, cooldown uses `CD_MSG`, jailed uses `CD_MSG["jailed"]`)
-8. **`strings.py` `CD_MSG`** - add cooldown message if command has a cooldown
+8. **`strings/common.py` `CD_MSG`** - add cooldown message if command has a cooldown
-9. **`strings.py` `HELP_CATEGORIES["tipibot"]["fields"]`** - add the command to the help embed
+9. **`strings/commands.py` `HELP_CATEGORIES["tipibot"]["fields"]`** - add the command to the help embed
-10. **`bot.py`** - implement the `cmd_<name>` function, handle all `res["reason"]` cases
+10. **`commands/economy_<group>_commands.py`** - inside `register_*_commands`, add `@tree.command(name="<cmd>", ...)` `cmd_<name>`; handle all `res["reason"]` cases
-11. **`bot.py`** - call `_maybe_remind` if the command has a cooldown and reminders make sense
+11. **`commands/economy_<group>_commands.py`** - call `maybe_remind(user_id, "<cmd>")` if the command has a cooldown and reminders make sense (the helper is passed in via the `register_*` signature)
-12. **`bot.py`** - call `_award_exp(interaction, economy.EXP_REWARDS["<cmd>"])` on success
+12. **`commands/economy_<group>_commands.py`** - call `await award_exp(interaction, economy.EXP_REWARDS["<cmd>"])` on success
-13. **`strings.py` `REMINDER_OPTS`** - add a reminder option if the command needs one
+13. **`strings/common.py` `REMINDER_OPTS`** - add a reminder option if the command needs one
-14. **`bot.py` `_maybe_remind`** - if the command has an item-modified cooldown, add an `elif` branch
+14. **`bot.py` `_maybe_remind`** - if the command has an item-modified cooldown, add an `elif` branch (this helper still lives in `bot.py` and is shared across all command modules)
 
 ---
 
@@ -40,21 +78,21 @@ Checklist - do all of these, in order:
 
 Checklist:
 
-1. **`economy.py` `SHOP`** - add the item dict `{name, emoji, cost, description: strings.ITEM_DESCRIPTIONS["key"]}`
+1. **`core/economy/shop.py` `SHOP`** - add the item dict `{name, emoji, cost, description: strings.ITEM_DESCRIPTIONS["key"]}`
-2. **`economy.py` `SHOP_TIERS`** - add the key to the correct tier list (1/2/3)
+2. **`core/economy/shop.py` `SHOP_TIERS`** - add the key to the correct tier list (1/2/3)
-3. **`economy.py` `SHOP_LEVEL_REQ`** - add minimum level if it is T2 (≥10) or T3 (≥20)
+3. **`core/economy/shop.py` `SHOP_LEVEL_REQ`** - add minimum level if it is T2 (≥10) or T3 (≥20)
-4. **`strings.py` `ITEM_DESCRIPTIONS`** - add the item description (Estonian flavour + English effect)
+4. **`strings/economy.py` `ITEM_DESCRIPTIONS`** - add the item description (Estonian flavour + English effect)
-5. **`strings.py` `HELP_CATEGORIES["shop"]["fields"]`** - add display entry (sorted by cost)
+5. **`strings/commands.py` `HELP_CATEGORIES["shop"]["fields"]`** - add display entry (sorted by cost)
 6. If the item modifies a cooldown:
-   - **`economy.py`** - add the `if "item" in user["items"]` branch in the relevant `do_<cmd>` function
+   - **`core/economy/<area>.py`** - add the `if "item" in user["items"]` branch in the relevant `do_<cmd>` function
    - **`bot.py` `_maybe_remind`** - add `elif cmd == "<cmd>" and "<item>" in items:` branch with the new delay
-   - **`bot.py` `cmd_cooldowns`** - add the item annotation to the relevant status line
+   - **`commands/economy_profile_commands.py` `cmd_cooldowns`** - add the item annotation to the relevant status line
 
 ---
 
 ## Adding a New Level Role
 
-1. **`economy.py` `LEVEL_ROLES`** - add `(min_level, "RoleName")` in descending level order (highest first)
+1. **`core/economy/levels.py` `LEVEL_ROLES`** - add `(min_level, "RoleName")` in descending level order (highest first)
 2. **`bot.py` `_ensure_level_role`** - no changes needed (uses `LEVEL_ROLES` dynamically)
 3. Run **`/economysetup`** in the server to create the role and set its position
 
@@ -62,9 +100,9 @@ Checklist:
 
 ## Adding a New Admin Command
 
-1. **`strings.py` `CMD`** - add `"[Admin] ..."` description
+1. **`strings/commands.py` `CMD`** - add `"[Admin] ..."` description
-2. **`strings.py` `HELP_CATEGORIES["admin"]["fields"]`** - add the entry
+2. **`strings/commands.py` `HELP_CATEGORIES["admin"]["fields"]`** - add the entry
-3. **`bot.py`** - add `@app_commands.default_permissions(manage_guild=True)` and `@app_commands.guild_only()`
+3. **`commands/economy_admin_commands.py`** (or `commands/ops_admin_commands.py` for non-economy ops) - add the handler with `@app_commands.default_permissions(manage_guild=True)` and `@app_commands.guild_only()`
 
 ---
 
@@ -72,7 +110,7 @@ Checklist:
 
 ### Storage
 
-All economy state is stored in **PocketBase** (`economy_users` collection). `pb_client.py` owns all reads/writes. Each `do_*` function in `economy.py` calls `get_user()` → mutates the local dict → calls `_commit()`. `_commit` does a `PATCH` to PocketBase.
+All economy state is stored in **PocketBase** (`economy_users` collection). `core/pb_client.py` owns all reads/writes. Each `do_*` function in `core/economy/` calls `get_user()` (from `store.py`) → mutates the local dict → calls `_commit()`. `_commit` does a `PATCH` to PocketBase.
 
 ### Currency & Income Sources
 
@@ -103,8 +141,41 @@ Commands that accept a coin amount (`/give`, `/roulette`, `/rps`, `/slots`, `/bl
 - `/jailbreak`: 3 dice rolls, need doubles to escape free. On fail - bail = 20-30% of balance, min 350⬡. If balance < 350⬡, player stays jailed until timer.
 - **Blocked while jailed**: `/work`, `/beg`, `/crime`, `/rob`, `/give` (checked in `do_*` functions via `_is_jailed`)
 
-### EXP Rewards (from `EXP_REWARDS` in economy.py)
+### EXP Rewards (from `EXP_REWARDS` in `core/economy/levels.py`)
-EXP is awarded on every successful command use. Level formula: `floor(sqrt(exp / 10))`, so Level 5 = 250 EXP, Level 10 = 1000, Level 20 = 4000, Level 30 = 9000.
+EXP is awarded on every successful command use. Level formula: `level = max(1, floor(sqrt(exp / 6)))` (see `get_level` / `exp_for_level`). Thresholds: Level 5 = 150 EXP, Level 10 = 600, Level 20 = 2 400, Level 30 = 5 400.
+
+Gambling EXP is bet-scaled via `gamble_exp(bet)`; fish EXP is per-species in `FISH_CATALOGUE` (common 2–3, uncommon 6–7, rare 10, epic 14–15, legendary 25).
+
+---
+
+## Tournament Team Roles
+
+Economy profile only. Roster-independent: matches Discord usernames straight against `TEAM_SHEET_ID`, never the member sheet. Entry points are `/teamsync` (`commands/economy_team_commands.py`) and the hourly `team_sync_hourly` task in `bot.py`; both call `sheets.refresh_teams()` then `member_sync.sync_all_team_roles()`.
+
+### Pipeline
+
+| Step | Where | Notes |
+|---|---|---|
+| Split a tab into per-game blocks | `sheets.parse_team_sections` | Returns `TeamSection(title, rosters)`. The merged title row above each header is the **only** thing identifying game + year |
+| Flatten to `{team: [players]}` | `sheets.parse_team_rosters` | Thin wrapper over `parse_team_sections` |
+| Section title → divider role name | `sheets.resolve_divider` | Matches `config.TEAM_DIVIDERS`; most specific key wins |
+| Cache | `sheets._refresh_teams_sync` | Populates `_team_roster`, `_team_by_username`, `_team_names`, `_team_divider` |
+| Grant/remove roles per member | `member_sync.sync_team_role` | Only names in `all_team_names()` are ever touched |
+| Compute new role positions | `member_sync.plan_team_positions` | **Pure** - list of names ascending + managed set + placements → `{name: new position}`. Unit-tested without Discord |
+| Apply | `member_sync.apply_team_role_positions` | One `guild.edit_role_positions` call per sync |
+
+### Adding a game to the divider config
+
+1. `.env` - add `TEAM_DIVIDER_<GAME>_<YEAR>="<exact Discord role name>"`. No code change; `config._parse_team_dividers` discovers any var with that prefix at startup.
+2. Restart the bot (env is read once at import).
+
+### Position maths gotchas
+
+- Discord positions are **ascending from the bottom** (`@everyone` = 0), so "under the divider in the UI" means a *lower* number. `plan_team_positions` therefore inserts each block reverse-sorted.
+- The bot can only reorder roles strictly below its own highest role. Dividers at or above it are skipped with an error rather than attempted.
+- `managed` roles (integration/bot/booster) are never emitted in the plan.
+- Roles are matched **by name** throughout the feature; with duplicate names the lowest-positioned one wins.
+- Only roles whose position actually changed are submitted, so a settled guild costs zero API calls.
 
 ---
 
@@ -139,45 +210,51 @@ Role assignment:
 | T3 | 20 | monitor_360, karikas, gaming_tool |
 
 Shop display is sorted by cost (ascending) within each tier.
-The `SHOP_LEVEL_REQ` dict in `economy.py` controls per-item lock thresholds.
+The `SHOP_LEVEL_REQ` dict in `core/economy/shop.py` controls per-item lock thresholds.
 
 ---
 
-## strings.py Organisation
+## strings/ Organisation
 
-| Section | Dict | Usage in bot.py |
+Imported as `import strings as S` everywhere. `strings/` is a package: the names below live in domain submodules and are re-exported from `strings/__init__.py`, so `S.CMD`, `S.ERR`, etc. resolve unchanged regardless of which submodule they live in. Dicts are read from `bot.py` and from every `commands/*.py` module. Edit the submodule shown in the **Module** column.
-|---|---|---|
+
-| Flavour text | `WORK_JOBS`, `BEG_LINES`, `CRIME_WIN`, `CRIME_LOSE` | Randomised descriptions |
+| Section | Dict | Module | Typical usage |
-| Command descriptions | `CMD["key"]` | `@tree.command(description=S.CMD["key"])` |
+|---|---|---|---|
-| Parameter descriptions | `OPT["key"]` | `@app_commands.describe(param=S.OPT["key"])` |
+| Flavour text | `WORK_JOBS`, `BEG_LINES`, `CRIME_WIN`, `CRIME_LOSE` | `economy.py` | Randomised descriptions |
-| Help embed | `HELP_CATEGORIES["cat"]` | `cmd_help` |
+| Command descriptions | `CMD["key"]` | `commands.py` | `@tree.command(description=S.CMD["key"])` |
-| Banned message | `MSG_BANNED` | All banned checks |
+| Parameter descriptions | `OPT["key"]` | `commands.py` | `@app_commands.describe(param=S.OPT["key"])` |
-| Maintenance mode | `MSG_MAINTENANCE` | Shown when `_PAUSED=True` in bot.py (toggled by `/pause`) |
+| Help embed | `HELP_CATEGORIES["cat"]` | `commands.py` | `cmd_help` (in `bot.py`) |
-| Reminder options | `REMINDER_OPTS` | `RemindersSelect` dropdown |
+| Banned message | `MSG_BANNED` | `common.py` | All banned checks |
-| Slots outcomes | `SLOTS_TIERS["tier"]` → `(title, color)` | `cmd_slots` |
+| Maintenance mode | `MSG_MAINTENANCE` | `common.py` | Shown when `_PAUSED=True` in `bot.py` (toggled by `/pause` in `commands/ops_admin_commands.py`) |
-| Embed titles | `TITLE["key"]` | `discord.Embed(title=S.TITLE["key"])` |
+| Reminder options | `REMINDER_OPTS` | `common.py` | `RemindersSelect` dropdown |
-| Error messages | `ERR["key"]` | `send_message(S.ERR["key"])` - use `.format(**kwargs)` for dynamic parts |
+| Slots outcomes | `SLOTS_TIERS["tier"]` → `(title, color)` | `games.py` | `cmd_slots` (in `commands/economy_games_commands.py`) |
-| Cooldown messages | `CD_MSG["cmd"].format(ts=_cd_ts(...))` | Cooldown responses |
+| Embed titles | `TITLE["key"]` | `common.py` | `discord.Embed(title=S.TITLE["key"])` |
-| Shop UI | `SHOP_UI["key"]` | `_shop_embed` |
+| Error messages | `ERR["key"]` | `common.py` | `send_message(S.ERR["key"])` - use `.format(**kwargs)` for dynamic parts |
-| Item descriptions | `ITEM_DESCRIPTIONS["item_key"]` | `economy.SHOP[key]["description"]` |
+| Cooldown messages | `CD_MSG["cmd"].format(ts=cd_ts(...))` | `common.py` | Cooldown responses (`cd_ts` helper passed in by `bot.py`) |
+| Shop UI | `SHOP_UI["key"]` | `economy.py` | `_shop_embed` (in `commands/economy_support_commands.py`) |
+| Item descriptions | `ITEM_DESCRIPTIONS["item_key"]` | `economy.py` | `core/economy/shop.py` `SHOP[key]["description"]` |
+| Patch notes UI | `PATCHNOTES_UI["key"]` | `common.py` | `commands/info_commands.py` (`/patchnotes`) |
 
 ---
 
 ## Constants Location Quick-Reference
 
-| Constant | File | Description |
+All are re-exported from `core/economy/__init__.py`, so code reads them as `economy.<NAME>` regardless of which submodule defines them. Edit the file in the **Defined in** column.
+
+| Constant | Defined in | Description |
 |---|---|---|
-| `SHOP` | `economy.py` | All shop items (name, emoji, cost, description) |
+| `SHOP` | `core/economy/shop.py` | All shop items (name, emoji, cost, description) |
-| `SHOP_TIERS` | `economy.py` | Which items are in T1/T2/T3 |
+| `SHOP_TIERS` | `core/economy/shop.py` | Which items are in T1/T2/T3 |
-| `SHOP_LEVEL_REQ` | `economy.py` | Min level per item |
+| `SHOP_LEVEL_REQ` | `core/economy/shop.py` | Min level per item |
-| `COOLDOWNS` | `economy.py` | Base cooldown per command |
+| `COOLDOWNS` | `core/economy/store.py` | Base cooldown per command |
-| `JAIL_DURATION` | `economy.py` | How long jail lasts |
+| `JAIL_DURATION` | `core/economy/store.py` | How long jail lasts |
-| `LEVEL_ROLES` | `economy.py` | `[(min_level, "RoleName"), ...]` highest first |
+| `LEVEL_ROLES` | `core/economy/levels.py` | `[(min_level, "RoleName"), ...]` highest first |
-| `ECONOMY_ROLE` | `economy.py` | Name of the base economy participation role |
+| `ECONOMY_ROLE` | `core/economy/levels.py` | Name of the base economy participation role |
-| `EXP_REWARDS` | `economy.py` | EXP per command |
+| `EXP_REWARDS` | `core/economy/levels.py` | EXP per command |
-| `HOUSE_ID` | `economy.py` | Bot's user ID (house account for /rob) |
+| `FISH_CATALOGUE` | `core/economy/fishing.py` | Fish species table (rarity, weight, coins, exp) |
-| `MIN_BAIL` | `economy.py` | Minimum bail payment (350⬡) |
+| `HOUSE_ID` | `core/economy/house.py` | Bot's user ID (house account for /rob) |
-| `COIN` | `economy.py` | The coin emoji string |
+| `MIN_BAIL` | `core/economy/jail.py` | Minimum bail payment (350⬡) |
+| `COIN` | `core/economy/store.py` | The coin emoji string |
 | `_PAUSED` | `bot.py` | In-memory maintenance flag; toggled by `/pause`; blocks all non-admin commands |
 
 ---

docs/PATCHNOTES.md

@@ -0,0 +1,25 @@
+# TipiBOT changelog
+
+Here you'll find an overview of TipiBOT updates. Latest changes are at the top.
+Format each version with a `## ` header (e.g. `## v0.1.0 — 2026-05-03`).
+
+## v0.3.0 — 2026-08-19
+
+- Added `/consumables` — a shop of repeatable, temporary boosts you can buy over and over again (unlike the permanent gear in `/shop`): **Energiajook XL** (1 hour of 2× earnings from `/work`, `/beg` and `/crime`), **XP jook** (1 hour of 2× EXP), and **Kohv** (instantly clears all your cooldowns). Run `/consumables` with no option to browse the menu and see which boosts are still ticking, or pick one to buy and activate it. Buying the same boost again extends its timer instead of wasting it.
+- Fixed a broken icon on the "jailed" line in `/cooldowns`
+
+## v0.2.0 — 2026-07-22
+
+- Added `/quests` — daily and weekly quests with a "claim rewards" button. Three daily quests refresh every day and two weekly quests refresh every week; every player gets their own personal set that rotates over time. Complete objectives like working, fishing, wagering, or pulling off crimes to earn TipiCOIN and EXP.
+- Fixed concurrent commands being able to overwrite each other's balance changes — every economy action now runs under a per-user lock, and house payouts use atomic database increments
+- Fixed the maintenance pause and channel restrictions never actually being enforced — the global command check was registered incorrectly and silently did nothing (command logging was also affected)
+
+## v0.1.0 — 2026-05-03
+
+- Added `/patchnotes`
+- Fixed silent swallowing of database write errors — failed saves now show the user an error instead of appearing to succeed
+- Fixed fish-sell bug that let the last fish be duplicated (sold and kept in inventory)
+- Fixed RPS PvP duels having no bet escrow — bets are now held when the duel is accepted, paid out to the winner, and refunded on tie / timeout / cancel (previously the loser could spend their balance before the duel resolved and the winner would get nothing)
+- Fixed multi-party transfers leaving coins in limbo on partial failures — `/give` and `/rob` now roll back the first commit if the second fails; heists try to refund the house when a participant payout fails
+- Fixed Google Sheets I/O blocking the Discord gateway — sheet reads/writes now run in a worker thread so heartbeats stay alive during slow API calls
+- Fixed migration script overwriting accumulated PocketBase state on re-run — fields not present in the legacy JSON are now preserved instead of being clobbered with defaults

docs/POCKETBASE_SETUP.md

@@ -13,9 +13,14 @@ Create your admin account on first launch via the Admin UI.
 
 ---
 
-## 2. Create the `economy_users` collection
+## 2. Create economy collections for both bot profiles
 
-In the Admin UI → **Collections** → **New collection** → name it exactly `economy_users`.
+In the Admin UI → **Collections** → **New collection** and create:
+
+- `economy_users_dev`
+- `economy_users_prod`
+
+Use the same schema for both collections.
 
 Add the following fields:
 
@@ -39,6 +44,17 @@ Add the following fields:
 
 > **Tip:** Set `user_id` as a unique index under **Indexes** tab.
 
+The table above is only the base schema. After creating the collections, run:
+
+```bash
+python scripts/sync_pb_schema.py
+```
+
+It derives the complete field list from the bot's user model and adds whatever
+is missing to **both** collections (stats, fishing, prestige, quests, ...).
+Re-run it after every update - PocketBase silently drops writes to fields that
+are not in the collection schema, which breaks features without any error.
+
 Set **API rules** (all four: list, view, create, update) to admin-only (leave blank / locked).
 
 ---
@@ -51,6 +67,8 @@ Add to your `.env`:
 PB_URL=http://127.0.0.1:8090
 PB_ADMIN_EMAIL=your-admin@email.com
 PB_ADMIN_PASSWORD=your-admin-password
+PB_ECONOMY_COLLECTION_DEV=economy_users_dev
+PB_ECONOMY_COLLECTION_ECONOMY=economy_users_prod
 ```
 
 ---

logs/transactions.log

@@ -1,108 +0,0 @@
-2026-04-01 18:44:29 | WORK              user=272518654715887618  earned=+54  lucky=False  bal=24077
-2026-04-01 20:02:11 | BEG               user=272518654715887618  earned=+23  jailed=False  bal=24100
-2026-04-01 20:02:53 | ROULETTE_WIN      user=178852380018868224  bet=15214708  colour=punane  result=punane  mult=1  bal=30429416
-2026-04-01 20:03:42 | ROULETTE_WIN      user=178852380018868224  bet=30429416  colour=must  result=must  mult=1  bal=60858832
-2026-04-01 20:04:16 | ROULETTE_LOSE     user=178852380018868224  bet=60858832  colour=punane  result=must  mult=1  bal=0
-2026-04-01 20:06:37 | BEG               user=401373976431165449  earned=+52  jailed=False  bal=8446
-2026-04-01 20:06:39 | WORK              user=401373976431165449  earned=+60  lucky=False  bal=8506
-2026-04-01 20:06:52 | DAILY             user=401373976431165449  earned=+750  streak=1  bal=9256
-2026-04-01 20:07:07 | DAILY             user=272518654715887618  earned=+825  streak=1  bal=24925
-2026-04-01 20:07:12 | CRIME_WIN         user=272518654715887618  earned=+331  bal=25256
-2026-04-01 20:07:38 | CRIME_WIN         user=401373976431165449  earned=+391  bal=9647
-2026-04-01 20:07:49 | BUY               user=401373976431165449  item=echolood  cost=-8000  bal=1647
-2026-04-01 20:09:16 | ROB_BLOCKED       robber=824516445382901800  victim=340451525799182357  fine=-118  robber_bal=891  ac_uses_left=1
-2026-04-01 20:09:23 | ROB_BLOCKED       robber=401373976431165449  victim=340451525799182357  fine=-175  robber_bal=1472  ac_uses_left=0
-2026-04-01 20:09:52 | ROB_WIN           robber=178852380018868224  victim=340451525799182357  stolen=+34868  jackpot=False  robber_bal=34868  victim_bal=140238
-2026-04-01 20:10:48 | DAILY             user=367347301322326016  earned=+712  streak=1  bal=8462
-2026-04-01 20:10:55 | WORK              user=367347301322326016  earned=+25  lucky=False  bal=8487
-2026-04-01 20:11:00 | BEG               user=367347301322326016  earned=+15  jailed=False  bal=8502
-2026-04-01 20:11:37 | ROB_FAIL          robber=272518654715887618  victim=340451525799182357  fine=-140  robber_bal=25116
-2026-04-01 20:15:19 | HEIST_FAIL        user=178852380018868224  fine=-1000  jailed_until=2026-04-01T18:45:19.705842+00:00  bal=33868
-2026-04-01 20:15:19 | HEIST_FAIL        user=340451525799182357  fine=-1000  jailed_until=2026-04-01T18:45:19.705842+00:00  bal=139238
-2026-04-01 20:15:19 | HEIST_FAIL        user=272518654715887618  fine=-1000  jailed_until=2026-04-01T18:45:19.705842+00:00  bal=24116
-2026-04-01 20:15:19 | HEIST_FAIL        user=209554152584380420  fine=-1000  jailed_until=2026-04-01T18:45:19.705842+00:00  bal=20112
-2026-04-01 20:15:19 | HEIST_FAIL        user=401373976431165449  fine=-220  jailed_until=2026-04-01T18:45:19.705842+00:00  bal=1252
-2026-04-01 20:15:19 | HEIST_FAIL        user=344531774518591498  fine=-1000  jailed_until=2026-04-01T18:45:19.705842+00:00  bal=112701
-2026-04-01 20:15:19 | HEIST_FAIL        user=367347301322326016  fine=-1000  jailed_until=2026-04-01T18:45:19.705842+00:00  bal=7502
-2026-04-01 20:15:45 | JAIL_FREE         user=272518654715887618  method=doubles
-2026-04-01 20:20:07 | JAIL_FREE         user=344531774518591498  method=doubles
-2026-04-01 20:20:14 | DAILY             user=344531774518591498  earned=+825  streak=1  bal=113526
-2026-04-01 20:20:16 | WORK              user=344531774518591498  earned=+45  lucky=False  bal=113571
-2026-04-01 20:20:19 | WORK              user=272518654715887618  earned=+55  lucky=False  bal=24171
-2026-04-01 20:20:19 | BEG               user=344531774518591498  earned=+22  jailed=False  bal=113593
-2026-04-01 20:20:36 | BLACKJACK         user=272518654715887618  payout=+0  net=-24171  bal=0
-2026-04-01 20:21:03 | CRIME_FAIL        user=344531774518591498  fine=-90  jailed=True  bal=113503
-2026-04-01 20:21:11 | FISH              user=272518654715887618  fish=koger  weight=590  value=15
-2026-04-01 20:21:45 | ROB_WIN           robber=344531774518591498  victim=340451525799182357  stolen=+15566  jackpot=False  robber_bal=129069  victim_bal=123672
-2026-04-01 20:25:40 | BAIL_PAID         user=178852380018868224  fine=-8760  pct=26%  bal=25108
-2026-04-01 20:28:28 | BEG               user=178852380018868224  earned=+28  jailed=False  bal=25136
-2026-04-01 20:28:30 | WORK              user=178852380018868224  earned=+92  lucky=False  bal=25228
-2026-04-01 20:28:33 | DAILY             user=178852380018868224  earned=+825  streak=1  bal=26053
-2026-04-01 20:28:38 | CRIME_WIN         user=178852380018868224  earned=+640  bal=26693
-2026-04-01 20:35:35 | BEG               user=401373976431165449  earned=+56  jailed=True  bal=1308
-2026-04-01 20:36:20 | JAIL_FREE         user=401373976431165449  method=doubles
-2026-04-01 20:37:47 | FISH              user=401373976431165449  fish=angerjas  weight=989  value=79
-2026-04-01 20:46:02 | DAILY             user=338622999127261185  earned=+300  streak=1  bal=300
-2026-04-01 20:56:03 | BEG               user=344531774518591498  earned=+60  jailed=False  bal=129129
-2026-04-01 20:56:29 | ROULETTE_LOSE     user=344531774518591498  bet=1000  colour=punane  result=must  mult=1  bal=128129
-2026-04-01 21:01:23 | BEG               user=272518654715887618  earned=+33  jailed=False  bal=33
-2026-04-01 21:01:42 | FISH              user=272518654715887618  fish=sarj  weight=151  value=6
-2026-04-01 21:02:38 | FISH              user=344531774518591498  fish=viidikas  weight=98  value=6
-2026-04-01 21:02:57 | FISH_SELL         user=344531774518591498  count=2  coins=+13  bal=128142
-2026-04-01 21:03:10 | BEG               user=401373976431165449  earned=+54  jailed=False  bal=1362
-2026-04-01 21:03:31 | FISH              user=401373976431165449  fish=siig  weight=584  value=63
-2026-04-01 21:05:19 | WORK              user=401373976431165449  earned=+131  lucky=False  bal=1493
-2026-04-01 21:05:38 | FISH              user=401373976431165449  fish=siig  weight=1624  value=112
-2026-04-01 21:05:48 | FISH_SELL         user=401373976431165449  count=3  coins=+254  bal=1747
-2026-04-01 21:08:31 | BEG               user=401373976431165449  earned=+32  jailed=False  bal=1779
-2026-04-01 21:08:45 | FISH              user=401373976431165449  fish=tougjas  weight=3051  value=207
-2026-04-01 21:09:01 | ROULETTE_WIN      user=401373976431165449  bet=1000  colour=punane  result=punane  mult=1  bal=2779
-2026-04-01 21:09:35 | BLACKJACK         user=401373976431165449  payout=+3000  net=+1500  bal=4279
-2026-04-01 21:09:35 | ROULETTE_LOSE     user=344531774518591498  bet=1000  colour=punane  result=must  mult=1  bal=127142
-2026-04-01 21:10:05 | ROULETTE_WIN      user=401373976431165449  bet=1000  colour=punane  result=punane  mult=1  bal=5279
-2026-04-01 21:10:46 | ROULETTE_WIN      user=344531774518591498  bet=1000  colour=punane  result=punane  mult=1  bal=128142
-2026-04-01 21:11:03 | ROULETTE_LOSE     user=401373976431165449  bet=1000  colour=must  result=punane  mult=1  bal=4279
-2026-04-01 21:11:24 | ROULETTE_LOSE     user=344531774518591498  bet=1000  colour=punane  result=roheline  mult=1  bal=127142
-2026-04-01 21:15:50 | WORK              user=338622999127261185  earned=+15  lucky=False  bal=315
-2026-04-01 21:15:54 | CRIME_WIN         user=338622999127261185  earned=+453  bal=768
-2026-04-01 21:16:00 | BEG               user=338622999127261185  earned=+20  jailed=False  bal=788
-2026-04-01 21:16:13 | FISH              user=338622999127261185  fish=ahven  weight=422  value=14
-2026-04-01 21:18:36 | BEG               user=401373976431165449  earned=+20  jailed=False  bal=4299
-2026-04-01 21:18:52 | FISH              user=401373976431165449  fish=karpkala  weight=1920  value=47
-2026-04-01 21:20:58 | SLOTS_TRIPLE      user=344531774518591498  bet=1000  change=4000  bal=131142
-2026-04-01 21:21:39 | SLOTS_MISS        user=344531774518591498  bet=1000  change=-1000  bal=130142
-2026-04-01 21:28:25 | ROULETTE_LOSE     user=401373976431165449  bet=1000  colour=punane  result=must  mult=1  bal=3299
-2026-04-01 21:29:10 | SLOTS_PAIR        user=344531774518591498  bet=1000  change=500  bal=130642
-2026-04-01 21:29:28 | ROULETTE_LOSE     user=401373976431165449  bet=1000  colour=punane  result=must  mult=1  bal=2299
-2026-04-01 21:30:49 | SLOTS_PAIR        user=344531774518591498  bet=1000  change=500  bal=131142
-2026-04-01 21:31:30 | SLOTS_PAIR        user=344531774518591498  bet=1000  change=500  bal=131642
-2026-04-01 21:31:33 | ROULETTE_WIN      user=401373976431165449  bet=1000  colour=punane  result=punane  mult=1  bal=3299
-2026-04-01 21:31:37 | BEG               user=401373976431165449  earned=+68  jailed=False  bal=3367
-2026-04-01 21:32:05 | FISH              user=401373976431165449  fish=latikas  weight=2351  value=66
-2026-04-01 21:33:14 | ROULETTE_LOSE     user=401373976431165449  bet=1000  colour=punane  result=must  mult=1  bal=2367
-2026-04-01 21:35:09 | SLOTS_MISS        user=344531774518591498  bet=1000  change=-1000  bal=130642
-2026-04-01 21:35:14 | ROULETTE_LOSE     user=401373976431165449  bet=1000  colour=punane  result=must  mult=1  bal=1367
-2026-04-01 21:48:35 | ROB_FAIL          robber=338622999127261185  victim=340451525799182357  fine=-237  robber_bal=551
-2026-04-01 21:49:59 | BEG               user=401373976431165449  earned=+56  jailed=False  bal=1423
-2026-04-01 21:50:15 | FISH              user=401373976431165449  fish=vimb  weight=856  value=462
-2026-04-01 22:11:02 | BEG               user=401373976431165449  earned=+52  jailed=False  bal=1475
-2026-04-01 22:11:13 | WORK              user=401373976431165449  earned=+73  lucky=False  bal=1548
-2026-04-01 22:11:27 | ROB_WIN           robber=401373976431165449  victim=367347301322326016  stolen=+1818  jackpot=False  robber_bal=3366  victim_bal=5684
-2026-04-01 22:11:44 | FISH              user=401373976431165449  fish=lohe  weight=2973  value=313
-2026-04-01 22:13:30 | ROULETTE_LOSE     user=401373976431165449  bet=2000  colour=punane  result=roheline  mult=1  bal=1366
-2026-04-01 22:14:33 | ROULETTE_LOSE     user=401373976431165449  bet=1366  colour=punane  result=must  mult=1  bal=0
-2026-04-01 22:40:19 | WORK              user=367347301322326016  earned=+82  lucky=False  bal=5766
-2026-04-01 22:40:23 | CRIME_FAIL        user=367347301322326016  fine=-100  jailed=True  bal=5666
-2026-04-01 22:46:27 | WORK              user=344531774518591498  earned=+116  lucky=False  bal=130758
-2026-04-01 22:46:30 | BEG               user=344531774518591498  earned=+58  jailed=False  bal=130816
-2026-04-01 22:46:35 | CRIME_WIN         user=344531774518591498  earned=+419  bal=131235
-2026-04-01 22:46:44 | ROB_FAIL          robber=344531774518591498  victim=340451525799182357  fine=-246  robber_bal=130989
-2026-04-01 22:47:01 | FISH              user=344531774518591498  fish=viidikas  weight=80  value=5
-2026-04-01 22:48:58 | WORK              user=178852380018868224  earned=+106  lucky=True  bal=26799
-2026-04-01 22:49:03 | CRIME_WIN         user=178852380018868224  earned=+486  bal=27285
-2026-04-01 22:49:05 | BEG               user=178852380018868224  earned=+76  jailed=False  bal=27361
-2026-04-01 22:52:25 | BEG               user=401373976431165449  earned=+44  jailed=False  bal=44
-2026-04-01 22:52:29 | WORK              user=401373976431165449  earned=+103  lucky=False  bal=147
-2026-04-01 22:52:39 | CRIME_FAIL        user=401373976431165449  fine=-125  jailed=False  bal=22
-2026-04-01 22:53:01 | FISH              user=401373976431165449  fish=latikas  weight=1217  value=40
-2026-04-01 22:57:11 | SLOTS_PAIR        user=344531774518591498  bet=10000  change=5000  bal=135989

member_sync.py

@@ -1,213 +0,0 @@
-"""Member synchronization logic - roles, nicknames, birthdays."""
-
-from __future__ import annotations
-
-import logging
-from datetime import datetime, date
-from dataclasses import dataclass, field
-
-import discord
-
-import config
-import sheets
-
-log = logging.getLogger(__name__)
-_PLACEHOLDER = {"-", "x", "n/a", "none", "ei"}
-
-
-def _is_placeholder(val: str) -> bool:
-    """Return True if a sheet cell value is an intentional empty marker."""
-    return not val.strip() or val.strip().lower() in _PLACEHOLDER
-
-
-# Maps sheet role values to Discord role names where they differ
-ROLE_NAME_MAP: dict[str, str] = {
-    "Juht": "Tiimijuht",
-    "Admin": "+",
-}
-
-
-@dataclass
-class SyncResult:
-    """Tracks what happened during a sync operation."""
-    nickname_changed: bool = False
-    roles_added: list[str] = field(default_factory=list)
-    roles_removed: list[str] = field(default_factory=list)
-    birthday_soon: bool = False
-    not_found: bool = False
-    errors: list[str] = field(default_factory=list)
-    synced: bool = False  # True when no errors; caller writes this to the sheet
-
-    @property
-    def changed(self) -> bool:
-        return self.nickname_changed or self.roles_added or self.roles_removed
-
-
-def _format_nickname(full_name: str) -> str:
-    """Format a nickname from a full name: first name + last name initial.
-
-    Examples:
-        'Mari Tamm'       -> 'Mari T'
-        'Mari-Liis Tamm'  -> 'Mari-Liis T'
-        'Jaan'            -> 'Jaan'
-    """
-    parts = full_name.strip().split()
-    if len(parts) < 2:
-        return full_name.strip()
-    first = parts[0]  # preserves hyphenated names like Mari-Liis
-    last_initial = parts[-1][0].upper()
-    return f"{first} {last_initial}"
-
-
-def _parse_roles(roles_str: str) -> list[str]:
-    """Parse comma-separated role names from the sheet."""
-    if not roles_str:
-        return []
-    return [r.strip().rstrip(".,;:!?") for r in str(roles_str).split(",") if r.strip()]
-
-
-def _parse_birthday(raw: str) -> date | None:
-    """Parse a birthday string robustly. Returns None for garbage/placeholder values."""
-    raw = str(raw).strip()
-    if _is_placeholder(raw):
-        return None
-    today = date.today()
-    for fmt, has_year in [("%d/%m/%Y", True), ("%Y-%m-%d", True), ("%m-%d", False)]:
-        try:
-            parsed = datetime.strptime(raw, fmt).date()
-            if has_year and not (1920 <= parsed.year <= today.year):
-                return None  # unrealistic year (formula artefact, future year, etc.)
-            return parsed if has_year else parsed.replace(year=today.year)
-        except ValueError:
-            continue
-    return None
-
-
-def _is_birthday_soon(birthday_str: str, window_days: int | None = None) -> bool:
-    """Check if a birthday falls within the configured window."""
-    bday = _parse_birthday(birthday_str)
-    if bday is None:
-        return False
-    window = window_days or config.BIRTHDAY_WINDOW_DAYS
-    today = date.today()
-    this_year_bday = bday.replace(year=today.year)
-    if this_year_bday < today:
-        this_year_bday = bday.replace(year=today.year + 1)
-    delta = (this_year_bday - today).days
-    return 0 <= delta <= window
-
-
-def is_birthday_today(birthday_str: str) -> bool:
-    """Return True if today is the member's birthday (any supported date format)."""
-    bday = _parse_birthday(birthday_str)
-    if bday is None:
-        return False
-    today = date.today()
-    return bday.month == today.month and bday.day == today.day
-
-
-async def sync_member(
-    member: discord.Member,
-    guild: discord.Guild,
-) -> SyncResult:
-    """Synchronize a single member's nickname and roles based on sheet data.
-
-    Also populates Discord ID in the sheet if missing, and updates username.
-    Returns a SyncResult describing what happened.
-    """
-    result = SyncResult()
-
-    # Look up member in sheet cache
-    row = sheets.find_member(member.id, member.name)
-    if row is None:
-        result.not_found = True
-        return result
-
-    # --- Backfill User ID if missing ---
-    raw_id = str(row.get("User ID", "")).strip()
-    if not raw_id or raw_id == "0":
-        sheets.set_user_id(member.name, member.id)
-
-    # --- Update Discord username in sheet if it changed ---
-    sheet_username = str(row.get("Discord", "")).strip()
-    if sheet_username.lower() != member.name.lower():
-        sheets.update_username(member.id, member.name)
-
-    # --- Nickname (Nimi = real name, formatted as first name + last initial) ---
-    nimi = str(row.get("Nimi", "")).strip()
-    desired_nick = _format_nickname(nimi) if nimi else None
-    if desired_nick and member.nick != desired_nick:
-        try:
-            await member.edit(nick=desired_nick)
-            result.nickname_changed = True
-        except discord.Forbidden:
-            log.debug("No permission to set nickname for %s (likely admin), skipping", member)
-        except discord.HTTPException as e:
-            result.errors.append(f"Hüüdnime viga kasutajale {member}: {e}")
-
-    # --- Roles (from Organisatsioon, Valdkond, Roll columns; values may be comma-separated) ---
-    desired_role_names: list[str] = []
-    for col in ("Organisatsioon", "Valdkond", "Roll"):
-        val = str(row.get(col, "")).strip()
-        if not _is_placeholder(val):
-            desired_role_names.extend(
-                r for r in _parse_roles(val)
-                if not _is_placeholder(r)
-            )
-    desired_roles: list[discord.Role] = []
-    for rname in desired_role_names:
-        rname = ROLE_NAME_MAP.get(rname, rname)
-        role = discord.utils.get(guild.roles, name=rname)
-        if role:
-            desired_roles.append(role)
-        else:
-            result.errors.append(f"Rolli '{rname}' ei leitud serverist")
-
-    # Base roles that every synced member must have
-    for rid in config.BASE_ROLE_IDS:
-        role = guild.get_role(rid)
-        if role:
-            desired_roles.append(role)
-        else:
-            result.errors.append(f"Baasrolli ID {rid} ei leitud serverist")
-
-    # Roles to add (desired but member doesn't have)
-    to_add = [r for r in desired_roles if r not in member.roles]
-    # (we currently only ADD the desired roles, not remove extras - safe default)
-
-    if to_add:
-        try:
-            await member.add_roles(*to_add, reason="Sheet sync")
-            result.roles_added = [r.name for r in to_add]
-        except discord.Forbidden:
-            log.debug("No permission to add roles for %s (likely admin), skipping", member)
-        except discord.HTTPException as e:
-            result.errors.append(f"Rolli viga kasutajale {member}: {e}")
-
-    # --- Birthday check ---
-    birthday_str = str(row.get("Sünnipäev", "")).strip()
-    if not _is_placeholder(birthday_str) and _is_birthday_soon(birthday_str):
-        result.birthday_soon = True
-
-    # --- Mark synced (caller is responsible for writing to sheet) ---
-    result.synced = not bool(result.errors)
-
-    return result
-
-
-async def announce_birthday(
-    member: discord.Member,
-    bot: discord.Client,
-) -> None:
-    """Send a birthday-coming-soon announcement to the configured channel."""
-    channel = bot.get_channel(config.BIRTHDAY_CHANNEL_ID)
-    if channel is None:
-        log.warning("Birthday channel %s not found", config.BIRTHDAY_CHANNEL_ID)
-        return
-
-    row = sheets.find_member(member.id, member.name)
-    bday_str = str(row.get("Sünnipäev", "")) if row else "?"
-
-    await channel.send(
-        f"🎂 @here **{member.display_name}** sünnipäev on täna! 🥳 Palju-palju õnne sünnipäevaks! 🎉"
-    )

pb_client.py

@@ -1,152 +0,0 @@
-"""Async PocketBase REST client for TipiLAN Bot.
-
-Handles admin authentication (auto-refreshed), and CRUD operations on the
-economy_users collection.  Uses aiohttp, which discord.py already depends on.
-
-Environment variables (set in .env):
-    PB_URL              Base URL of PocketBase  (default: http://127.0.0.1:8090)
-    PB_ADMIN_EMAIL      PocketBase admin e-mail
-    PB_ADMIN_PASSWORD   PocketBase admin password
-"""
-
-from __future__ import annotations
-
-import asyncio
-import logging
-import os
-import time
-from typing import Any
-
-import aiohttp
-
-_log = logging.getLogger("tipiCOIN.pb")
-
-PB_URL = os.getenv("PB_URL", "http://127.0.0.1:8090")
-PB_ADMIN_EMAIL = os.getenv("PB_ADMIN_EMAIL", "")
-PB_ADMIN_PASSWORD = os.getenv("PB_ADMIN_PASSWORD", "")
-ECONOMY_COLLECTION = "economy_users"
-
-_TIMEOUT = aiohttp.ClientTimeout(total=10)
-
-# ---------------------------------------------------------------------------
-# Persistent session (created once, reused for the lifetime of the process)
-# ---------------------------------------------------------------------------
-_session: aiohttp.ClientSession | None = None
-
-
-def _get_session() -> aiohttp.ClientSession:
-    global _session
-    if _session is None or _session.closed:
-        _session = aiohttp.ClientSession(timeout=_TIMEOUT)
-    return _session
-
-
-# ---------------------------------------------------------------------------
-# Auth token cache
-# ---------------------------------------------------------------------------
-_token: str = ""
-_token_expiry: float = 0.0
-_auth_lock = asyncio.Lock()
-
-
-async def _ensure_auth() -> str:
-    global _token, _token_expiry
-    async with _auth_lock:
-        if time.monotonic() < _token_expiry:
-            return _token
-        session = _get_session()
-        async with session.post(
-            f"{PB_URL}/api/collections/_superusers/auth-with-password",
-            json={"identity": PB_ADMIN_EMAIL, "password": PB_ADMIN_PASSWORD},
-        ) as resp:
-            if resp.status != 200:
-                text = await resp.text()
-                raise RuntimeError(f"PocketBase auth failed ({resp.status}): {text}")
-            data = await resp.json()
-            _token = data["token"]
-            _token_expiry = time.monotonic() + 13 * 24 * 3600  # refresh well before expiry
-            _log.debug("PocketBase admin token refreshed")
-    return _token
-
-
-async def _hdrs() -> dict[str, str]:
-    return {"Authorization": await _ensure_auth()}
-
-
-# ---------------------------------------------------------------------------
-# CRUD helpers
-# ---------------------------------------------------------------------------
-
-async def get_record(user_id: str) -> dict[str, Any] | None:
-    """Fetch one economy record by Discord user_id. Returns None if not found."""
-    session = _get_session()
-    async with session.get(
-        f"{PB_URL}/api/collections/{ECONOMY_COLLECTION}/records",
-        params={"filter": f'user_id="{user_id}"', "perPage": 1},
-        headers=await _hdrs(),
-    ) as resp:
-        resp.raise_for_status()
-        data = await resp.json()
-        items = data.get("items", [])
-        return items[0] if items else None
-
-
-async def create_record(record: dict[str, Any]) -> dict[str, Any]:
-    """Create a new economy record. Returns the created record (includes PB id)."""
-    session = _get_session()
-    async with session.post(
-        f"{PB_URL}/api/collections/{ECONOMY_COLLECTION}/records",
-        json=record,
-        headers=await _hdrs(),
-    ) as resp:
-        if resp.status not in (200, 201):
-            text = await resp.text()
-            raise RuntimeError(f"PocketBase create failed ({resp.status}): {text}")
-        return await resp.json()
-
-
-async def update_record(record_id: str, data: dict[str, Any]) -> dict[str, Any]:
-    """PATCH an existing record by its PocketBase record id."""
-    session = _get_session()
-    async with session.patch(
-        f"{PB_URL}/api/collections/{ECONOMY_COLLECTION}/records/{record_id}",
-        json=data,
-        headers=await _hdrs(),
-    ) as resp:
-        resp.raise_for_status()
-        return await resp.json()
-
-
-async def count_records() -> int:
-    """Return the total number of records in the collection (single cheap request)."""
-    session = _get_session()
-    async with session.get(
-        f"{PB_URL}/api/collections/{ECONOMY_COLLECTION}/records",
-        params={"perPage": 1, "page": 1},
-        headers=await _hdrs(),
-    ) as resp:
-        resp.raise_for_status()
-        data = await resp.json()
-        return int(data.get("totalItems", 0))
-
-
-async def list_all_records(page_size: int = 500) -> list[dict[str, Any]]:
-    """Fetch every record in the collection, handling PocketBase pagination."""
-    results: list[dict[str, Any]] = []
-    page = 1
-    session = _get_session()
-    hdrs = await _hdrs()
-    while True:
-        async with session.get(
-            f"{PB_URL}/api/collections/{ECONOMY_COLLECTION}/records",
-            params={"perPage": page_size, "page": page},
-            headers=hdrs,
-        ) as resp:
-            resp.raise_for_status()
-            data = await resp.json()
-            batch = data.get("items", [])
-            results.extend(batch)
-            if len(batch) < page_size:
-                break
-            page += 1
-    return results

requirements-dev.txt

@@ -0,0 +1,2 @@
+-r requirements.txt
+pytest>=8.0

scripts/add_quest_fields.py

@@ -0,0 +1,101 @@
+"""Add the quest-system JSON fields to the economy_users PocketBase collection.
+
+Run once after pulling the quest changes:
+    python scripts/add_quest_fields.py
+
+Requirements:
+    - PocketBase running and reachable at PB_URL
+    - PB_ADMIN_EMAIL / PB_ADMIN_PASSWORD set in .env
+"""
+
+from __future__ import annotations
+
+import asyncio
+import sys
+from pathlib import Path
+
+import aiohttp
+from dotenv import load_dotenv
+
+sys.path.insert(0, str(Path(__file__).parent.parent))
+load_dotenv()
+
+import config  # noqa: E402
+
+PB_URL = config.PB_URL
+PB_ADMIN_EMAIL = config.PB_ADMIN_EMAIL
+PB_ADMIN_PASSWORD = config.PB_ADMIN_PASSWORD
+# Patch both profiles' collections so the result doesn't depend on which
+# BOT_PROFILE happened to be set when the script was run.
+COLLECTIONS = sorted({config.PB_ECONOMY_COLLECTION_DEV, config.PB_ECONOMY_COLLECTION_ECONOMY})
+
+# ---------------------------------------------------------------------------
+# New fields to add
+# ---------------------------------------------------------------------------
+_NEW_JSON_FIELDS = [
+    "quest_daily",
+    "quest_weekly",
+]
+
+
+def _json_field(name: str) -> dict:
+    return {"name": name, "type": "json", "required": False}
+
+
+async def main() -> None:
+    timeout = aiohttp.ClientTimeout(total=15)
+    async with aiohttp.ClientSession(timeout=timeout) as session:
+        # ── Authenticate ────────────────────────────────────────────────────
+        async with session.post(
+            f"{PB_URL}/api/collections/_superusers/auth-with-password",
+            json={"identity": PB_ADMIN_EMAIL, "password": PB_ADMIN_PASSWORD},
+        ) as resp:
+            if resp.status != 200:
+                print(f"Auth failed ({resp.status}): {await resp.text()}")
+                return
+            token = (await resp.json())["token"]
+
+        hdrs = {"Authorization": token}
+
+        for collection in COLLECTIONS:
+            print(f"── {collection} ──")
+
+            # ── Fetch current collection ─────────────────────────────────────
+            async with session.get(
+                f"{PB_URL}/api/collections/{collection}", headers=hdrs
+            ) as resp:
+                if resp.status != 200:
+                    print(f"Could not fetch collection ({resp.status}): {await resp.text()}\n")
+                    continue
+                col = await resp.json()
+
+            existing = {f["name"] for f in col.get("fields", [])}
+            print(f"Existing fields ({len(existing)}): {sorted(existing)}\n")
+
+            new_fields = []
+            for name in _NEW_JSON_FIELDS:
+                if name not in existing:
+                    new_fields.append(_json_field(name))
+                    print(f"  + {name}  (json)")
+                else:
+                    print(f"  = {name}  (already exists)")
+
+            if not new_fields:
+                print("Nothing to add - schema already up to date.\n")
+                continue
+
+            # ── Patch collection schema ──────────────────────────────────────
+            updated_fields = col.get("fields", []) + new_fields
+            async with session.patch(
+                f"{PB_URL}/api/collections/{collection}",
+                json={"fields": updated_fields},
+                headers=hdrs,
+            ) as resp:
+                if resp.status != 200:
+                    print(f"Schema update failed ({resp.status}): {await resp.text()}\n")
+                    continue
+                print(f"✅ Added {len(new_fields)} field(s) successfully.\n")
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

scripts/add_stats_fields.py

@@ -11,7 +11,6 @@ Requirements:
 from __future__ import annotations
 
 import asyncio
-import os
 import sys
 from pathlib import Path
 
@@ -21,10 +20,12 @@ from dotenv import load_dotenv
 sys.path.insert(0, str(Path(__file__).parent.parent))
 load_dotenv()
 
-PB_URL            = os.getenv("PB_URL", "http://127.0.0.1:8090")
+import config  # noqa: E402
-PB_ADMIN_EMAIL    = os.getenv("PB_ADMIN_EMAIL", "")
+
-PB_ADMIN_PASSWORD = os.getenv("PB_ADMIN_PASSWORD", "")
+PB_URL = config.PB_URL
-COLLECTION        = "economy_users"
+PB_ADMIN_EMAIL = config.PB_ADMIN_EMAIL
+PB_ADMIN_PASSWORD = config.PB_ADMIN_PASSWORD
+COLLECTION = config.PB_ECONOMY_COLLECTION
 
 # ---------------------------------------------------------------------------
 # New fields to add

scripts/migrate_to_pb.py

@@ -23,12 +23,12 @@ from pathlib import Path
 
 from dotenv import load_dotenv
 
-# Ensure the project root is on sys.path so pb_client can be imported
+# Ensure the project root is on sys.path so core modules can be imported
 sys.path.insert(0, str(Path(__file__).parent.parent))
 
 load_dotenv()
 
-import pb_client  # noqa: E402  (needs dotenv loaded first)
+from core import pb_client  # noqa: E402  (needs dotenv loaded first)
 
 DATA_FILE = Path("data") / "economy.json"
 
@@ -42,26 +42,32 @@ async def main() -> None:
     total = len(raw)
     print(f"Found {total} user(s) in {DATA_FILE}")
 
-    created = skipped = errors = 0
+    created = updated = errors = 0
 
     for uid, user in raw.items():
         try:
-            record = dict(user)
-            record["user_id"] = uid
-            record.setdefault("balance", 0)
-            record.setdefault("exp", 0)
-            record.setdefault("items", [])
-            record.setdefault("item_uses", {})
-            record.setdefault("reminders", ["daily", "work", "beg", "crime", "rob"])
-            record.setdefault("eco_banned", False)
-            record.setdefault("daily_streak", 0)
-
             existing = await pb_client.get_record(uid)
             if existing:
-                await pb_client.update_record(existing["id"], record)
+                # Merge JSON fields *onto* the existing record so values that have
+                # accumulated in PB (items, daily_streak, reminders, etc.) are not
+                # clobbered by JSON defaults on a re-run. JSON values take
+                # precedence only for keys that are actually present.
+                merged: dict = {k: v for k, v in existing.items() if not k.startswith("_") and k != "id"}
+                merged.update(user)
+                merged["user_id"] = uid
+                await pb_client.update_record(existing["id"], merged)
                 print(f"  [UPDATE] {uid}")
-                skipped += 1  # reuse skipped counter as "updated"
+                updated += 1
             else:
+                record = dict(user)
+                record["user_id"] = uid
+                record.setdefault("balance", 0)
+                record.setdefault("exp", 0)
+                record.setdefault("items", [])
+                record.setdefault("item_uses", {})
+                record.setdefault("reminders", ["daily", "work", "beg", "crime", "rob"])
+                record.setdefault("eco_banned", False)
+                record.setdefault("daily_streak", 0)
                 await pb_client.create_record(record)
                 print(f"  [CREATE] {uid}")
                 created += 1
@@ -69,7 +75,9 @@ async def main() -> None:
             print(f"  [ERROR] {uid}: {exc}")
             errors += 1
 
-    print(f"\nDone. Created: {created}  Skipped: {skipped}  Errors: {errors}")
+    print(f"\nDone. Created: {created}  Updated: {updated}  Errors: {errors}")
+    if errors:
+        sys.exit(1)
 
 
 if __name__ == "__main__":

scripts/reset_pb_collections.py

@@ -0,0 +1,180 @@
+"""Destructively recreate economy PocketBase collections for dev + economy profiles.
+
+Usage:
+    python scripts/reset_pb_collections.py --confirm
+
+This will DELETE and recreate the collections configured by:
+- PB_ECONOMY_COLLECTION_DEV
+- PB_ECONOMY_COLLECTION_ECONOMY
+"""
+
+from __future__ import annotations
+
+import argparse
+import asyncio
+import sys
+from pathlib import Path
+
+import aiohttp
+from dotenv import load_dotenv
+
+sys.path.insert(0, str(Path(__file__).parent.parent))
+load_dotenv()
+
+import config  # noqa: E402
+
+PB_URL = config.PB_URL
+PB_ADMIN_EMAIL = config.PB_ADMIN_EMAIL
+PB_ADMIN_PASSWORD = config.PB_ADMIN_PASSWORD
+
+
+def _text_field(name: str, required: bool = False) -> dict:
+    return {
+        "name": name,
+        "type": "text",
+        "required": required,
+        "options": {"min": None, "max": None, "pattern": ""},
+    }
+
+
+def _number_field(name: str) -> dict:
+    return {
+        "name": name,
+        "type": "number",
+        "required": False,
+        "options": {"min": None, "max": None, "noDecimal": False},
+    }
+
+
+def _bool_field(name: str) -> dict:
+    return {"name": name, "type": "bool", "required": False}
+
+
+def _json_field(name: str) -> dict:
+    return {"name": name, "type": "json", "required": False}
+
+
+def _collection_payload(name: str) -> dict:
+    fields = [
+        _text_field("user_id", required=True),
+        _number_field("balance"),
+        _number_field("exp"),
+        _number_field("daily_streak"),
+        _text_field("last_daily"),
+        _text_field("last_work"),
+        _text_field("last_beg"),
+        _text_field("last_crime"),
+        _text_field("last_rob"),
+        _text_field("last_heist"),
+        _text_field("last_streak_date"),
+        _text_field("jailed_until"),
+        _text_field("last_fish"),
+        _json_field("items"),
+        _json_field("item_uses"),
+        _json_field("reminders"),
+        _json_field("prestige_upgrades"),
+        _json_field("fish_book"),
+        _json_field("fish_inventory"),
+        _bool_field("eco_banned"),
+        _bool_field("jailbreak_used"),
+        _number_field("heist_global_cd_until"),
+        _number_field("peak_balance"),
+        _number_field("lifetime_earned"),
+        _number_field("lifetime_lost"),
+        _number_field("work_count"),
+        _number_field("beg_count"),
+        _number_field("total_wagered"),
+        _number_field("biggest_win"),
+        _number_field("biggest_loss"),
+        _number_field("slots_jackpots"),
+        _number_field("crimes_attempted"),
+        _number_field("crimes_succeeded"),
+        _number_field("times_jailed"),
+        _number_field("total_bail_paid"),
+        _number_field("heists_joined"),
+        _number_field("heists_won"),
+        _number_field("total_given"),
+        _number_field("total_received"),
+        _number_field("best_daily_streak"),
+        _number_field("prestige_level"),
+        _number_field("prestige_points"),
+        _number_field("season_total_exp"),
+        _number_field("total_fish_caught"),
+    ]
+
+    return {
+        "name": name,
+        "type": "base",
+        "fields": fields,
+        "listRule": None,
+        "viewRule": None,
+        "createRule": None,
+        "updateRule": None,
+        "deleteRule": None,
+    }
+
+
+async def _auth_token(session: aiohttp.ClientSession) -> str:
+    async with session.post(
+        f"{PB_URL}/api/collections/_superusers/auth-with-password",
+        json={"identity": PB_ADMIN_EMAIL, "password": PB_ADMIN_PASSWORD},
+    ) as resp:
+        if resp.status != 200:
+            raise RuntimeError(f"Auth failed ({resp.status}): {await resp.text()}")
+        return (await resp.json())["token"]
+
+
+async def _delete_if_exists(session: aiohttp.ClientSession, headers: dict[str, str], name: str) -> None:
+    async with session.get(f"{PB_URL}/api/collections/{name}", headers=headers) as resp:
+        if resp.status == 404:
+            print(f"[SKIP] {name} does not exist")
+            return
+        if resp.status != 200:
+            raise RuntimeError(f"Could not fetch {name} ({resp.status}): {await resp.text()}")
+
+    async with session.delete(f"{PB_URL}/api/collections/{name}", headers=headers) as resp:
+        if resp.status not in (200, 204):
+            raise RuntimeError(f"Delete failed for {name} ({resp.status}): {await resp.text()}")
+    print(f"[DELETE] {name}")
+
+
+async def _create_collection(session: aiohttp.ClientSession, headers: dict[str, str], name: str) -> None:
+    payload = _collection_payload(name)
+    async with session.post(f"{PB_URL}/api/collections", json=payload, headers=headers) as resp:
+        if resp.status not in (200, 201):
+            raise RuntimeError(f"Create failed for {name} ({resp.status}): {await resp.text()}")
+    print(f"[CREATE] {name}")
+
+
+async def main() -> None:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--confirm", action="store_true", help="Required flag to run destructive reset")
+    args = parser.parse_args()
+
+    if not args.confirm:
+        raise SystemExit("Refusing to run without --confirm (this operation deletes collections).")
+
+    targets = []
+    for name in [config.PB_ECONOMY_COLLECTION_DEV, config.PB_ECONOMY_COLLECTION_ECONOMY]:
+        if name and name not in targets:
+            targets.append(name)
+
+    if not targets:
+        raise SystemExit("No target collections configured.")
+
+    timeout = aiohttp.ClientTimeout(total=20)
+    async with aiohttp.ClientSession(timeout=timeout) as session:
+        token = await _auth_token(session)
+        headers = {"Authorization": token}
+
+        for name in targets:
+            await _delete_if_exists(session, headers, name)
+            await _create_collection(session, headers, name)
+
+    print("\nDone. Collections recreated:")
+    for name in targets:
+        print(f" - {name}")
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

scripts/sync_pb_schema.py

@@ -0,0 +1,131 @@
+"""Reconcile the PocketBase economy collections with the bot's user schema.
+
+The expected field list is derived from core.economy._default_user() - the
+single source of truth for what the bot persists - so this supersedes
+add_stats_fields.py / add_quest_fields.py and also covers the fields those
+scripts never added (fishing, prestige, quests, last_heist, ...).
+
+PocketBase silently drops record fields that are missing from the collection
+schema, so any drift here breaks features without a single error message.
+
+Patches BOTH profile collections regardless of BOT_PROFILE. Only ever adds
+fields; existing fields are never removed or retyped (type mismatches are
+reported for manual review).
+
+    python scripts/sync_pb_schema.py           # add whatever is missing
+    python scripts/sync_pb_schema.py --check   # report only; exit 1 on drift
+"""
+
+from __future__ import annotations
+
+import asyncio
+import sys
+from pathlib import Path
+
+import aiohttp
+from dotenv import load_dotenv
+
+sys.path.insert(0, str(Path(__file__).parent.parent))
+load_dotenv()
+
+import config  # noqa: E402
+from core import economy  # noqa: E402
+
+PB_URL = config.PB_URL
+COLLECTIONS = sorted({config.PB_ECONOMY_COLLECTION_DEV, config.PB_ECONOMY_COLLECTION_ECONOMY})
+
+# _default_user() keys whose default is None, all ISO date/datetime strings
+_TEXT_FIELDS = {
+    "last_daily", "last_work", "last_beg", "last_crime", "last_rob",
+    "last_heist", "last_fish", "last_streak_date", "jailed_until",
+}
+
+
+def _expected_fields() -> dict[str, str]:
+    """Map every persisted field name to its PocketBase field type."""
+    expected = {"user_id": "text"}
+    for key, default in economy._default_user().items():
+        if key in _TEXT_FIELDS:
+            expected[key] = "text"
+        elif isinstance(default, bool):
+            expected[key] = "bool"
+        elif isinstance(default, (int, float)):
+            expected[key] = "number"
+        elif isinstance(default, (list, dict)):
+            expected[key] = "json"
+        else:
+            raise SystemExit(
+                f"Cannot infer a PocketBase type for {key!r} (default {default!r}). "
+                "Add it to _TEXT_FIELDS or extend the mapping."
+            )
+    return expected
+
+
+async def main() -> int:
+    check_only = "--check" in sys.argv
+    expected = _expected_fields()
+    drift = False
+
+    timeout = aiohttp.ClientTimeout(total=15)
+    async with aiohttp.ClientSession(timeout=timeout) as session:
+        async with session.post(
+            f"{PB_URL}/api/collections/_superusers/auth-with-password",
+            json={"identity": config.PB_ADMIN_EMAIL, "password": config.PB_ADMIN_PASSWORD},
+        ) as resp:
+            if resp.status != 200:
+                print(f"Auth failed ({resp.status}): {await resp.text()}")
+                return 1
+            hdrs = {"Authorization": (await resp.json())["token"]}
+
+        for collection in COLLECTIONS:
+            print(f"── {collection} ──")
+            async with session.get(
+                f"{PB_URL}/api/collections/{collection}", headers=hdrs
+            ) as resp:
+                if resp.status != 200:
+                    print(f"Could not fetch collection ({resp.status}): {await resp.text()}\n")
+                    drift = True
+                    continue
+                col = await resp.json()
+
+            existing = {f["name"]: f.get("type", "?") for f in col.get("fields", [])}
+
+            missing = [name for name in expected if name not in existing]
+            mismatched = [
+                (name, existing[name], ftype)
+                for name, ftype in expected.items()
+                if name in existing and existing[name] != ftype
+            ]
+
+            for name, have, want in mismatched:
+                drift = True
+                print(f"  ! {name}: schema has type '{have}', bot expects '{want}' - fix manually")
+
+            if not missing:
+                print("  ✓ no missing fields\n" if not mismatched else "")
+                continue
+
+            drift = True
+            for name in missing:
+                print(f"  + {name}  ({expected[name]})")
+
+            if check_only:
+                print()
+                continue
+
+            new_fields = [{"name": name, "type": expected[name]} for name in missing]
+            async with session.patch(
+                f"{PB_URL}/api/collections/{collection}",
+                json={"fields": col.get("fields", []) + new_fields},
+                headers=hdrs,
+            ) as resp:
+                if resp.status != 200:
+                    print(f"  Schema update failed ({resp.status}): {await resp.text()}\n")
+                    continue
+                print(f"  ✅ added {len(new_fields)} field(s)\n")
+
+    return 1 if (check_only and drift) else 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(asyncio.run(main()))

sheets.py

@@ -1,216 +0,0 @@
-"""Google Sheets integration - read/write member data via gspread."""
-
-import gspread
-from google.oauth2.service_account import Credentials
-
-import config
-
-# Scopes needed: read + write to Sheets
-SCOPES = [
-    "https://www.googleapis.com/auth/spreadsheets",
-    "https://www.googleapis.com/auth/drive",
-]
-
-# ---------------------------------------------------------------------------
-# Expected sheet columns (header row):
-#   Nimi | Organisatsioon | Meil | Discord | User ID | Sünnipäev |
-#   Telefon | Valdkond | Roll | Discordis synced? | Groupi lisatud?
-#
-# - Nimi              : member's real name (used as Discord nickname)
-# - Organisatsioon    : organisation value - maps to a Discord role
-# - Meil              : email address (read-only for bot)
-# - Discord           : Discord username for initial matching
-# - User ID           : numeric Discord user ID (bot can populate this)
-# - Sünnipäev         : birthday date string (YYYY-MM-DD or MM-DD)
-# - Telefon           : phone number (read-only for bot)
-# - Valdkond          : field/area value - maps to a Discord role
-# - Roll              : role value - maps to a Discord role
-# - Discordis synced? : TRUE/FALSE - bot writes this after confirming sync
-# - Groupi lisatud?   : group membership flag (managed externally)
-# ---------------------------------------------------------------------------
-
-EXPECTED_HEADERS = [
-    "Nimi",
-    "Organisatsioon",
-    "Meil",
-    "Discord",
-    "User ID",
-    "Sünnipäev",
-    "Telefon",
-    "Valdkond",
-    "Roll",
-    "Discordis synced?",
-    "Groupi lisatud?",
-]
-
-_client: gspread.Client | None = None
-_worksheet: gspread.Worksheet | None = None
-
-# In-memory cache: list of dicts (one per row)
-_cache: list[dict] = []
-
-
-def _get_worksheet() -> gspread.Worksheet:
-    """Authenticate and return the first worksheet of the configured sheet."""
-    global _client, _worksheet
-    creds = Credentials.from_service_account_file(config.GOOGLE_CREDS_PATH, scopes=SCOPES)
-    _client = gspread.authorize(creds)
-    spreadsheet = _client.open_by_key(config.SHEET_ID)
-    _worksheet = spreadsheet.sheet1
-    return _worksheet
-
-
-def _ensure_headers(ws: gspread.Worksheet) -> None:
-    """If the sheet is empty or missing headers, write them (headers are in row 1)."""
-    existing = ws.row_values(1)
-    if existing != EXPECTED_HEADERS:
-        for col_idx, header in enumerate(EXPECTED_HEADERS, start=1):
-            if col_idx > len(existing) or existing[col_idx - 1] != header:
-                ws.update_cell(1, col_idx, header)
-
-
-def refresh() -> list[dict]:
-    """Pull all rows from the sheet into the in-memory cache.
-
-    Returns the cache (list of dicts keyed by header names).
-    """
-    global _cache
-    ws = _get_worksheet()
-    _ensure_headers(ws)
-    # head=1: row 1 is the header; row 2 is a formula/stats row - skip it
-    records = ws.get_all_records(head=1)
-    _cache = records[1:]  # drop the formula row (row 2) from the cache
-    return _cache
-
-
-def get_cache() -> list[dict]:
-    """Return the current in-memory cache without re-querying."""
-    return _cache
-
-
-def find_member_by_id(discord_id: int) -> dict | None:
-    """Look up a member row by Discord user ID."""
-    for row in _cache:
-        raw = row.get("User ID", "")
-        if str(raw).strip() == str(discord_id):
-            return row
-    return None
-
-
-def find_member_by_username(username: str) -> dict | None:
-    """Look up a member row by Discord username (case-insensitive)."""
-    for row in _cache:
-        if str(row.get("Discord", "")).strip().lower() == username.lower():
-            return row
-    return None
-
-
-def find_member(discord_id: int, username: str) -> dict | None:
-    """Try ID first, fall back to username."""
-    return find_member_by_id(discord_id) or find_member_by_username(username)
-
-
-# ---- Write helpers --------------------------------------------------------
-
-def _row_index_for_member(discord_id: int | None = None, username: str | None = None) -> int | None:
-    """Return the 1-based sheet row index for a member (header = row 2, data from row 3)."""
-    for idx, row in enumerate(_cache):
-        if discord_id and str(row.get("User ID", "")).strip() == str(discord_id):
-            return idx + 3  # +3 because header is row 2, data starts row 3, idx is 0-based
-        if username and str(row.get("Discord", "")).strip().lower() == username.lower():
-            return idx + 3
-    return None
-
-
-def update_cell_for_member(
-    discord_id: int | None,
-    username: str | None,
-    column_name: str,
-    value: str,
-) -> bool:
-    """Write a value to a specific column for a member row.
-
-    Returns True if the write succeeded.
-    """
-    ws = _worksheet or _get_worksheet()
-    row_idx = _row_index_for_member(discord_id=discord_id, username=username)
-    if row_idx is None:
-        return False
-
-    try:
-        col_idx = EXPECTED_HEADERS.index(column_name) + 1
-    except ValueError:
-        return False
-
-    ws.update([[value]], gspread.utils.rowcol_to_a1(row_idx, col_idx),
-               value_input_option="USER_ENTERED")
-
-    # Keep cache in sync
-    cache_idx = row_idx - 3
-    if 0 <= cache_idx < len(_cache):
-        _cache[cache_idx][column_name] = value
-
-    return True
-
-
-def batch_set_synced(updates: list[tuple[int, bool]]) -> None:
-    """Batch-write 'Discordis synced?' for multiple members in a single API call."""
-    ws = _worksheet or _get_worksheet()
-    col_idx = EXPECTED_HEADERS.index("Discordis synced?") + 1
-    cells = []
-    for discord_id, synced in updates:
-        row_idx = _row_index_for_member(discord_id=discord_id)
-        if row_idx is None:
-            continue
-        cells.append(gspread.Cell(row_idx, col_idx, "TRUE" if synced else "FALSE"))
-        cache_idx = row_idx - 3
-        if 0 <= cache_idx < len(_cache):
-            _cache[cache_idx]["Discordis synced?"] = "TRUE" if synced else "FALSE"
-    if cells:
-        ws.update_cells(cells, value_input_option="USER_ENTERED")
-
-
-def set_user_id(username: str, discord_id: int) -> bool:
-    """Write a Discord user ID for a row matched by Discord username."""
-    return update_cell_for_member(
-        discord_id=None,
-        username=username,
-        column_name="User ID",
-        value=str(discord_id),
-    )
-
-
-def set_synced(discord_id: int, synced: bool) -> bool:
-    """Mark a member as synced (TRUE) or not (FALSE)."""
-    return update_cell_for_member(
-        discord_id=discord_id,
-        username=None,
-        column_name="Discordis synced?",
-        value="TRUE" if synced else "FALSE",
-    )
-
-
-def update_username(discord_id: int, new_username: str) -> bool:
-    """Update the Discord column for a member (keeps sheet in sync with Discord)."""
-    return update_cell_for_member(
-        discord_id=discord_id,
-        username=None,
-        column_name="Discord",
-        value=new_username,
-    )
-
-
-def add_new_member_row(username: str, discord_id: int) -> None:
-    """Append a new row to the sheet with Discord username and User ID pre-filled.
-
-    All other columns are left empty for manual entry by an admin.
-    """
-    ws = _worksheet or _get_worksheet()
-    row = [""] * len(EXPECTED_HEADERS)
-    row[EXPECTED_HEADERS.index("Discord")] = username
-    row[EXPECTED_HEADERS.index("User ID")] = str(discord_id)
-    row[EXPECTED_HEADERS.index("Discordis synced?")] = "FALSE"
-    ws.append_row(row, value_input_option="USER_ENTERED")
-    # Add to local cache so subsequent find_member() calls work in the same session
-    new_entry = {h: row[i] for i, h in enumerate(EXPECTED_HEADERS)}
-    _cache.append(new_entry)

strings/__init__.py

@@ -0,0 +1,192 @@
+"""All user-facing text for TipiLAN Bot.
+
+Strings live in domain submodules (common, commands, member, economy, admin,
+games, fishing) and are re-exported here, so ``import strings`` and
+``strings.NAME`` keep working unchanged. Edit the relevant submodule to change
+any message, description, or flavour text without touching any logic code."""
+
+from .common import (
+    MSG_BANNED,
+    MSG_SPAM_JAIL,
+    MSG_PONG,
+    MSG_RESTART_DONE,
+    MSG_RESTARTING,
+    MSG_SHUTTING_DOWN,
+    MSG_PAUSED,
+    MSG_UNPAUSED,
+    MSG_MAINTENANCE,
+    MSG_SYNC_DONE,
+    MSG_REMINDER,
+    MSG_LEVELUP,
+    MSG_LEVELUP_ROLE,
+    REMINDER_OPTS,
+    TITLE,
+    ERR,
+    CD_MSG,
+    REMINDERS_UI,
+    SEND_UI,
+    PATCHNOTES_UI,
+    STATUS_UI,
+)
+
+from .commands import (
+    CMD,
+    OPT,
+    HELP_CATEGORIES,
+    HELP_UI,
+)
+
+from .member import (
+    MEMBER_UI,
+    MEMBER_FIELDS,
+    ECONOMYSETUP_UI,
+    CHANNEL_UI,
+    BIRTHDAY_UI,
+    BIRTHDAY_MONTHS,
+    CHECK_UI,
+    TEAMSYNC_UI,
+)
+
+from .economy import (
+    WORK_JOBS,
+    BEG_LINES,
+    BEG_JAIL_LINES,
+    CRIME_WIN,
+    CRIME_LOSE,
+    QUEST_UI,
+    QUEST_DESCRIPTIONS,
+    SHOP_UI,
+    ITEM_DESCRIPTIONS,
+    CONSUMABLES_UI,
+    CONSUMABLE_DESCRIPTIONS,
+    JAILED_UI,
+    SHOP_BTN,
+    DAILY_UI,
+    STATS_UI,
+    PROFILE_UI,
+    BALANCE_UI,
+    COOLDOWNS_UI,
+    RANK_UI,
+    WORK_UI,
+    BEG_UI,
+    CRIME_UI,
+    ROB_UI,
+    GIVE_UI,
+    BUY_UI,
+    LEADERBOARD_UI,
+    REQUEST_UI,
+)
+
+from .admin import (
+    ADMINVIEW_UI,
+    ADMIN,
+    SEASON,
+    PRESTIGE_SHOP_NAMES,
+    PRESTIGE_SHOP_DESCRIPTIONS,
+    PRESTIGE_UI,
+)
+
+from .games import (
+    SLOTS_TIERS,
+    ROULETTE,
+    HEIST_STORY,
+    HEIST_UI,
+    BJ,
+    JAILBREAK_UI,
+    SLOTS_UI,
+    RPS_UI,
+    RPS_CHOICES,
+    BJ_UI,
+)
+
+from .fishing import (
+    FISH_NAMES,
+    FISH_RARITY_NAMES,
+    FISH_RARITY_EMOJI,
+    FISH_JUNK_LINES,
+    FISH_UI,
+)
+
+__all__ = [
+    'MSG_BANNED',
+    'MSG_SPAM_JAIL',
+    'MSG_PONG',
+    'MSG_RESTART_DONE',
+    'MSG_RESTARTING',
+    'MSG_SHUTTING_DOWN',
+    'MSG_PAUSED',
+    'MSG_UNPAUSED',
+    'MSG_MAINTENANCE',
+    'MSG_SYNC_DONE',
+    'MSG_REMINDER',
+    'MSG_LEVELUP',
+    'MSG_LEVELUP_ROLE',
+    'REMINDER_OPTS',
+    'TITLE',
+    'ERR',
+    'CD_MSG',
+    'REMINDERS_UI',
+    'SEND_UI',
+    'PATCHNOTES_UI',
+    'STATUS_UI',
+    'CMD',
+    'OPT',
+    'HELP_CATEGORIES',
+    'HELP_UI',
+    'MEMBER_UI',
+    'MEMBER_FIELDS',
+    'ECONOMYSETUP_UI',
+    'CHANNEL_UI',
+    'BIRTHDAY_UI',
+    'BIRTHDAY_MONTHS',
+    'CHECK_UI',
+    'TEAMSYNC_UI',
+    'WORK_JOBS',
+    'BEG_LINES',
+    'BEG_JAIL_LINES',
+    'CRIME_WIN',
+    'CRIME_LOSE',
+    'QUEST_UI',
+    'QUEST_DESCRIPTIONS',
+    'SHOP_UI',
+    'ITEM_DESCRIPTIONS',
+    'CONSUMABLES_UI',
+    'CONSUMABLE_DESCRIPTIONS',
+    'JAILED_UI',
+    'SHOP_BTN',
+    'DAILY_UI',
+    'STATS_UI',
+    'PROFILE_UI',
+    'BALANCE_UI',
+    'COOLDOWNS_UI',
+    'RANK_UI',
+    'WORK_UI',
+    'BEG_UI',
+    'CRIME_UI',
+    'ROB_UI',
+    'GIVE_UI',
+    'BUY_UI',
+    'LEADERBOARD_UI',
+    'REQUEST_UI',
+    'ADMINVIEW_UI',
+    'ADMIN',
+    'SEASON',
+    'PRESTIGE_SHOP_NAMES',
+    'PRESTIGE_SHOP_DESCRIPTIONS',
+    'PRESTIGE_UI',
+    'SLOTS_TIERS',
+    'ROULETTE',
+    'HEIST_STORY',
+    'HEIST_UI',
+    'BJ',
+    'JAILBREAK_UI',
+    'SLOTS_UI',
+    'RPS_UI',
+    'RPS_CHOICES',
+    'BJ_UI',
+    'FISH_NAMES',
+    'FISH_RARITY_NAMES',
+    'FISH_RARITY_EMOJI',
+    'FISH_JUNK_LINES',
+    'FISH_UI',
+]

strings/admin.py

@@ -0,0 +1,125 @@
+"""Economy admin responses, season reset, and prestige system.
+
+Auto-split from the original strings.py; edit strings here.
+"""
+
+from core.emoji import EMOJI as E
+
+__all__ = [
+    'ADMINVIEW_UI',
+    'ADMIN',
+    'SEASON',
+    'PRESTIGE_SHOP_NAMES',
+    'PRESTIGE_SHOP_DESCRIPTIONS',
+    'PRESTIGE_UI',
+]
+
+ADMINVIEW_UI: dict[str, str] = {
+    "title":           "🔍 {name} - majandusandmed",
+    "banned_yes":      "🚫 JAH",
+    "banned_no":       "✅ Ei",
+    "f_balance":       "💰 Saldo",
+    "f_exp":           "📊 EXP / Tase",
+    "f_streak":        "🔥 Streak",
+    "f_banned":        "🚫 Keelatud",
+    "f_jailed":        "🚔 Vangis kuni",
+    "f_prestige":      "🔥 Prestiiž",
+    "f_items":         "🎒 Esemed",
+    "f_uses":          "🔢 Kasutused",
+    "f_fish":          "🎣 Kala",
+    "f_last_daily":    "⏱️ Viimati daily",
+    "f_last_work":     "⏱️ Viimati work",
+    "f_last_crime":    "⏱️ Viimati crime",
+    "f_last_fish":     "⏱️ Viimati fish",
+    "footer":          "ID: {uid}",
+    "exp_val":         "{exp} EXP (Tase {level})",
+    "prestige_val":    "Prestiiž {level} · {pp} PP",
+    "fish_val":        "{caught} püütud · {inv} inventaris",
+}
+
+# ---------------------------------------------------------------------------
+# Admin command responses and DMs
+# ---------------------------------------------------------------------------
+
+ADMIN: dict[str, str] = {
+    "coins_done":  "{emoji} **{name}**: {verb} {coin} → saldo **{balance}**\n📝 Põhjus: {reason}",
+    "coins_dm":    "{emoji} Admin muutis sinu TipiCOINide saldot: **{verb} {coin}**\n📝 Põhjus: *{reason}*\nUus saldo: **{balance} {coin}**",
+    "jail_done":   "🚔 **{name}** on vangistatud {minutes} minutiks (vabaneb {ts}).\n📝 Põhjus: {reason}",
+    "jail_dm":     "🚔 Admin saatis sind vanglasse **{minutes} minutiks**.\n📝 Põhjus: *{reason}*\nVabaneb {ts}.",
+    "unjail_done": "✅ **{name}** on vanglast vabastatud.",
+    "unjail_dm":   "✅ Admin vabastas sind vanglast.",
+    "ban_done":    "🚫 **{name}** keelati majandussüsteemis osaleda.\n📝 Põhjus: {reason}",
+    "ban_dm":      "🚫 Sul keelati TipiBOTi majandussüsteemis osalemine.\n📝 Põhjus: *{reason}*",
+    "unban_done":  "✅ **{name}** on majandussüsteemi osalemise keelust eemaldatud.",
+    "unban_dm":    "✅ Sinu TipiBOTi majandussüsteemis osalemise keeld on tühistatud. Saad taas käske kasutada.",
+    "reset_done":  "🗑️ **{name}** majandusandmed on lähtestatud.\n📝 Põhjus: {reason}",
+    "reset_dm":    "🗑️ Admin lähtestas sinu TipiBOTi majandusandmed (saldo, esemed, streak).\n📝 Põhjus: *{reason}*",
+    "exp_done":    "{emoji} **{name}**: {verb} EXP → kokku **{exp} EXP** (Tase {level}).\n📝 Põhjus: {reason}",
+    "exp_dm":      "{emoji} Admin muutis sinu EXP-i: **{verb} EXP**\n📝 Põhjus: *{reason}*\nUus EXP: **{exp}** (Tase {level})",
+    "item_given":  "✅ **{item}** antud kasutajale **{name}** (tasuta).",
+    "item_removed":"🗑️ **{item}** eemaldatud kasutajalt **{name}**.",
+    "item_invalid":"❌ Tundmatu ese: `{item_id}`. Kontrolli `/shop` eseme ID-d.",
+    "item_not_owned": "❌ **{name}** ei oma eset `{item_id}`.",
+    "item_dm_given":  "✅ Admin andis sulle eseme: **{item}**.",
+    "item_dm_removed":"🗑️ Admin eemaldas sult eseme: **{item}**.",
+}
+
+# ---------------------------------------------------------------------------
+# /adminseason  strings
+# ---------------------------------------------------------------------------
+
+SEASON: dict[str, str] = {
+    "top_header": "**Top mängijad EXP järgi:**",
+    "no_players": "Keegi ei teeninud EXP-i.",
+    "entry":      "{prefix} {name} - {exp} EXP  *(Tase {level})*",
+    "footer":     "Kõigi EXP, mündid ja esemed lähtestati. Uus hooaeg algab kohe!",
+    "done":       "✅ Hooaeg lõpetatud - EXP, mündid ja esemed lähtestatud.",
+}
+
+# ---------------------------------------------------------------------------
+# Prestige system strings
+# ---------------------------------------------------------------------------
+
+PRESTIGE_SHOP_NAMES: dict[str, str] = {
+    "coin_mult":  "Mündiboost",
+    "exp_mult":   "EXP-boost",
+    "daily_plus": "Päevabonus+",
+    "work_plus":  "Töötaja+",
+}
+PRESTIGE_SHOP_DESCRIPTIONS: dict[str, str] = {
+    "coin_mult":  "Kõik TipiCOINide teenimisallikad (daily, töö, kerja, kala) teenivad +8% rohkem iga taseme kohta. Max 5 taset → +40%.",
+    "exp_mult":   "Kõik EXP allikad teenivad +8% rohkem iga taseme kohta. Max 5 taset → +40%.",
+    "daily_plus": "Päevase boonuse alussumma tõuseb +20% iga taseme kohta. Max 3 taset → +60%.",
+    "work_plus":  "/work teenib +20% rohkem iga taseme kohta. Max 3 taset → +60%.",
+}
+PRESTIGE_UI: dict[str, str] = {
+    "confirm_desc": (
+        "Oled tasemel **{level}** ({exp} EXP).\n\n"
+        "Prestiiži korral saad **{pp}** " + E["TipiFIRE"] + " ja kõik lähtestub:\n"
+        "• Saldo, EXP, esemed, ooteajad\n\n"
+        "**Kalakogu jääb alles!**\n\nKas oled kindel?"
+    ),
+    "btn_confirm":    "🔥 Jah, prestiiži!",
+    "btn_cancel":     "❌ Tühista",
+    "btn_tab_status": "⭐ Prestiiz",
+    "btn_tab_shop":   "🛍️ Uuendused",
+    "success_desc": (
+        "Said **{pp}** " + E["TipiFIRE"] + "\n"
+        "Prestiiži tase: **{level}**\n"
+        "Kogutud PP: **{total_pp}** " + E["TipiFIRE"] + "\n\n"
+        "*Kõik lähtestati. Alusta otsast!*"
+    ),
+    "too_low_desc":    "Prestiiži jaoks vajad taset **{required}** (sul on tase {level}).",
+    "shop_desc":       "Sul on **{pp}** " + E["TipiFIRE"] + "  ·  Vajuta nuppu uuenduse ostmiseks",
+    "shop_maxed":      "✅ Max",
+    "shop_level_fmt":  "Tase {cur}/{max}",
+    "shop_cost_fmt":   "{cost} " + E["TipiFIRE"],
+    "buy_success_desc":"**{name}** uuendatud tasemele **{new_level}/{max_level}**!\nPP alles: **{pp}** " + E["TipiFIRE"],
+    "buy_no_pp":       E["TipICRY"] + " Sul pole piisavalt PP. Sul on **{have}**, vajad **{need}** " + E["TipiFIRE"] + ".",
+    "buy_maxed":       "❌ See uuendus on juba maksimumtasemel.",
+    "buy_not_found":   "❌ Sellist uuendust ei leitud. Vaata `/prestigeshop`.",
+    "rank_line":       E["TipiFIRE"] + " Prestiiž **{level}**  ·  {pp} PP",
+    "rank_season":     "🏆 Hooaja EXP: **{exp}**",
+    "btn_buy_upgrade": "{emoji} {name} +1  ({cost} PP)",
+    "status_footer":   "⭐ Prestiiž {level}  ·  {pp} PP",
+}

strings/commands.py

@@ -0,0 +1,226 @@
+"""Slash-command and /help metadata (descriptions, options, categories).
+
+Auto-split from the original strings.py; edit strings here.
+"""
+
+from core.emoji import EMOJI as E
+
+__all__ = [
+    'CMD',
+    'OPT',
+    'HELP_CATEGORIES',
+    'HELP_UI',
+]
+
+# ---------------------------------------------------------------------------
+# Slash command descriptions  (shown in Discord's autocomplete)
+# ---------------------------------------------------------------------------
+
+CMD: dict[str, str] = {
+    "ping":        "Vaata, kas bot on üleval",
+    "help":        "Nimekiri kõikidest käskudest kategooriate kaupa",
+    "status":      "Näita boti staatust ja ressursside kasutust",
+    "birthdays":   "Näita kõigi liikmete sünnipäevi kuu järgi",
+    "check":       "Laadi andmed, täida ID'd ja sünkroniseeri kõik liikmed",
+    "sync":        "Sünkroniseeri käsklused Discordi serveriga",
+    "member":      "Näita liikme andmeid tabelist",
+    "teamsync":    "[Admin] Sünkroniseeri tiimirollid registreerimistabelist",
+    "restart":     "Tee taaskäivitus botile",
+    "shutdown":    "Lülita bot välja (ilma taaskäivituseta)",
+    "pause":       "Peata / jätka kõik käsklused (hooldusrežiim)",
+    "send":        "Saada sõnum valitud kanalisse",
+    "profile":     "Vaata oma profiili: saldo, tase, esemed, statistika ja kalakogu",
+    "balance":     "Vaata enda (või kellegi teise) TipiCOINide saldot",
+    "daily":       "Võta enda päevane TipiCOINi boonus",
+    "work":        "Tööta ja teeni TipiCOINe (1h ooteaeg)",
+    "beg":         "Kerja TipiCOINe (5min ooteaeg)",
+    "crime":       "Proovi oma õnne kriminaalse tegevusega (2h ooteaeg)",
+    "rob":         "Proovi kelleltki TipiCOINe varastada",
+    "heist":       "Alusta grupirööv pangahoidlasse (min 2 mängijat, max 8, 4h serveri ooteaeg)",
+    "roulette":    "Panusta TipiCOINe punasele, mustale või rohelisele (1/37 võimalus, 14x payout)",
+    "give":        "Anna TipiCOINe teisele mängijale",
+    "leaderboard": "TipiBOTi edetabel - kes on kõige rikkam?",
+    "shop":        "Sirvi TipiBOTi poodi",
+    "buy":         "Osta ese TipiBOTi poodist",
+    "rps":         "Kivi-paber-käärid mõne teise mängija vastu",
+    "slots":       "Proovi oma õnne TipiBOTi mänguautomaadiga",
+    "request":     "Kerja TipiCOINe teistelt mängijatelt - nagu crowdfunding, aga halvem",
+    "reminders":   "Halda DM meeldetuletusi - kõik on vaikimisi sees, lülita need siin välja",
+    "cooldowns":   "Vaata kõikide käskude ooteaegu",
+    "jailed":      "Vaata, kes on praegu vanglas",
+    "rank":        "Vaata oma EXP, taset ja edetabeli positsiooni",
+    "stats":       "Vaata oma mängustatistikat",
+    "jailbreak":   "Proovi vanglast põgeneda kasutades täringuid",
+    "adminseason": "[Admin] Lõpeta võistlus, teavita võitjaid ja lähtesta EXP",
+    "admincoins":  "[Admin] Anna või võta TipiCOINe kasutajale/kasutajalt",
+    "adminjail":   "[Admin] Saada kasutaja vangi",
+    "adminunjail": "[Admin] Vabasta kasutaja vangist",
+    "adminban":    "[Admin] Keela kasutajal majandussüsteemis osaleda",
+    "adminunban":  "[Admin] Eemalda majandussüsteemi keeld kasutajalt",
+    "adminreset":  "[Admin] Lähtesta kasutaja majandusandmed",
+    "adminview":     "[Admin] Vaata kasutaja majandusandmeid",
+    "adminexp":      "[Admin] Anna v\u00f5i v\u00f5ta EXP kasutajalt",
+    "adminitem":     "[Admin] Anna v\u00f5i eemalda ese kasutajalt (tasuta)",
+    "allowchannel":  "[Admin] Lisa kanal, kus bot võib vastata käsklustele",
+    "denychannel":   "[Admin] Eemalda kanal lubatud kanalite nimekirjast",
+    "channels":      "[Admin] Näita lubatud kanalite nimekirja",
+    "economysetup":  "[Admin] Loo ja sea korda majandussüsteemi rollid",
+    "blackjack":      "Mängi blackjacki TipiBOTi vastu",
+    "prestige":       "Prestiiži (nõuab taset 30) ja teeni Prestiižipunkte",
+    "prestigeshop":   "Vaata prestiižipoodi ja sinu uuenduste taset",
+    "prestigebuy":    "Osta prestiižiuuendus Prestiižipunktide eest",
+    "fish":           "Mine kalastama (interaktiivne mäng, 2min ooteaeg)",
+    "fishbook":       "Vaata oma kalakogu ja kogutud kalaliike",
+    "fishsell":       "Müü kalu oma inventarist",
+    "patchnotes":     "Vaata TipiBOTi viimaseid muudatusi ja uuendusi",
+    "quests":         "Vaata oma päeva- ja nädalaülesandeid ning nõua auhinnad",
+    "consumables":    "Sirvi ja osta turgutusi (korduvostetavad boostid)",
+}
+
+# ---------------------------------------------------------------------------
+# Option descriptions  (shown next to each parameter in Discord)
+# ---------------------------------------------------------------------------
+
+OPT: dict[str, str] = {
+    "admin_kasutaja":     "Kasutaja",
+    "admin_põhjus":       "Põhjus (saadetakse kasutajale DM kaudu)",
+    "admincoins_kogus":   "Positiivne = anna, negatiivne = võta",
+    "adminjail_minutid":  "Vangistamise kestus minutites",
+    "balance_kasutaja":   "Mängija, kelle saldot vaadata (vaikimisi sina)",
+    "roulette_panus":     "Panus TipiCOINides ('all' = kogu saldo)",
+    "roulette_värv":      "Punane, must või roheline",
+    "give_kasutaja":      "Kellele annad?",
+    "give_summa":         "Kui palju annad? ('all' = kogu saldo)",
+    "buy_ese":            "Eseme nimi (vaata /shop)",
+    "consumable_ese":     "Turgutus, mida osta (tühjaks jättes näeb menüüd)",
+    "rps_panus":          "Valikuline TipiCOINide panus ('all' = kogu saldo)",
+    "rps_vastane":        "Väljakutse teisele mängijale (PvP)",
+    "slots_panus":        "Panus TipiCOINides ('all' = kogu saldo)",
+    "request_summa":      "Kui palju TipiCOINe vajad?",
+    "request_põhjus":     "Miks sa vajad TipiCOINe?",
+    "request_sihtmärk":   "Valikuline: kellelt täpselt palud (teised ei saa toetada)",
+    "send_kanal":           "Kanal, kuhu sõnum saata",
+    "send_sõnum":           "Sõnum, mida saata",
+    "allowchannel_kanal":  "Kanal, kus bot võib vastata käsklustele",
+    "denychannel_kanal":   "Kanal, kus bot ei või vastata käsklustele",
+    "rob_sihtmärk":       "Kellelt röövid?",
+    "member_user":        "Mängija, kelle infot tahad vaadata",
+    "rank_kasutaja":      "Mängija, kelle taset tahad vaadata (vaikimisi sina)",
+    "stats_kasutaja":     "Mängija, kelle statistikat tahad vaadata (vaikimisi sina)",
+    "adminseason_top_n":  "Kui palju mängijaid võitis (vaikimisi 10)",
+    "blackjack_panus":   "Panus TipiCOINides ('all' = kogu saldo)",
+    "prestigebuy_upgrade": "Uuenduse ID (vaata /prestigeshop)",
+    "fishbook_kasutaja":   "Mängija, kelle kalakogu vaadata (vaikimisi sina)",
+    "profile_kasutaja":    "Mängija, kelle profiili vaadata (vaikimisi sina)",
+    "adminexp_kogus":      "Positiivne = anna, negatiivne = võta",
+    "adminitem_ese":       "Eseme ID (kasutatav sisse, vaata /shop)",
+    "adminitem_tegevus":   "'anna' või 'eemalda'",
+}
+
+# ---------------------------------------------------------------------------
+# /help categories
+# ---------------------------------------------------------------------------
+
+HELP_CATEGORIES: dict[str, dict] = {
+    "üldine": {
+        "label": "🤖 Üldine",
+        "description": "Üldised käsklused",
+        "color": 0x57F287,
+        "fields": [
+            ("/ping", "Vaata, kas bot on üleval"),
+            ("/status", "Näita boti staatust ja ressursside kasutust"),
+            ("/help", "Nimekiri kõikidest käskudest kategooriate kaupa"),
+            ("/birthdays", "Näita kõigi liikmete sünnipäevi kuu järgi"),
+        ],
+    },
+    "tipibot": {
+        "label": "🪙 TipiBOT",
+        "description": "TipiCOIN majandus",
+        "color": 0xF4C430,
+        "fields": [
+            ("/profile [@user]", "Saldo, tase, EXP progress, prestiiz - kõik ühes kohas. Nupud: Esemed · Statistika · Kalakogu."),
+            ("/cooldowns", "Vaata kõikide käskude ooteaegu. Näitab ka vangla ooteaega."),
+            ("/daily", "Võta enda päevane TipiCOINide boonus. 20h ooteaeg. Streak'i boonus: 3d=+50%, 7d=+100%, 14d=+200%."),
+            ("/work", "Tööta ja teeni TipiCOINe (1h ooteaeg)"),
+            ("/beg", "Kerja TipiCOINe (5min ooteaeg)"),
+            ("/crime", "Proovi oma õnne kriminaalse tegevusega. 60% edu, 40% trahv + 30min vanglas. 2h ooteaeg."),
+            ("/rob @user", "Proovi kelleltki TipiCOINe varastada. 45% edu. Ebaõnnestumisel saad trahvi."),
+            ("/heist", "Alusta grupiröövi pangahoidlasse. Min 2 mängijat, max 8. 5 min ühinemisaeg. Õnnestumisel jagatakse saak võrdselt - ebaõnnestumisel 1h 30min vangis + trahv. 4h serveri ooteaeg (ei ole isiklik)."),
+            ("/jailbreak", "Proovi vanglas olles täringuid visata, et duublit saada (3 katset). Duubli korral saad vabaks. Ebaõnnestumisel saad valida: maksa kautsjon (20-30% saldost, min 350 ⬡) või jää vanglasse kuni aja lõpuni."),
+            ("/give @user <amount>", "Anna TipiCOINe teisele mängijale"),
+            ("/quests", "Vaata oma päeva- ja nädalaülesandeid ning nõua auhinnad (uueneb iga päev/nädal)."),
+            ("/leaderboard", "TipiBOTi edetabel - kes on kõige rikkam?"),
+            ("/shop", "Sirvi TipiBOTi poodi"),
+            ("/buy <item>", "Osta ese TipiBOTi poodist"),
+            ("/request <amount> <reason> [target]", "Saada crowdfundingu taotlus. Keegi saab 'Toeta' nuppu vajutades raha kanda (taotlus kehtib 5 minutit)."),
+            ("/reminders", "DM meeldetuletused on vaikimisi sees. Kasuta seda käsku, et lülitada sisse/välja, milliseid käsklusi meelde tuletada."),
+        ],
+    },
+    "shop": {
+        "label": "🛍️ Pood",
+        "description": "TipiBOTi poe esemed ja nende efektid",
+        "color": 0xF4C430,
+        "fields": [
+            (f"{E['TipiHIIR']} Mängurihiir - 500 ⬡", "Teeni töötades 50% rohkem TipiCOINe."),
+            (f"{E['TipiMATT']} XL hiirematt - 600 ⬡", "Kerjamise ooteaeg 5min → 3min."),
+            (f"{E['TipiKLAPID']} Kõrvaklapid - 1200 ⬡", "Päevase boonuse ooteaeg 20h → 18h."),
+            (f"{E['TipiPILET']} LAN pilet (2025) - 1200 ⬡", "Päevane boonus on duubeldatud."),
+            (f"{E['TipiVAC']} Anticheat - 750 ⬡", "Röövimine sinu vastu ebaõnnestub. Pärast 2 kasutust pead ostma uue."),
+            (f"{E['TipiBULL']} Red Bull - 800 ⬡", "30% tõenäosus, et teenid töötades 3x rohkem."),
+            (f"{E['TipiLAP']} Botikoobas - 1500 ⬡", "RTX 5090 jooksutab botte 24/7. Päevane boonus genereerib 5% intressi sinu saldo pealt."),
+            (f"{E['TipiLAUD']} Reguleeritav laud - 3500 ⬡ *(T2)*", "/work teenib 25% rohkem (stackib mängurihiirega)."),
+            (f"{E['TipiSERVER']} Jellyfin server - 4000 ⬡ *(T2)*", "Röövimise edu tõenäosus 45% → 60%."),
+            (f"{E['TipiMIC']} Mikrofon - 2800 ⬡ *(T2)*", "Teeni 30% rohkem eduka /crime puhul."),
+            (f"{E['TipiKLAVA']} Mehhaaniline klaviatuur - 1800 ⬡ *(T2)*", "/beg teenib 2x rohkem."),
+            (f"{E['TipiMONITOR']} Ultralai monitor - 2500 ⬡ *(T2)*", "/work ooteaeg: 1h → 40min."),
+            (f"{E['TipiCAT']} CAT6 netikaabel - 3500 ⬡ *(T2)*", "/crime edu tõenäosus tõuseb 60% → 75%."),
+            (f"{E['TipiMONITOR2']} 360hz monitor - 7500 ⬡ *(T3)*", "Mänguautomaadi jackpot 10x → 15x, kolmik 4x → 6x."),
+            (f"{E['TipiKARIKAS']} TipiLANi trofee - 6000 ⬡ *(T3)*", "Streak ei nulli, kui sa mõne päeva vahele jätad."),
+            (f"{E['TipiTOOL']} Mänguritool - 9000 ⬡ *(T3)*", "/crime ebaõnnestumine ei saada sind vanglasse."),
+        ],
+    },
+    "games": {
+        "label": "🎮 Mängud",
+        "description": "Lõbusad mängud",
+        "color": 0x5865F2,
+        "fields": [
+            ("/roulette <bet> <colour>", "Panusta TipiCOINe punasele, mustale või rohelisele (1/37 võimalus, 14x payout)"),
+            ("/rps [bet] [opponent]", "Kivi-paber-käärid mõne teise mängija vastu"),
+            ("/slots <bet>", "Proovi oma õnne TipiBOTi mänguautomaadiga"),
+            ("/blackjack <bet>", "Mängi blackjacki TipiBOTi vastu. Blackjack maksab 3:2. Kakskordistamine (double down) on võimalik vaid esimese käigu ajal."),
+        ],
+    },
+    "admin": {
+        "label": "🔧 Admin",
+        "description": "Admin käsklused (peidetud tavaliste kasutajate eest)",
+        "color": 0xED4245,
+        "fields": [
+            ("/check", "Laadi andmed, täida ID'd ja sünkroniseeri kõik liikmed"),
+            ("/member @user", "Näita liikme andmeid tabelist"),
+            ("/sync", "Sünkroniseeri käsklused Discordi serveriga"),
+            ("/restart", "Tee taaskäivitus botile"),
+            ("/send #channel message", "Saada sõnum valitud kanalisse"),
+            ("/admincoins @user <amount> <reason>", "Anna või võta TipiCOINe kasutajale/kasutajalt"),
+            ("/adminjail @user <minutes> <reason>", "Saada kasutaja vangi"),
+            ("/adminunjail @user", "Vabasta kasutaja vangist"),
+            ("/adminban @user <reason>", "Keela kasutajal majandussüsteemis osaleda"),
+            ("/adminunban @user", "Eemalda majandussüsteemi keeld kasutajalt"),
+            ("/adminreset @user <reason>", "Lähtesta kasutaja majandusandmed"),
+            ("/adminview @user", "Vaata kasutaja majandusandmeid"),
+            ("/allowchannel #channel", "Lisa kanal, kus bot võib vastata käsklustele"),
+            ("/denychannel #channel", "Eemalda kanal lubatud kanalite nimekirjast"),
+            ("/channels", "Näita lubatud kanalite nimekirja"),
+            ("/adminseason [top_n]", "Lõpeta võistlus, teavita võitjaid ja lähtesta EXP"),
+            ("/economysetup", "Loo ja sea korda majandussüsteemi rollid (ECONOMY + taseme rollid) boti rolli alla"),
+        ],
+    },
+}
+
+# ---------------------------------------------------------------------------
+# /help  UI
+# ---------------------------------------------------------------------------
+
+HELP_UI: dict[str, str] = {
+    "footer":              "TipiBOT • Vali kategooria allmenüüst",
+    "select_placeholder":  "Vali kategooria...",
+}

strings/common.py

@@ -0,0 +1,247 @@
+"""Shared / system-wide strings (messages, titles, errors, cooldowns).
+
+Auto-split from the original strings.py; edit strings here.
+"""
+
+from core.emoji import EMOJI as E
+
+__all__ = [
+    'MSG_BANNED',
+    'MSG_SPAM_JAIL',
+    'MSG_PONG',
+    'MSG_RESTART_DONE',
+    'MSG_RESTARTING',
+    'MSG_SHUTTING_DOWN',
+    'MSG_PAUSED',
+    'MSG_UNPAUSED',
+    'MSG_MAINTENANCE',
+    'MSG_SYNC_DONE',
+    'MSG_REMINDER',
+    'MSG_LEVELUP',
+    'MSG_LEVELUP_ROLE',
+    'REMINDER_OPTS',
+    'TITLE',
+    'ERR',
+    'CD_MSG',
+    'REMINDERS_UI',
+    'SEND_UI',
+    'PATCHNOTES_UI',
+    'STATUS_UI',
+]
+
+# ---------------------------------------------------------------------------
+# Repeated system messages
+# ---------------------------------------------------------------------------
+
+MSG_BANNED       = "🚫 Sul keelati TipiBOTi majandussüsteemis osaleda."
+MSG_SPAM_JAIL    = "⚠️ Liiga kiire! Automaatsed skriptid/spam on keelatud. Oled **30 minutit vangis**. Kasuta `/jailbreak`, et varem välja pääseda."
+MSG_PONG         = "🏓 Pong!"
+MSG_RESTART_DONE = "✅ Bot on taaskäivitatud!"
+MSG_RESTARTING   = "🔄 Taaskäivitan..."
+MSG_SHUTTING_DOWN = "⛔ Lülitan boti välja..."
+MSG_PAUSED       = "⏸️ Bot on hooldusrežiimis - kõik käsklused on peatatud."
+MSG_UNPAUSED     = "▶️ Hooldusrežiim lõpetatud - käsklused on taas saadaval."
+MSG_MAINTENANCE  = "🔧 Bot on hetkel hoolduses. Proovi mõne hetke pärast uuesti."
+MSG_SYNC_DONE    = "✅ Käsud sünkroniseeritud!"
+MSG_REMINDER     = "⏰ **/{cmd}** on taas kasutamiseks valmis!\n-# Meeldetuletuste haldamiseks kasuta serveris `/reminders`."
+MSG_LEVELUP      = "⬆️ **{name}** jõudis **{level}. tasemele**!{extra}"
+MSG_LEVELUP_ROLE = "  🎊 Uus tiitel: **{role}**!"
+
+# ---------------------------------------------------------------------------
+# /reminders  dropdown options  (cmd_key, label, description)
+# ---------------------------------------------------------------------------
+
+REMINDER_OPTS: list[tuple[str, str, str]] = [
+    ("daily", "📅 /daily",  "Päevane boonus (20t ooteaeg)"),
+    ("work",  "💼 /work",   "Töö (1t ooteaeg, 40min monitoriga)"),
+    ("beg",   "🙏 /beg",    "Kerjamine (5min ooteaeg)"),
+    ("crime", "🦹 /crime",  "Kuritegu (2t ooteaeg)"),
+    ("rob",   "🔫 /rob",    "Rööv (2t ooteaeg)"),
+    ("fish",  "🎣 /fish",  "Kalapüük (2min ooteaeg)"),
+]
+
+# ---------------------------------------------------------------------------
+# Embed titles
+# ---------------------------------------------------------------------------
+
+TITLE: dict[str, str] = {
+    "daily":            "📅 Päevane boonus",
+    "work":             "💼 Töö",
+    "beg":              "🙏 Kerjamine",
+    "crime_win":        f"{E['TipiFIRE']} Kuritegu õnnestus!",
+    "crime_fail":       f"{E['TipiTROLL']} Vahele jäid!",
+    "rob_win":          f"{E['TipiFIRE']} Rööv õnnestus!",
+    "rob_fail":         f"{E['TipiTROLL']} Rööv ebaõnnestus!",
+    "rob_anticheat":    f"{E['TipiVAC']} Anticheat peatas sind!",
+    "jailbreak":        "🎲 Vanglast põgenemine",
+    "jailbreak_free":   f"🎲 {E['TipiFIRE']} DUUBEL! Oled vaba!",
+    "jailbreak_fail":   f"{E['TipICRY']} Kolm katset läbi!",
+    "jailbreak_miss":   "🎲 " + E["TipICRY"] + " Ei saanud duublit ({tries}/{max})",
+    "jailbreak_bail":   "💸 Kautsjon",
+    "give":             f"{E['TipiHEART']} TipiCOINi ülekanne",
+    "stats":            "📊 Mängustatistika",
+    "leaderboard_coins":    "🪙 TipiBOTi edetabel - Mündid",
+    "leaderboard_exp":      "📊 TipiBOTi edetabel - EXP / Tase",
+    "leaderboard_season":   "🏆 TipiBOTi edetabel - Hooaja EXP",
+    "leaderboard_prestige": f"{E['TipiFIRE']} TipiBOTi edetabel - Prestiiž",
+    "leaderboard_wagered":  "🎲 TipiBOTi edetabel - Hasartmängud",
+    "leaderboard_fish":     "🎣 TipiBOTi edetabel - Kalapüük",
+    "rps":              "⚔️ Kivi, Paber, Käärid",
+    "rps_duel":         "⚔️ KPK duell",
+    "rps_duel_active":  "⚔️ KPK duell - käimas",
+    "rps_duel_done":    "⚔️ KPK duell - lõppenud",
+    "rps_duel_cancel":  "⚔️ KPK duell - tühistatud",
+    "rps_duel_expire":  "⚔️ KPK duell - aegus",
+    "rps_duel_decline": "⚔️ KPK duell - keelduti",
+    "heist_lobby":      "🔫 Grupirööv - kogunemine",
+    "heist_win":        f"{E['TipiFIRE']} Grupirööv õnnestus!",
+    "heist_fail":       f"{E['TipiSKULL']} Grupirööv ebaõnnestus!",
+    "heist_cancel":     "🔫 Grupirööv tühistatud",
+    "request":          f"{E['TipiHEART']} Rahataotlus",
+    "reminders":        "⏰ Meeldetuletused",
+    "cooldowns":        "⏱️ Sinu ooteajad",
+    "adminseason":      "🏆 Hooaeg lõppes!",
+    "economysetup":     "⚙️ Majanduse seadistamine",
+    "blackjack":        "🃏 Blackjack",
+    "blackjack_bj":     f"🃏 {E['TipiFIRE']} BLACKJACK!",
+    "blackjack_win":    f"{E['TipiFIRE']} Võitsid!",
+    "blackjack_lose":   f"{E['TipiSKULL']} Kaotasid!",
+    "blackjack_bust":   f"{E['TipiSKULL']} Üle 21 - kaotasid!",
+    "blackjack_push":   "🤝 Viik!",
+    "blackjack_dbust":  f"{E['TipiSKULL']} Üle 21 - mõlemad kaotasid!",
+    "blackjack_dwin":   f"{E['TipiFIRE']} Topeltpanus võitis!",
+    "prestige_confirm":  "🔥 Prestiiž - kinnita",
+    "prestige_success":  E["TipiFIRE"] + " Prestiiž {level} saavutatud!",
+    "prestige_too_low":  "❌ Prestiiž pole saadaval",
+    "prestige_shop":     f"{E['TipiFIRE']} Prestiižipood",
+    "prestige_buy_ok":   "✅ Uuendus ostetud!",
+    "fish_cast":         "🎣 Otsid kala...",
+    "fish_bite":         "🐟 KALA NÄKKAB!",
+    "fish_escape":       "🎣 Kala pääses!",
+    "fish_junk":         "🗑️ Ai ai ai...",
+    "fishbook":          "📖 Kalakogu",
+    "quests":            "🎯 Ülesanded",
+}
+
+# ---------------------------------------------------------------------------
+# Error / validation messages  (use .format(**kwargs) for dynamic parts)
+# ---------------------------------------------------------------------------
+
+ERR: dict[str, str] = {
+    "positive_bet":      "❌ Panus peab olema positiivne.",
+    "positive_amount":   "❌ Summa peab olema positiivne.",
+    "positive_duration": "❌ Aeg peab olema positiivne.",
+    "admincoins_zero":   "Kogus ei tohi olla 0.",
+    "missing_perms":     "❌ Sul on vaja **Rollide haldamise** õigust selle käsu kasutamiseks.",
+    "generic_error":     "❌ Tekkis viga: ```{error}```",
+    "send_failed":       "❌ Sõnumi saatmine ebaõnnestus: ```{error}```",
+    "rob_self":          "❌ Sa ei saa iseennast röövida.",
+    "rob_bot":           "❌ Botti ei saa röövida.",
+    "rob_no_house":      "❌ Kassa pole veel avatud.",
+    "rob_house_blocked": "❌ Panga seif on liiga hästi kaitstud. Kasuta `/heist` selle rüüstamiseks.",
+    "rob_too_poor":      "❌ **{name}** on liiga vaene röövimiseks.",
+    "rob_target_jailed": "❌ **{name}** on vanglas - vabad inimesed ei saa vanglas olevaid röövida.",
+    "heist_active":      "❌ Serveris on juba aktiivne grupirööv käimas! Oota, kuni see lõpeb.",
+    "heist_full":        "❌ Grupirööv on täis!",
+    "heist_min_players": "❌ Grupiröövi alustamiseks on vaja vähemalt **{min}** osalejat.",
+    "broke":             E["TipICRY"] + " Sul pole piisavalt TipiCOINe. Saldo: {bal}",
+    "broke_need":        E["TipICRY"] + " Sul pole piisavalt TipiCOINe. Vajad veel {need}.",
+    "item_owned":        "❌ Sul on see ese juba olemas.",
+    "item_not_found":    "❌ Eset ei leitud.",
+    "item_level_req":    "🔒 Selle eseme ostmiseks vajad **taset {min_level}** (sul on tase {user_level}). Teeni EXP-id kõiki käske kasutades.",
+    "not_your_game":     "❌ See pole sinu mäng!",
+    "game_in_progress":  "❌ Sul on juba mäng käimas! Lõpeta see enne.",
+    "not_your_challenge":"❌ See väljakutse pole sulle!",
+    "not_your_menu":     "❌ See ei ole sinu menüü.",
+    "give_self":         "❌ Sa ei saa iseendale TipiCOINe anda.",
+    "give_bot":          "❌ Botile ei saa TipiCOINe anda.",
+    "give_jailed":       "❌ Oled vangis - vanglas ei saa TipiCOINe anda. Pääsed välja {ts}.",
+    "rps_self":          "❌ Sa ei saa iseendale väljakutset esitada.",
+    "rps_bot":           "❌ Botid on KPK-is liiga head.",
+    "not_jailed":        "❌ Sa pole praegu vangis.",
+    "not_in_leaderboard":"❌ Sind pole veel edetabelis.",
+    "admin_ban_bot":     "❌ Botti ei saa bannida.",
+    "admin_reset_bot":   "❌ Kassa andmeid ei saa lähtestada.",
+    "member_not_found":  "❌ **{name}** ei leitud tabelist.",
+    "request_self_fund": "❌ Sa ei saa oma taotlust ise rahastada.",
+    "request_self":      "❌ Sa ei saa iseendalt anuda.",
+    "request_bot":       "❌ Botid on teatavasti kitsid.",
+    "request_targeted":  "❌ See taotlus on suunatud kasutajale **{name}**.",
+    "request_closed":    "❌ See taotlus on juba rahastatud või aegunud.",
+    "already_in_game":   "❌ Sul on juba aktiivne mäng käimas!",
+    "invalid_amount":    "❌ Sisesta kehtiv summa või 'all'.",
+    "fund_range":        "❌ Sisesta summa vahemikus 1-{max}.",
+    "channel_only":      "❌ Boti käske saab kasutada ainult nendes kanalites: {channels}",
+    "guild_only":        "Seda käsku saab kasutada ainult serveris.",
+    "sheet_error":       "❌ Tabeli laadimine ebaõnnestus: ```{error}```",
+    "gamble_cooldown":   "🎰 Oled just mänginud! Saad uuesti mängida {ts}.",
+}
+
+# ---------------------------------------------------------------------------
+# Cooldown messages  (use .format(ts=...) - ts is a Discord timestamp string)
+# ---------------------------------------------------------------------------
+
+CD_MSG: dict[str, str] = {
+    "daily":  "⏳ Järgmine boonus {ts}.",
+    "work":   "⏳ Saad töötada {ts}.",
+    "beg":    "⏳ Saad kerjata {ts}.",
+    "crime":  "⏳ Saad uuesti proovida {ts}.",
+    "rob":    "⏳ Saad uuesti röövida {ts}.",
+    "heist":        "⏳ Saad uuesti heisti teha {ts}.",
+    "heist_global": "⏳ Pangahoidla alles kosub eelmisest röövist. Järgmine heist võimalik {ts}.",
+    "jailed": E["TipiTROLL"] + " Oled vangis! Pääsed välja {ts}. Kasuta `/jailbreak`, et varem välja pääseda.",
+    "fish":   "🎣 Saad uuesti kalastada {ts}.",
+}
+REMINDERS_UI: dict[str, str] = {
+    "select_placeholder": "Vali käsud, millest soovid meeldetuletust...",
+    "saved_on":           "✅ Meeldetuletused sisse lülitatud: {names}",
+    "saved_off":          "🔕 Kõik meeldetuletused välja lülitatud.",
+    "desc_active":        "Praegu aktiivne: {status}\n\nMuuda valikut allpool.",
+    "desc_none":          "Hetkel pole ühtegi meeldetuletust sisse lülitatud.\n\nVali allpool, millest soovid DM-i saada.",
+    "footer":             "Bot DM-ib sulle, kui valitud käsk on taas kasutamiseks valmis.",
+}
+
+# ---------------------------------------------------------------------------
+# /send  UI strings
+# ---------------------------------------------------------------------------
+
+SEND_UI: dict[str, str] = {
+    "sent":       "✅ Sõnum saadetud kanalisse {channel}!",
+    "forbidden":  "❌ Mul pole õigust kanalisse {channel} kirjutada.",
+}
+
+# ---------------------------------------------------------------------------
+# /patchnotes  UI strings
+# ---------------------------------------------------------------------------
+
+PATCHNOTES_UI: dict[str, str] = {
+    "title":              "📝 Muudatuste logi — {version}",
+    "footer":             "Versioon {idx}/{total}",
+    "btn_newer":          "◀ Uuem",
+    "btn_older":          "Vanem ▶",
+    "select_placeholder": "Vali versioon…",
+    "empty_file":         "ℹ️ Muudatuste logi on hetkel tühi.",
+    "empty_version":      "_(selle versiooni kohta märkmeid pole)_",
+}
+
+# ---------------------------------------------------------------------------
+# /status  UI
+# ---------------------------------------------------------------------------
+
+STATUS_UI: dict[str, str] = {
+    "title": "🖥️ Boti olek",
+    "uptime_field": "🕐 Uptime",
+    "uptime_val": "{hours}t {minutes}m {seconds}s",
+    "latency_field": "📡 Latency",
+    "latency_val": "{ms} ms",
+    "ram_field": "🧠 RAM (RSS)",
+    "ram_val": "{mb} MB",
+    "cpu_field": "⚙️ CPU",
+    "cpu_val": "{percent}%",
+    "tasks_field": "🔄 Async tasks",
+    "eco_players_field": "👤 Eco players",
+    "members_cache_field": "📋 Liikmed (cache)",
+    "log_files_field": "📂 Log files",
+    "log_line": "`{name}` - {size_kb} KB",
+    "none": "-",
+}

strings/economy.py

@@ -0,0 +1,469 @@
+"""Core economy: income, profile, shop, quests, leaderboard, requests.
+
+Auto-split from the original strings.py; edit strings here.
+"""
+
+from core.emoji import EMOJI as E
+
+__all__ = [
+    'WORK_JOBS',
+    'BEG_LINES',
+    'BEG_JAIL_LINES',
+    'CRIME_WIN',
+    'CRIME_LOSE',
+    'QUEST_UI',
+    'QUEST_DESCRIPTIONS',
+    'SHOP_UI',
+    'ITEM_DESCRIPTIONS',
+    'CONSUMABLES_UI',
+    'CONSUMABLE_DESCRIPTIONS',
+    'JAILED_UI',
+    'SHOP_BTN',
+    'DAILY_UI',
+    'STATS_UI',
+    'PROFILE_UI',
+    'BALANCE_UI',
+    'COOLDOWNS_UI',
+    'RANK_UI',
+    'WORK_UI',
+    'BEG_UI',
+    'CRIME_UI',
+    'ROB_UI',
+    'GIVE_UI',
+    'BUY_UI',
+    'LEADERBOARD_UI',
+    'REQUEST_UI',
+]
+
+# ---------------------------------------------------------------------------
+# Flavour text
+# ---------------------------------------------------------------------------
+
+WORK_JOBS: list[tuple[str, float]] = [
+    ("paigaldasid aulas netikaableid", 1.0),
+    ("paigaldasid aulas voolukaableid", 1.0),
+    ("tõid poest korraldajatele pitsat", 1.0),
+    ("konfigureerisid uue switchi", 1.0),
+    ("vedasid laudu aulasse", 1.0),
+    ("vedasid toole aulasse", 1.0),
+    ("paigaldasid aulasse vahekardinaid", 1.0),
+    ("aitasid üles seada turniiri lava", 1.0),
+    ("töötasid baaris", 1.0),
+    ("testisid helisüsteemi \"Erootikapoodi\" blastides", 1.0),
+    ("juhendasid külastajaid infolauas", 1.0),
+    ("seadistasid LAN serverit", 1.0),
+    ("paigaldasid monitore", 1.0),
+    ("ühendasid aulas kilpe", 1.0),
+    ("aitasid LANil osalejat", 1.0),
+    ("müüsid energiajooke", 1.0),
+    ("tegid netikaableid", 1.0),
+    ("lahendasid IP-konflikti", 1.0),
+    ("parandasid kellegi arvutit", 1.0),
+    ("tegid korda striimi heli (mitte nagu PGL)", 1.2),
+    ("kirjutasid koodi miniturniiri jaoks", 1.2),
+    ("võitsid turniiri", 1.5),
+]
+BEG_LINES: list[str] = [
+    "istusid kurva näoga oma monitori taga",
+    "palusid abi kellegi DMis",
+    "postitasid #abi kanalisse",
+    "vaatasid kadedusega teiste asju",
+    "kirjutasid /beg kolmandat korda järjest",
+    "küsisid oma tiimiliikmelt laenu",
+    "võtsid kiirlaenu",
+    "müüsid 3 sendi eest oma CSi skinne",
+    "korjasid kampuselt taarat",
+    "tegid TikToki live'i",
+    "refreshisid pangaäppi lootuses, et raha tekib",
+    "kirjutasid \"pls donate\" chatti",
+    "vaatasid oma tühja rahakotti",
+    "püüdsid kedagi guilt-trippida",
+    "lubasid exposure'it raha eest",
+    "mängisid kurba muusikat taustaks",
+    "teesklesid, et see on sotsiaalne eksperiment",
+    "kirjutasid emotsionaalse loo oma olukorrast",
+    "pakkusid vastu future equity't",
+    "tegite sõbraga koos kerjamisplaani",
+    "otsisid diivani vahelt sente",
+    "lubasid boostida kellegi ranki viieka eest",
+    "küsisid chatist, kas keegi teab kust tasuta V-Buckse saab",
+    "avastasid, et su krüptoportfell on sügavas miinuses",
+]
+BEG_JAIL_LINES: list[str] = [
+    "karjusid läbi trellide, et keegi münte läbi lükkaks",
+    "kirjutasid kongi seina peale oma PayPali aadressi",
+    "lubasid, et maksad järgmine kord vangi minnes tagasi",
+    "veensid valvurit, et oled tegelikult hea inimene",
+    "saatsid vanglast käsitsi kirjutatud kirja oma meeskonnale",
+    "pakkusid vahile tulevaste vihjete eest raha",
+    "koputasid morset vastu naaberkongi seina",
+    "üritasid vangla WiFit häkkida",
+    "lubasid teha tasuta IT-tööd vabanemise eest",
+    "üritasid lusikaga tunnelit kaevata",
+    "kirjutasid bug reporti vangla süsteemile",
+    "proovisid trellidest läbi pugeda, aga jäid kinni",
+    "pakkusid vangivalvurile oma Steami kontot vabanemise eest",
+]
+CRIME_WIN: list[str] = [
+    "häkkisid turniiri tulemuste tabelit",
+    "varastasid oma vastase hiire",
+    "varastasid oma vastase klaviatuuri",
+    "varastasid oma vastase kõrvaklapid",
+    "varastasid oma vastase monitori",
+    "varastasid oma vastase mikrofoni",
+    "müüsid võltsitud LANi pileteid",
+    "laenatasid kellegi GPUd ja ei tagastanud seda",
+    "laenatasid Filmiklubilt AUX-kaablit ja ei tagastanud seda",
+    "käivitasid DDoS rünnaku serverile",
+    "tegid oma shitcoin'idega pump and dump'i",
+    "kasutasid aimbotti ja keegi ei märganud",
+    "exploitisid mängu bugi enda kasuks",
+    "phishisid kellegi Steami konto",
+    "varastasid prize pooli raha",
+    "ühendasid enda krüptokaevandaja serverisse",
+    "tegid petukõnesid"
+]
+CRIME_LOSE: list[str] = [
+    "jäid turniiri adminile vahele",
+    "tõmbasid oma arvuti kaabli pistikust välja",
+    "kukutasid lahtise Red Bulli omale sülle",
+    "unustasid VPNi sisse lülitada",
+    "lagisid kriitilisel momendil",
+    "said banni otseülekande ajal",
+    "unustasid logid kustutada",
+    "sinu skript crashis valel hetkel",
+    "said reportitud mitme mängija poolt",
+    "sinu krüptokaevandaja süttis põlema",
+    "flashisid tervet oma tiimi",
+    "avastasid, et Windows otsustas keset mängu uuendama hakata",
+    "jäid politseile petukõnedega vahele"
+]
+
+# ---------------------------------------------------------------------------
+# Quest system  (/quests)
+# ---------------------------------------------------------------------------
+
+QUEST_UI: dict[str, str] = {
+    "daily_header":  "📅 Päevaülesanded",
+    "weekly_header": "📆 Nädalaülesanded",
+    "progress":      "⏳ {progress}/{max}",
+    "ready":         "✅ Valmis - nõua auhind!",
+    "completed":     "🏆 Nõutud",
+    "reward":        "🎁 {coins} ⬡ · {exp} EXP",
+    "empty":         "Ühtegi ülesannet pole. Proovi hiljem uuesti!",
+    "claim_btn":     "🎁 Nõua auhinnad",
+    "claimed_msg":   "🏆 Nõudsid {count} ülesande auhinnad: +{coins} · +{exp} EXP!",
+    "nothing":       "Sul pole ühtegi valmis ülesannet, mida nõuda.",
+    "error":         "❌ Ülesannete laadimine ebaõnnestus. Proovi hiljem uuesti.",
+}
+
+# Estonian one-line description per quest id (keys match economy.QUESTS_*).
+QUEST_DESCRIPTIONS: dict[str, str] = {
+    # Daily
+    "work3":     "Tööta 3 korda (/work)",
+    "beg5":      "Kerja 5 korda (/beg)",
+    "wager500":  "Panusta kokku 500 ⬡ hasartmängudes",
+    "fish2":     "Püüa 2 kala (/fish)",
+    "crime1":    "Soorita edukalt 1 kuritegu (/crime)",
+    "earn1000":  "Teeni kokku 1 000 ⬡",
+    "give200":   "Kingi teistele kokku 200 ⬡ (/give)",
+    # Weekly
+    "work20":    "Tööta 20 korda (/work)",
+    "fish15":    "Püüa 15 kala (/fish)",
+    "wager5000": "Panusta kokku 5 000 ⬡ hasartmängudes",
+    "crime5":    "Soorita edukalt 5 kuritegu (/crime)",
+    "heist1":    "Osale 1 grupiröövis (/heist)",
+    "earn10000": "Teeni kokku 10 000 ⬡",
+}
+
+# ---------------------------------------------------------------------------
+# Shop UI strings
+# ---------------------------------------------------------------------------
+
+SHOP_UI: dict[str, str] = {
+    "tier_1":       "Tier 1 - Algaja",
+    "tier_2":       "Tier 2 - Kogenud",
+    "tier_3":       "Tier 3 - Legend",
+    "desc":         "Saldo: {bal}  ·  Osta käsuga `/buy`",
+    "owned":        "✅ Olemas",
+    "owned_uses_1": "✅ Olemas ({uses} kasutus järel)",
+    "owned_uses_n": "✅ Olemas ({uses} kasutust järel)",
+    "locked":       "🔒 Tase {min_lvl} nõutud  *(sul on {user_lvl})*",
+}
+
+# ---------------------------------------------------------------------------
+# Shop item descriptions  (keyed by SHOP dict key in economy.py)
+# ---------------------------------------------------------------------------
+
+ITEM_DESCRIPTIONS: dict[str, str] = {
+    "gaming_hiir":       "Koolist varastatud hiir? Ei, see on mängurihiir. Teeni töötades 50% rohkem TipiCOINe.",
+    "hiirematt":         "XXL suuruses, ainult parimast materjalist. Kerjamise ooteaeg 5min → 3min.",
+    "korvaklapid":       "Noise-cancelling - kuuled ainult TipiCOINide kõlinat. Päevase boonuse ooteaeg 20h → 18h + 25⬡ boonust.",
+    "lan_pass":          "Ametlik TipiLANi pilet (2025). Päevane boonus on duubeldatud.",
+    "energiajook":       "Kolm Red Bulli järjest. 30% tõenäosus, et teenid töötades 3x rohkem.",
+    "gaming_laptop":     "RTX 5090 jooksutab botte 24/7. Päevane boonus genereerib 5% intressi sinu saldo pealt.",
+    "anticheat":         "VAC, EAC, Faceit AC ja BattlEye korraga. Röövimine sinu vastu ebaõnnestub. **2 kasutust**, siis pead ostma uue.",
+    "reguleeritav_laud": "Võid nii seista kui istuda - alati võidad. /work teenib 25% rohkem (stackib mängurihiirega).",
+    "jellyfin":          "Self-hosted meediaserver - oled suurfirmadest sõltumatu. Röövimise edu 45% → 60%. Grupiröövi õnnestumisele +5%.",
+    "mikrofon":          "Parem helikvaliteet teeb sind usutavamaks. Teeni 30% rohkem eduka /crime puhul.",
+    "klaviatuur":        "Klõbinad kostuvad üle kogu saali. /beg teenib 2x rohkem.",
+    "monitor":           "240Hz ja 27 tolli. /work ooteaeg: 1h → 40min.",
+    "cat6":              "Gigabitine internet = ideaalne piraatluseks. /crime edu tõenäosus tõuseb 60% → 75%.",
+    "monitor_360":       "360Hz, 1ms. Mänguautomaadi jackpot 10x → 15x, kolmik 4x → 6x. Hasartmängude ooteaeg 30s → 25s.",
+    "karikas":           "Ainult legendidele. Streak ei nulli, kui sa mõne päeva vahele jätad.",
+    "gaming_tool":       "Nii mugav, et isegi admin ei saa sind üles. /crime ebaõnnestumine ei saada sind vanglasse.",
+    "ussipurk":          "Lakkumatu toiduga ussipurk - kalad ei saa vastu. Kalapyygi ooteaeg 2min → 90s.",
+    "kalavork":          "Suurem võrk = suuremad kalad. Kõigi kalade haruldus tõuseb ühe astme võrra.",
+    "echolood":          "Täpne ehholood näitab kala täpset asukohta. Haukamise aken 2s → 3s.",
+}
+
+# ---------------------------------------------------------------------------
+# Consumables  (repeatable, expiring boosts - a recurring coin sink)
+# ---------------------------------------------------------------------------
+CONSUMABLE_DESCRIPTIONS: dict[str, str] = {
+    "energy_xl": "Topeltannus kofeiini. **1 tund**: /work, /beg ja /crime teenivad **2x** rohkem.",
+    "xp_potion": "Kahtlane roheline jook. **1 tund**: kõik EXP-allikad annavad **2x** rohkem.",
+    "kohv":      "Kange kohv äratab su üles. Nullib kohe kõik ooteajad (work, beg, crime, rob, fish).",
+}
+
+CONSUMABLES_UI: dict[str, str] = {
+    "title":         "☕ Turgutused",
+    "desc":          "Ühekordsed, korduvostetavad boostid. Saldo: {bal}  ·  Osta `/consumables <ese>`",
+    "active_header": "⏳ Aktiivsed boostid",
+    "active_none":   "Ühtegi boosti pole aktiivne.",
+    "buff_line":     "{name} - veel **{time}**",
+    "kind_earn":     "⚡ 2x tulu",
+    "kind_exp":      "✨ 2x EXP",
+    "bought_title":  "{emoji} {name} ostetud!",
+    "bought_buff":   "Boost on aktiivne **{time}**.\nUus saldo: {balance}",
+    "bought_extended": "Boosti pikendati - aktiivne veel **{time}**.\nUus saldo: {balance}",
+    "bought_instant":  "☕ Kõik ooteajad nullitud!\nUus saldo: {balance}",
+}
+
+JAILED_UI: dict[str, str] = {
+    "title":      "🔒 Praegu vanglas",
+    "empty":      "Kõik on vabad! Vanglas pole kedagi.",
+    "entry":      "• {mention} - vabaneb <t:{ts}:R>",
+    "footer":     "{count} vang{plural}",
+}
+SHOP_BTN: dict[int, str] = {
+    1: "Tier 1",
+    2: "Tier 2",
+    3: "Tier 3",
+}
+
+# ---------------------------------------------------------------------------
+# /daily  embed strings
+# ---------------------------------------------------------------------------
+
+DAILY_UI: dict[str, str] = {
+    "earned":    "✅ Said {earned}!",
+    "interest":  E["TipiLAP"] + " Bot Farm tootis: +{interest}",
+    "vip":       f"{E['TipiPILET']} LAN pileti boonus rakendus!",
+    "footer":    "Streak: {streak_str}  ·  Saldo: {balance}",
+}
+
+# ---------------------------------------------------------------------------
+# /stats  embed strings
+# ---------------------------------------------------------------------------
+
+STATS_UI: dict[str, str] = {
+    "economy_field":   "💰 Majandus",
+    "economy_val":     "Tipp-saldo: {peak}\nEluaegne tulu: {earned}\nEluaegne kaotus: {lost}",
+    "work_field":      "🛠️ Töö & Kerja",
+    "work_val":        "Töötanud: **{work}** korda\nKerjanud: **{beg}** korda",
+    "gamble_field":    "🎲 Hasartmängud",
+    "gamble_val":      "Panustatud kokku: {wagered}\nSuurim võit: {win}\nSuurim kaotus: {loss}\nSlotsi jackpotid: **{jackpots}** korda",
+    "crime_field":     "🦹 Kuritegevus",
+    "crime_val":       "Kuriteod: **{crimes}** ({succeeded} õnnestus)\nHeistid: **{heists}** ({heists_won} võideti)\nVangi sattunud: **{jailed}** korda\nKautsjon makstud: {bail}",
+    "social_field":    "🤝 Sotsiaalne",
+    "social_val":      "Kingitud: {given}\nSaadud: {received}",
+    "records_field":   "🔥 Rekordid",
+    "records_val":     "Pikim päevane streak: **{streak}** päeva",
+}
+
+# ---------------------------------------------------------------------------
+# /profile  tabbed view
+# ---------------------------------------------------------------------------
+
+PROFILE_UI: dict[str, str] = {
+    "btn_profile": "💰 Profiil",
+    "btn_items":   "🎒 Esemed",
+    "btn_stats":   "📊 Statistika",
+    "btn_fish":    "🎣 Kalakogu",
+    "main_title":  "💰 {name}",
+    "items_title": "🎒 {name} - Esemed",
+    "stats_title": "📊 {name} - Statistika",
+    "fish_title":  "🎣 {name} - Kalakogu",
+    "items_empty": "Sul pole ühtegi eset.",
+    "f_balance":   "💰 Saldo",
+    "f_level":     "📊 Tase",
+    "f_streak":    "🔥 Streak",
+    "f_prestige":  "⭐ Prestiiz",
+    "f_jail":      "🚔 Vangis kuni",
+    "f_progress":  "→ Tase {next}",
+    "progress_bar": "`{bar}` {done}/{needed} EXP",
+    "level_val":   "Tase {level} - {role}",
+    "prestige_val":"⭐ P{level}  ·  {pp} PP",
+    "footer_t1":   "Tase 10 avab T2 poe · Tase 20 avab T3 poe",
+    "footer_t2":   "T2 pood avatud · Tase 20 avab T3 poe",
+    "footer_t3":   "T2 ja T3 pood avatud",
+}
+
+# ---------------------------------------------------------------------------
+# /balance  embed strings
+# ---------------------------------------------------------------------------
+
+BALANCE_UI: dict[str, str] = {
+    "saldo":        "Saldo",
+    "streak":       "Päeva streak",
+    "streak_val":   "🔥 {streak}p",
+    "jailed_until": "🚔 Vangis kuni",
+    "items":        "Esemed",
+    "uses_one":     " *({uses} kasutus järel)*",
+    "uses_many":    " *({uses} kasutust järel)*",
+}
+
+# ---------------------------------------------------------------------------
+# /cooldowns  embed strings
+# ---------------------------------------------------------------------------
+
+COOLDOWNS_UI: dict[str, str] = {
+    "ready":          "✅ Valmis",
+    "daily_line":     "📅 **/daily**  {status}{note}",
+    "work_line":      "💼 **/work**  {status}{note}",
+    "beg_line":       "🙏 **/beg**  {status}{note}",
+    "crime_line":     "🦹 **/crime**  {status}",
+    "rob_line":       "🔫 **/rob**  {status}",
+    "fish_line":      "🎣 **/fish**  {status}{note}",
+    "note_korvak":    " *(kõrvaklapid: 18t)*",
+    "note_monitor":   " *(monitor: 40min)*",
+    "note_hiirematt": " *(hiirematt: 3min)*",
+    "note_ussipurk":  " *(ussipurk: 90s)*",
+    "jailed":         "\n🔒 **Vanglas** - vabaneb <t:{ts}:R>",
+    "jail_expired":   "\n🔓 Vangla lõppes",
+}
+
+# ---------------------------------------------------------------------------
+# /rank  embed strings
+# ---------------------------------------------------------------------------
+
+RANK_UI: dict[str, str] = {
+    "title":          "📊 {name} - Tase {level}",
+    "field_title":    "Tiitel",
+    "field_exp":      "EXP",
+    "field_progress": "Progress → Tase {next}",
+    "progress_val":   "`{bar}` {progress}/{needed} EXP",
+    "footer_t1":      "Tase 10 avab T2 poe · Tase 20 avab T3 poe",
+    "footer_t2":      "T2 pood avatud · Tase 20 avab T3 poe",
+    "footer_t3":      "T2 ja T3 pood avatud",
+}
+
+# ---------------------------------------------------------------------------
+# /work  embed strings
+# ---------------------------------------------------------------------------
+
+WORK_UI: dict[str, str] = {
+    "desc":     "Sa {job} ja teenisid {earned}!",
+    "redbull":  f"\n{E['TipiBULL']} Red Bull aktiveerus - 3x boonus!",
+    "hiir":     f"\n{E['TipiHIIR']} Mängurihiir: +50% palk",
+    "laud":     f"\n{E['TipiLAUD']} Reguleeritav laud: +25% palk",
+    "balance":  "\nSaldo: {balance}",
+}
+
+# ---------------------------------------------------------------------------
+# /beg  embed strings
+# ---------------------------------------------------------------------------
+
+BEG_UI: dict[str, str] = {
+    "desc":       "Sa {text} ja said {earned}.",
+    "klaviatuur": f"{E['TipiKLAVA']} Mehhaaniline klaviatuur: 2x tulu",
+    "balance":    "Saldo: {balance}",
+}
+
+# ---------------------------------------------------------------------------
+# /crime  embed strings
+# ---------------------------------------------------------------------------
+
+CRIME_UI: dict[str, str] = {
+    "win_desc":    "Sa {text} ja teenisid {earned}!",
+    "fail_base":   "Sa {text} ja said trahvi {fine}.",
+    "fail_jailed": "\n\ud83d\udd12 Oled vangis! P\u00e4\u00e4sed {ts}.",
+    "fail_shield": "\n\ud83d\udee1\ufe0f Gaming Tool hoidis sind vanglast!",
+    "mikrofon":    f"\n{E['TipiMIC']} Mikrofon: +30% saak",
+    "cat6":        f"\n{E['TipiCAT']} CAT6: 75% edu t\u00f5en\u00e4osus",
+    "balance":     "\nSaldo: {balance}",
+}
+
+# ---------------------------------------------------------------------------
+# /rob  embed strings
+# ---------------------------------------------------------------------------
+
+ROB_UI: dict[str, str] = {
+    "jackpot_desc":    "💥 **JACKPOT!** Murdsid TipiBOTi kassasse sisse ja varastasid {stolen}!\nSaldo: {balance}",
+    "win_desc":        "Varastasid {stolen} kasutajalt **{name}**!\nSaldo: {balance}",
+    "anticheat_desc":  "**{name}** kaitseb end Anticheati'ga - said trahvi {fine}.",
+    "anticheat_worn":  "⚠️ Sinu **Anticheat** on kulunud! Osta uus `/buy` käsuga.",
+    "victim_dm":       "💸 **{robber}** varastas sinult **{stolen}** münti!",
+    "fail_desc":       "Jäid vahele! Trahv: {fine}.\nSaldo: {balance}",
+}
+
+# ---------------------------------------------------------------------------
+# /give  embed strings
+# ---------------------------------------------------------------------------
+
+GIVE_UI: dict[str, str] = {
+    "desc": "**{giver}** andis {amount} kasutajale **{receiver}**.",
+}
+
+# ---------------------------------------------------------------------------
+# /buy  embed strings
+# ---------------------------------------------------------------------------
+
+BUY_UI: dict[str, str] = {
+    "title": "{emoji} {name} ostetud!",
+    "desc":  "{description}\nUus saldo: {balance}",
+}
+
+# ---------------------------------------------------------------------------
+# /leaderboard  UI strings
+# ---------------------------------------------------------------------------
+
+LEADERBOARD_UI: dict[str, str] = {
+    "house_entry":    "🤖 {name} *(maja)* - {balance}",
+    "house_default_name": "TipiBOT",
+    "no_entries":     "Keegi ei ole veel punkte teeninud.",
+    "footer":         "Lehekülg {page}/{total}  ·  {count} mängijat",
+    "btn_coins":      "🪙 Mündid",
+    "btn_exp":        "📊 EXP",
+    "btn_find_me":    "📍 Mina",
+    "exp_entry":       "{prefix} {name} - {exp} EXP  *(Tase {level})*",
+    "unknown_user":    "Kasutaja {uid}",
+    "btn_season":      "🏆 Hooaeg",
+    "btn_prestige":    "🔥 Prestiiž",
+    "btn_wagered":     "🎲 Hasartmäng",
+    "btn_fish":        "🎣 Kalapyyk",
+    "season_entry":    "{prefix} {name} - {exp} EXP *(Prestiiž {prestige})*",
+    "prestige_entry":  "{prefix} {name} - Prestiiž **{prestige}** · {pp} PP",
+    "wagered_entry":   "{prefix} {name} - {wagered} panustatud",
+    "fish_entry":      "{prefix} {name} - {caught} kala",
+}
+
+# ---------------------------------------------------------------------------
+# /request  UI strings
+# ---------------------------------------------------------------------------
+
+REQUEST_UI: dict[str, str] = {
+    "modal_title":        "Rahasta taotlust",
+    "modal_label":        "Kui palju soovid panustada?",
+    "btn_fund":           "Rahasta 💸",
+    "btn_funded":         "Rahastatud ✅",
+    "btn_fund_remaining": "Rahasta 💸 ({remaining}⬡ jäänud)",
+    "funded_line":        "✅ **{name}** panustas {amount}",
+    "funded_full":        "\n🎯 Taotlus täielikult täidetud!",
+    "funded_partial":     "\n💰 Jäänud: {remaining}",
+    "audience_all":       "Avatud kõigile rahastajatele 🌍",
+    "audience_targeted":  "Suunatud: **{name}**",
+    "desc":               "**{requester}** palub {amount}\n\n📋 **Põhjus:** {reason}\n\n{audience}",
+    "footer":             "Taotlus aegub 5 minuti pärast",
+}

strings/fishing.py

@@ -0,0 +1,86 @@
+"""Fishing minigame: fish catalogue, rarities, and /fish UI.
+
+Auto-split from the original strings.py; edit strings here.
+"""
+
+__all__ = [
+    'FISH_NAMES',
+    'FISH_RARITY_NAMES',
+    'FISH_RARITY_EMOJI',
+    'FISH_JUNK_LINES',
+    'FISH_UI',
+]
+
+# ---------------------------------------------------------------------------
+# Fishing system strings
+# ---------------------------------------------------------------------------
+
+FISH_NAMES: dict[str, str] = {
+    "sarj":     "Särg",
+    "ahven":    "Ahven",
+    "koger":    "Koger",
+    "viidikas": "Viidikas",
+    "latikas":  "Latikas",
+    "karpkala": "Karpkala",
+    "linask":   "Linask",
+    "haug":     "Haug",
+    "angerjas": "Angerjas",
+    "siig":     "Siig",
+    "forell":   "Forell",
+    "koha":     "Koha",
+    "tougjas":  "Tõugjas",
+    "lohe":     "Lõhe",
+    "vimb":     "Vimb",
+}
+FISH_RARITY_NAMES: dict[str, str] = {
+    "common":    "Tavaline",
+    "uncommon":  "Ebatavaline",
+    "rare":      "Haruldane",
+    "epic":      "Eepiline",
+    "legendary": "Legendaarne",
+}
+FISH_RARITY_EMOJI: dict[str, str] = {
+    "common":    "🐟",
+    "uncommon":  "🐠",
+    "rare":      "🎣",
+    "epic":      "⭐",
+    "legendary": "🌟",
+}
+FISH_JUNK_LINES: list[str] = [
+    "Sa saad... **vana saabas**. Klassika.",
+    "Õnnitlused, leidsid **kasutatud autorehvi**. Keskkond tänab sind... mitte.",
+    "Taas üks **klaaspudel** rohkem jões.",
+    "**Vana poes käimise kott**! Hoidis aega hästi.",
+    "**Roostes konserv** - ilma sildita. Parem mitte teada, mis sees on.",
+    "**Ummistunud drenaažitoru**. Keegi oli hoolimatu.",
+    "**Tühi rahakott**. Kellegi päev läks halvemaks kui sinu oma.",
+    "**Vana CD-plaat** - Evanescence, 2003. Heas seisukorras.",
+    "Sa said **kivikese**. Ilus kivikene. Aga siiski kivikene.",
+    "**Kaotsi läinud droon**. GPS ei tööta, aku tühi.",
+]
+FISH_UI: dict[str, str] = {
+    "btn_wait":     "🎣 Oota näkkamist...",
+    "btn_bite":     "🐟 TÕMBA!",
+    "btn_sell":     "💰 Müü",
+    "btn_keep":     "🎒 Hoia",
+    "cast_desc":    "Viskad õnge vette. Oota, kuni kala näkkab...\n\n-# Vajuta nuppu, kui kala näkkab!",
+    "bite_desc":    "**KALA NÄKKAB!** Tõmba kiiresti! ⚡\n\n-# Sul on 2 sekundit!",
+    "escape_desc":  "Liiga hilja - kala lipsas minema. Proovi järgmine kord kiiremini!",
+    "junk_desc":    "{text}\n\n-# Saldo: {balance}",
+    "catch_desc":   "**{name}** · {weight}g  ·  +{exp} EXP\n-# Kas müüd kohe ({value}) või hoiad inventaris?",
+    "catch_sold":   "**{name}** · {weight}g\n\n+{coins}  ·  +{exp} EXP\nSaldo: {balance}",
+    "catch_kept":   "**{name}** · {weight}g lisatud inventarisse.  *(+{exp} EXP)*",
+    "new_fish":     "\n✨ **Uus kala kalakogusse lisatud!**",
+    "too_early":    "❌ Kala pole veel näkkanud! Oota...",
+    "book_caught":  "Püütud kalaliike: **{caught}/{total}**",
+    "book_yes":     "✅ {emoji} **{name}** *({rarity})*  · {count}×{inv}",
+    "book_inv":     "  *(inventaris: {n})*",
+    "book_no":      "❓ **???** *({rarity})*",
+    "book_footer":  "Lehekülg {page}/{total_pages}  ·  {caught}/{total} liiki",
+    "book_empty":   "Sa pole veel ühtegi kala püüdnud! Kasuta `/fish`.",
+    "inv_empty":    "Sinu kalainventaar on tühi! Kasuta `/fish` kala püüdmiseks.",
+    "inv_header":   "Sul on **{count}** kala inventaris  *(kokku väärt {total_value})*",
+    "inv_entry":    "{emoji} **{name}** · {weight}g · {value}",
+    "inv_sold_all": "Müüsid **{count}** kala kokku {coins} eest!\nSaldo: {balance}",
+    "inv_none":     "Inventaaris pole midagi müüa.",
+}

strings/games.py

@@ -0,0 +1,307 @@
+"""Minigames & gambling: slots, roulette, RPS, blackjack, heist, jailbreak.
+
+Auto-split from the original strings.py; edit strings here.
+"""
+
+from core.emoji import EMOJI as E
+
+__all__ = [
+    'SLOTS_TIERS',
+    'ROULETTE',
+    'HEIST_STORY',
+    'HEIST_UI',
+    'BJ',
+    'JAILBREAK_UI',
+    'SLOTS_UI',
+    'RPS_UI',
+    'RPS_CHOICES',
+    'BJ_UI',
+]
+
+# ---------------------------------------------------------------------------
+# /slots  outcome strings  (title, colour)
+# ---------------------------------------------------------------------------
+
+SLOTS_TIERS: dict[str, tuple[str, int]] = {
+    "jackpot": (f"{E['TipiFIRE']} JACKPOT!!!",                                  0xF4C430),
+    "triple":  ("🎰 Kolmik!",                                                   0x57F287),
+    "pair":    ("🎰 Paar",                                                       0x99AAB5),
+    "miss":    (f"{E['TipICRY']} Ei õnnestunud",                                0xED4245),
+}
+
+# ---------------------------------------------------------------------------
+# /roulette  outcome strings
+# ---------------------------------------------------------------------------
+
+ROULETTE: dict = {
+    "emoji":    {"punane": "🔴", "must": "⚫", "roheline": "🟢"},
+    "genitive": {"punane": "punase", "must": "musta", "roheline": "rohelise"},
+    "win_title":  "{emoji} Võitsid!",
+    "lose_title": "{emoji} Kaotasid!",
+    "win_desc":   "Ratas peatus **{genitive}** peal!{mult}\n+{change}\nSaldo: {balance}",
+    "lose_desc":  "Ratas peatus **{genitive}** peal.\n-{change}\nSaldo: {balance}",
+    "spin_title": "🎰 Ratas keerleb...",
+    "spin_stop":  "🎰 Ratas peatub...",
+    "spin_strip": "{s0}  {s1}  {s2}  {s3}  {s4}",
+}
+
+# ---------------------------------------------------------------------------
+# /heist  narrative story lines
+# Placeholders: {leader}, {member}, {names}, {vehicle}
+# ---------------------------------------------------------------------------
+
+HEIST_STORY: dict = {
+    "vehicles": [
+        "Škoda",
+        "BMW",
+        "Lada",
+        "Mazda",
+    ],
+    "arrival": [
+        "{leader} keerab nurga taga {vehicle} mootori kinni. Maskid ette. Keegi ei räägi.",
+        "{vehicle} peatub ühe kvartali kaugusel sihtmärgist. {leader}: *\"Pank on seal. Tegutseme plaani järgi.\"*",
+        "Meeskond astub {vehicle}st välja. {leader} kuulab kõrvamonitori. *\"Kaks valvurit, üks pimeala. Liigume nüüd.\"*",
+        "{leader} jälgib {vehicle}st sissepääsu. *\"Valvurite vahetus 40 sekundi pärast. See on meie ajaaken.\"*",
+        "Kell 3 öösel. Tänav on tühi. {vehicle} seisab väljas tühikäigul. {leader} tõmbab maski ette.",
+        "{vehicle} veereb aeglaselt vaiksesse pimedasse vahetänavasse. {leader}: *\"Viimane kontroll. Kõik valmis?\"*",
+        "{leader} koputab armatuurlauale. *\"Kui midagi läheb valesti, me lahkume kohe.\"* Vaikus vastuseks.",
+        "Tuul sahiseb mööda tühja tänavat. {vehicle} uksed avanevad korraga.",
+        "{member} kontrollib relva. {leader} vaatab kella. *\"Me oleme graafikus.\"*",
+        "{vehicle} tuled kustuvad. Linn jääb vaikseks. Nad liiguvad.",
+    ],
+    "entry_sneaky": [
+        "{member} tõmbab kloonitud kaarti külgukse juures. Lukk klõpsab hääleta lahti.",
+        "Meeskond libiseb sisse laadimisestakaadi kaudu, riietatud öisteks koristajateks.",
+        "{leader} on kaks nädalat valvurite graafikut pähe õppinud. Röövlid kõnnivad sisse vahetuse ajal.",
+        "Võltsitud alltöövõtja kaardi abil saavad nad fuajeest läbi ilma lisaküsimuseta.",
+        "{member} lülitab välikaamerad sülearvutist välja. {leader} kõnnib sisse, nagu see oleks tema oma maja.",
+        "{member} kasutab signaaliblokeerijat. Häired ei jõua kunagi süsteemi.",
+        "{leader} avab ventilatsiooniluugi. *\"Läheme ülevalt.\"*",
+        "Turvamees haigutab. Sekund hiljem on ta seotud ja vaikselt nurka lohistatud.",
+        "{member} süstib lukku mikrokaamera. Mehhanism kaardistatakse sekunditega.",
+    ],
+    "entry_loud": [
+        "{leader} lööb esiuksed lahti. *\"KÕIK PÕRANDALE - KOHE!\"*",
+        "Esmalt suitsugranaadid. Selleks ajaks, kui suits vaibub, on meeskond juba sees.",
+        "{leader} tulistab ühe lasu lakke. Haudvaikus. *\"Oleme siin seifi pärast! Kui teete koostööd, siis pääsete elusana.\"*",
+        "*\"Kui keegi ei liigu, ei saa keegi ka viga.\"* {leader} omab ruumi täielikku tähelepanu.",
+        "{member} lükkab kilbist elektri välja. Pimeduses juhib {leader} meeskonna mälu järgi edasi.",
+        "*\"See on rööv! Kõik pikali!\"* {leader} hääl kajab läbi saali.",
+        "Alarm hakkab ulguma juba enne, kui nad täielikult sisse jõuavad.",
+        "Klaas puruneb. Inimesed karjuvad. Täielik kaos.",
+    ],
+    "inside": [
+        "{names} liiguvad kiiresti läbi fuajee, sidudes turvamehi postide külge kinni.",
+        "{member} katab väljapääsud. {leader} suundub otse seifi poole.",
+        "Üks kassapidajatest proovib käivitada vaikset häiret, kuid {member} märkab ta nihelemist ja peatab ta hoiatuslasuga.",
+        "{leader} hoiab töötajad rahulikuna samal ajal, kui teised suunduvad alumisele korrusele.",
+        "Turvakaamerad on tsüklil. {names} on korrusel üksi.",
+        "{member} kontrollib kellaaega. *\"Me oleme 30 sekundit ees.\"*",
+        "{leader} annab käemärgi. Meeskond jaguneb ilma sõnadeta.",
+        "Koridor on tühi. Liiga tühi. {leader} peatub hetkeks.",
+        "{names} liiguvad trepist alla, sammud summutatud.",
+        "Üks uks on lukus. {member} avab selle sekundiga.",
+    ],
+    "vault": [
+        "Neljanda taseme ajalukuga seif. {member} tõmbab puuri välja. *\"Anna mulle kolm minutit.\"*",
+        "{leader} vaatab seifi ust. *\"Dünamiit.\"* Keegi ei vaidle.",
+        "{member} ühendub seifi juhtpaneeliga. Vana tarkvara. Ülevõtmine võtab 90 sekundit.",
+        "Seifil on käsikombinatsiooni lukk. Hea, et {leader} veetis kuu aega juhatajaga, teenides tema usaldust.",
+        "{member} paigutab lõhkeained. Meeskond astub tagasi. Üks kontrollitud plahvatus.",
+        "{leader} teeb magnetlukule tühistuse. Nagu õpikust võetud. Mehhanism annab järgi.",
+        "{member} higistab. *\"See pole standardlukk... anna mulle aega.\"*",
+        "{leader} kuulab vastu seifi ust. *\"Sees on liikumisandur.\"*",
+        "{member} lõikab läbi metallkihi nagu võid.",
+        "Ajurünnak. {leader} meenutab skeemi ja leiab nõrga koha.",
+        "{member} ühendab juhtmed ümber. Säde. Vaikus. Lukk avaneb.",
+    ],
+    "vault_open": [
+        "Uks avaneb. Kuhi-kuhja järel raha, põrandast laeni. Täpselt nagu plaanitud.",
+        "*\"...jackpot.\"* {leader} piilub seifi sisse. Meeskond seisab hetkeks vaikuses.",
+        "{member} hakkab kotte täis laduma. {leader} piilub juba väljapääsu poole.",
+        "Puhas. Kiire. {names} on seifis ja täidavad kotte enne, kui tolm settib.",
+        "Seif on lahti. {leader} võtab hinge. *\"Okei. Kottidesse ja liikuma.\"*",
+        "{leader} naeratab esimest korda. *\"See oli seda väärt.\"*",
+        "Raha lõhn täidab õhu. {member}: *\"Võtame kõik.\"*",
+        "{names} töötavad vaikides. Iga liigutus loeb.",
+        "Kotid täituvad kiiremini kui oodatud.",
+        "{leader} pilk muutub tõsiseks. *\"Aeg otsas. Liigume.\"*",
+    ],
+    "police_inbound": [
+        "Raadio krõbiseb. *\"Kõik üksused, relvastatud rööv Keskpangas-\"*",
+        "Väljas on kuulda eemalt ulguvaid sireene. {leader}: *\"Meil on umbes neli minutit. Liikuma.\"*",
+        "Punased ja sinised tuled vilguvad ülemistest akendest läbi. Varualarm käivitati.",
+        "Politsei helikopter skaneerib piirkonda prožektoriga. Aken sulgub kiiresti.",
+        "{member} kontrollib politsei skännerit. *\"Nad teavad. Kolm üksust, kaks minutit eemal.\"*",
+        "{member} kuulab raadiosidet. *\"Nad sulgevad kvartaleid.\"*",
+        "Sireenid lähenevad kiiremini kui plaanitud.",
+        "Helikopteri valgus libiseb üle akna. Liiga lähedal.",
+    ],
+    "getaway_success": [
+        "Adrenaliin. {names} jooksevad {vehicle} juurde. Kõik sees. {leader} keerab mootori käima.",
+        "{member} haarab roolist. {leader} on kõrval. *\"Lähme.\"* Rahulikult.",
+        "{leader} libistab {vehicle} kõrvalteed pidi minema. Sireen kaugel taga. Nad on kiiremad.",
+        "Rohelised tuled. {vehicle} sõidab vaikselt mööda parklas ootavast patrullautost. Keegi ei märka.",
+        "{member} näitab teed. {leader} sõidab vaikselt läbi tagakvartali. Käed lõdvad.",
+        "{vehicle} rehvid vilisevad, kui nad pööravad kitsasse tänavasse.",
+        "{leader} sõidab ilma tuledeta. Ainult mälu juhib teda.",
+        "{member} vaatab kaarti. *\"Vasak, siis kohe parem!\"*",
+        "Mootor möirgab. Nad kaovad öösse.",
+        "{vehicle} libiseb läbi viimase rohelise tule.",
+    ],
+    "getaway_fail": [
+        "{names} jooksevad {vehicle} juurde. Sireenid igalt poolt.",
+        "{member} haarab roolist. {leader} on kõrval. *\"Mine! MINE!\"*",
+        "{vehicle} kihutab tänavale, kuid helikopteri valgusvihk osutab neile. Kõik on nähtaval.",
+        "Kolm patrullautot jõuavad nende taha. {member} vaatab üle õla. *\"Nad on meil kannul.\"*",
+        "Raadio krõbiseb. *\"Sihtmärk kinnitatud. Blokeeri Liivalaia tänav.\"*",
+        "{vehicle} ei käivitu. {member}: *\"Päriselt ka või?!\"*",
+        "{member} komistab teel autoni. Tal oli pael lahti tulnud",
+        "{leader} avastab, et autot pole kuskil näha. See pukseeriti ära."
+    ],
+    "escape_success": [
+        "{names} murravad läbi perimeetri enne väravate sulgemist. Puhas põgenemine.",
+        "{leader} oli planeerinud kolm väljumisteed. Vaja läks ühte. {vehicle} kaob linna.",
+        "Kahe kvartali kaugusel asuv peibutushäire tõmbab üksused eemale. {names} on kadunud enne, kui keegi seifi kontrollib.",
+        "Naelribad? Juba eemaldatud. Teeblokk? Vale tänav. {leader} mõtles kõigele.",
+        "{vehicle} sõidab maanteele nagu poleks midagi juhtunud. {leader} hingab esimest korda tunnis välja.",
+        "*\"Oleme vabad.\"* {member} piilub kardinate tagant välja. Tühi tänav. Nad tegid ära.",
+        "{names} kaovad sügavale linna nagu neid poleks kunagi olnud.",
+        "Raadio jääb vaikseks. Keegi ei jälita enam.",
+        "{vehicle} jäetakse maha. Uus plaan aktiveerub.",
+        "{leader}: *\"See oli liiga lihtne...\"*",
+    ],
+    "escape_fail": [
+        "Patrullauto lõikab {vehicle} teekonna sillal ära. Mõlemalt poolt ümbritsetud. Ongi läbi.",
+        "{member} kukutab koti. Kolm sekundit kõhklust - ja uksed on ümber piiratud.",
+        "Helikopter jälgib neid kuni pelgupaigani. Kõik väljapääsud on kaetud.",
+        "{leader} arvutab võimalusi. *\"Väljapääsu pole.\"* Käed lähevad üles.",
+        "Naelribad lõhuvad {vehicle} rehvid. Meeskond libiseb liikluse keskele seisma.",
+        "{vehicle} põrkub vastu teetõket. Mootor sureb. Igast suunast tuled.",
+    ],
+}
+
+# ---------------------------------------------------------------------------
+# /heist  UI strings
+# ---------------------------------------------------------------------------
+
+HEIST_UI: dict[str, str] = {
+    "names_duo":          "**{a}** ja **{b}**",
+    "names_sep":          " & ",
+    "names_crew":         "**{leader}** ja meeskond",
+    "btn_join":           "Ühine röövimisega 🔫",
+    "btn_start":          "Alusta kohe ▶",
+    "already_joined":     "Sa oled juba sees!",
+    "only_organizer":     "Ainult heisti algataja saab heisti alustada.",
+    "lobby_desc":         "**Osalejad ({n}/{max}):**\n{names}\n\nÕnnestumise tõenäosus: **{chance}%**\n\n*Ühinemisaken sulgub <t:{ts}:R>*",
+    "cancel_desc":        "Ei piisanud osalejaid (vajad vähemalt **{min}**). Heist tühistati.",
+    "started_title":      "🔫 Grupirööv käib...",
+    "started_desc":       "**{n}** osalejat alustasid heisti. Jälgi allpool!",
+    "story_title":        "🔫 Grupirööv",
+    "win_desc":           "**Osalejad:**\n{names}\n\nSaak jagati võrdselt.\n**Igaüks sai: +{payout}**",
+    "fail_desc":          "**Osalejad:**\n{names}\n\nKõik osalejad saavad **1,5 tundi vangi** + trahv ~15% saldost.",
+}
+
+# ---------------------------------------------------------------------------
+# Blackjack in-game strings
+# ---------------------------------------------------------------------------
+
+BJ: dict[str, str] = {
+    "dealing":       "*Jagame kaardid...*",
+    "result_field":  "Tulemus",
+    "push_result":   "±0 (panus tagasi)",
+    "doubled_label": "💰 *Topeltpanus: {total}*",
+    "btn_hit":       "🃏 Võta kaart",
+    "btn_stand":     "✋ Seisa",
+    "btn_double":    "💰 Kahekordista (+{bet}⬡)",
+    "btn_split":     "✂️ Split (+{bet}⬡)",
+}
+
+# ---------------------------------------------------------------------------
+# /jailbreak  UI strings
+# ---------------------------------------------------------------------------
+
+JAILBREAK_UI: dict[str, str] = {
+    "btn_roll":          "🎲 Viska täringud  ({try_}/{max})",
+    "rolling_desc":     f"{E['TipiDICE']}  *Täringud lendavad...*",
+    "free_desc":        "{d1}  {d2}\n\n✅ Viskasid duubli - pääsesid vanglast!",
+    "miss_desc":        "{d1}  {d2}\n\n{left} katset jäänud. Proovi uuesti!",
+    "intro_desc":       "Oled vangis kuni {ts}.\n\nViska täringuid ja proovi **duublit** saada - siis pääsed tasuta vabaks!\nSul on **{tries} katset**. Ebaõnnestumisel saad valida: maksa kautsjon **(20–30% saldost, min 350 ⬡)** või jää vanglasse kuni aja lõpuni.",
+    "already_bail":     "Oled juba täringuid visanud. Ainuke väljapääs on kautsjon.\n\n💰 **Kautsjon: {min} – {max}** (20–30% saldost)\nSaldo: {bal}    Väljas: {ts}",
+    "already_broke":    "Oled juba täringuid visanud. Sul pole piisavalt raha kautsjoni maksmiseks.\n\n💰 Kautsjoni miinimum: **{min}** - sul on ainult {bal}\nVäljas: {ts}",
+    "bail_btn":         "💸 Maksa kautsjon",
+    "bail_broke_desc":  "❌ Sul pole piisavalt raha (min {min}).\nJääd vanglasse kuni aja lõpuni! Saldo: {balance}",
+    "bail_paid_desc":   "✅ Kautsjon makstud: **{fine}**\nOled vaba! Saldo: {balance}",
+    "bail_already_free": "✅ Oled juba vaba - kautsjonit ei võetud. Saldo: {balance}",
+    "fail_broke_desc":  "{d1}  {d2} - ei olnud duubel\n\n❌ Sul pole kautsjoni maksmiseks piisavalt raha (min 350 ⬡).\nJääd vanglasse kuni aja lõpuni! Saldo: {balance}",
+    "fail_bail_desc":   "{d1}  {d2} - ei olnud duubel\n\nKautsjon makstud: **{fine}**\nSaldo: {balance}",
+    "fail_bail_offer":  "{d1}  {d2} - ei olnud duubel\n\n💰 **Kautsjon: {min} - {max}** (20-30% saldost)\nSaldo: {bal}\n\nSaad maksta kautsjoni või jääda vanglasse kuni aja lõpuni.",
+}
+
+# ---------------------------------------------------------------------------
+# /slots  additional UI strings  (titles/footers per outcome)
+# ---------------------------------------------------------------------------
+
+SLOTS_UI: dict[str, str] = {
+    "playing":        "🎰 Mängimas...",
+    "jackpot_footer": E["TipiKARIKAS"] + " Kolm karikat! +{change}",
+    "triple_footer":  "✅ Kolm ühesugust! +{change}",
+    "pair_footer":    "Kaks ühesugust! +{change}",
+    "miss_footer":    "-{amount}",
+    "balance_line":   "\nSaldo: {balance}",
+}
+
+# ---------------------------------------------------------------------------
+# /rps  UI strings
+# ---------------------------------------------------------------------------
+
+RPS_UI: dict[str, str] = {
+    "vs_bot_desc":        "Tee oma valik! ⬇️",
+    "vs_bot_bet":         "\nPanus: {bet}",
+    "result_tie":         "🤝 Viik!",
+    "result_win":         "🎉 Sina võitsid!",
+    "result_lose":        "🤖 Bot võitis!",
+    "result_desc":        "Sina: {player_pick} {player_name}\nBot: {bot_pick} {bot_name}\n\n**{result}**{bet_line}",
+    "bet_win":            "\n+{amount} · Saldo: {balance}",
+    "bet_lose":           "\n-{amount} · Saldo: {balance}",
+    "bet_tie":            "\nViik - panus tagasi · Saldo: {balance}",
+    "challenge_desc":     "{challenger} kutsub välja {opponent}{bet}\n\n{opponent}, kas võtad vastu? ⬇️",
+    "challenge_bet":      " · Panus: {bet}",
+    "challenge_footer":   "Väljakutse aegub 60 sekundi pärast",
+    "duel_active_desc":   "{a} vs {b}{bet}\n\nMõlemad mängijad valivad DM-is. ⏳",
+    "duel_active_bet":    " · Panus: {bet}",
+    "duel_dm":            "⚔️ **KPK vs {opponent}**{bet}\nTee oma valik! ⬇️",
+    "duel_dm_bet":        "\nPanus: {bet}",
+    "duel_waiting":       "Valisid {choice} **{name}**. Ootame vastase valikut... ⏳",
+    "duel_result_a":      "**⚔️ KPK tulemus vs {opponent}**\nSinu valik: {pick_a} {name_a}\nVastase valik: {pick_b} {name_b}\n\n**{result}**{bet_line}\nSaldo: {balance}",
+    "duel_verdict_win":   "🏆 **{name}** võitis!",
+    "duel_verdict_tie":   "🤝 Viik!",
+    "duel_broke":         "\n⚠️ Makse ebaõnnestus (ebapiisav saldo)",
+    "duel_expire_dm":     "⏰ KPK duell aegus - keegi ei teinud valikut õigeaegselt.",
+    "duel_expire_desc":   "{a} vs {b}\n\nMäng aegus - valik jäi tegemata.",
+    "duel_dm_fail":       "Ei saanud DM saata: **{names}**. Kontrolli privaatsussätteid.",
+    "duel_decline":       "**{name}** keeldus väljakutsest.",
+    "duel_no_answer":     "**{name}** ei vastanud väljakutsele.",
+    "duel_insufficient":  "{mention}-l pole piisavalt TipiCOINi panuseks.",
+    "duel_done_desc":     "{a} {pick_a} vs {pick_b} {b}\n\n**{verdict}**\n\n{name_a}: {bal_a}\n{name_b}: {bal_b}",
+    "server_only":        "Seda käsku saab kasutada ainult serveris.",
+    "btn_accept":         "Võta vastu ✅",
+    "btn_decline":        "Keeldu ❌",
+    "btn_rock":           "🪨 Kivi",
+    "btn_paper":          "📄 Paber",
+    "btn_scissors":       "✂️ Käärid",
+}
+RPS_CHOICES: dict[str, str] = {
+    "🪨": "Kivi",
+    "📄": "Paber",
+    "✂️": "Käärid",
+}
+BJ_UI: dict[str, str] = {
+    "dealer":       "Dealer",
+    "player":       "Sina",
+    "hand_n":       "Käsi {n}",
+    "hand_active":  "▶ **Käsi {n}**",
+    "hand_pending": "Käsi {n} *...*",
+    "bust":         " 💥",
+    "balance_line": "  ·  Saldo: {balance}",
+}

strings/member.py

@@ -0,0 +1,119 @@
+"""Member sync, /check, birthdays, channel + economy-setup admin UI.
+
+Auto-split from the original strings.py; edit strings here.
+"""
+
+__all__ = [
+    'MEMBER_UI',
+    'MEMBER_FIELDS',
+    'ECONOMYSETUP_UI',
+    'CHANNEL_UI',
+    'BIRTHDAY_UI',
+    'BIRTHDAY_MONTHS',
+    'CHECK_UI',
+    'TEAMSYNC_UI',
+]
+
+# ---------------------------------------------------------------------------
+# /allowchannel  /denychannel  /channels  UI strings
+# ---------------------------------------------------------------------------
+
+MEMBER_UI: dict[str, str] = {
+    "title":                "👤 {name}",
+    "age_field":            "Vanus",
+    "age_val":              "{age}a",
+}
+MEMBER_FIELDS: list[tuple[str, str]] = [
+    ("Nimi",              "Nimi"),
+    ("Organisatsioon",    "Organisatsioon"),
+    ("Valdkond",          "Valdkond"),
+    ("Roll",              "Roll"),
+    ("Sünnipäev",         "Sünnipäev"),
+    ("Meil",              "Meil"),
+    ("Telefon",           "Telefon"),
+    ("Discord",           "Discord"),
+    ("User ID",           "Kasutaja ID"),
+    ("Discordis synced?", "Sünkroniseeritud"),
+    ("Groupi lisatud?",   "Grupis"),
+]
+ECONOMYSETUP_UI: dict[str, str] = {
+    "created_field":  "✅ Loodud",
+    "existing_field": "♻️ Juba olemas",
+    "footer":         "Rollid on nüüd boti rolli all õiges järjekorras.",
+}
+CHANNEL_UI: dict[str, str] = {
+    "already_allowed":  "ℹ️ {channel} on juba lubatud kanalite nimekirjas.",
+    "added":            "✅ {channel} lisatud. Bot vastab käskudele nüüd ainult lubatud kanalites.",
+    "not_in_list":      "ℹ️ {channel} pole lubatud kanalite nimekirjas.",
+    "removed":          "✅ {channel} eemaldatud lubatud kanalite nimekirjast.",
+    "removed_last":     "✅ {channel} eemaldatud. Lubatud kanalite nimekiri on nüüd tühi - bot vastab kõikides kanalites.",
+    "list_title":       "📋 Lubatud kanalid",
+    "list_empty":       "Lubatud kanalite nimekiri on **tühi** - bot vastab käskudele kõikides kanalites.\n\nKasuta `/allowchannel`, et piirata kindlatele kanalitele.",
+    "list_filled":      "Bot vastab käskudele ainult nendes kanalites:\n\n{lines}\n\n-# Kasuta `/allowchannel` / `/denychannel` nimekirja muutmiseks.",
+}
+
+# ---------------------------------------------------------------------------
+# /birthdays  UI
+# ---------------------------------------------------------------------------
+
+BIRTHDAY_UI: dict[str, str] = {
+    "no_entries": "Sellel kuul sünnipäevi ei ole.",
+    "today":      "täna 🎉",
+    "tomorrow":   "homme",
+    "in_days":    "{days}p pärast",
+    "footer":     "Leht {month}/12  ·  {month_name}",
+}
+BIRTHDAY_MONTHS: list[str] = [
+    "Jaanuar", "Veebruar", "Märts", "Aprill", "Mai", "Juuni",
+    "Juuli", "August", "September", "Oktoober", "November", "Detsember",
+]
+
+# ---------------------------------------------------------------------------
+# /check  summary strings
+# ---------------------------------------------------------------------------
+
+CHECK_UI: dict[str, str] = {
+    "sheet_stats_header": "📊 **Tabeli statistika** - {total} liiget",
+    "stat_ok":            "✅ **{label}**: kõik täidetud",
+    "stat_warn":          "⚠️ **{label}** puudub ({count}): {names}{more}",
+    "stat_more":          " (+{count} veel)",
+    "stat_uid":           "Kasutaja ID",
+    "stat_discord":       "Discordi kasutajanimi",
+    "stat_bday":          "Sünnipäev",
+    "no_name":            "(no name)",
+    "done":           "**Kontroll lõpetatud!**",
+    "already_ok":     "✅ Juba korras: {count}",
+    "fixed":          "🔧 Parandatud: {count}",
+    "not_found":      "❓ Pole tabelis: {count}",
+    "bday_pings":     "🎂 Sünnipäeva teavitused: {count}",
+    "errors":         "⚠️ Vead: {count}",
+    "details_header": "**Üksikasjad:**",
+    "details_more":   "... ja {count} rohkem",
+    "detail_error":      "⚠️ {error}",
+    "detail_nickname":   "hüüdnimi",
+    "detail_roles_added": "+rollid: {roles}",
+    "detail_changed":    "🔧 **{name}**: {parts}",
+    "ids_filled":     "\n🔑 Täideti **{count}** puuduvat kasutaja ID-d.",
+}
+
+
+# ---------------------------------------------------------------------------
+# /teamsync UI strings (tournament team-role sync from the registration sheet)
+# ---------------------------------------------------------------------------
+
+TEAMSYNC_UI: dict[str, str] = {
+    "disabled":       "⚠️ Tiimide sünkroonimine on välja lülitatud (TEAM_SHEET_ID puudub).",
+    "refresh_error":  "⚠️ Registreerimistabeli laadimine ebaõnnestus: {error}",
+    "done":           "**Tiimide sünkroonimine lõpetatud!**",
+    "scanned":        "👥 Kontrollitud liikmeid: {count}",
+    "assigned":       "✅ Tiimirolle antud: {count}",
+    "removed":        "➖ Tiimirolle eemaldatud: {count}",
+    "created":        "🆕 Loodud uusi tiimirolle: {roles}",
+    "positioned":     "📍 Eraldaja alla paigutatud: {count}",
+    "divider_assigned": "🏷️ Mängurolle (eraldaja) antud: {count}",
+    "divider_removed":  "➖ Mängurolle (eraldaja) eemaldatud: {count}",
+    "errors":         "⚠️ Vead: {count}",
+    "no_changes":     "✨ Kõik tiimirollid olid juba korras.",
+    "changes_header": "**Muudatused:**",
+    "changes_more":   "... ja {count} rohkem",
+}

tests/conftest.py

@@ -0,0 +1,114 @@
+"""Shared fixtures: an in-memory PocketBase stand-in wired into core.economy."""
+
+from __future__ import annotations
+
+import asyncio
+import copy
+import sys
+from pathlib import Path
+
+import pytest
+
+sys.path.insert(0, str(Path(__file__).parent.parent))
+
+from core import economy, pb_client  # noqa: E402
+
+
+class FakePocketBase:
+    """In-memory stand-in for core.pb_client.
+
+    Mimics the behaviours the economy layer depends on:
+    - records are returned as deep copies (like JSON over REST)
+    - "field+" / "field-" body keys are atomic number modifiers
+    - fields not in `schema_fields` are silently dropped, like PocketBase
+      does for fields missing from the collection schema (schema_fields=None
+      keeps everything)
+    """
+
+    def __init__(self, schema_fields: set[str] | None = None):
+        self.records: dict[str, dict] = {}
+        self.schema_fields = schema_fields
+        self._next_id = 0
+
+    def _filter(self, data: dict) -> dict:
+        if self.schema_fields is None:
+            return dict(data)
+        return {k: v for k, v in data.items() if k.rstrip("+-") in self.schema_fields}
+
+    def _apply(self, record: dict, data: dict) -> None:
+        for key, value in self._filter(data).items():
+            if key.endswith("+"):
+                record[key[:-1]] = record.get(key[:-1], 0) + value
+            elif key.endswith("-"):
+                record[key[:-1]] = record.get(key[:-1], 0) - value
+            else:
+                record[key] = value
+
+    async def get_record(self, user_id: str) -> dict | None:
+        await asyncio.sleep(0)  # yield, so unserialized tasks would interleave
+        for record in self.records.values():
+            if record.get("user_id") == user_id:
+                return copy.deepcopy(record)
+        return None
+
+    async def create_record(self, record: dict) -> dict:
+        await asyncio.sleep(0)
+        self._next_id += 1
+        stored = self._filter(record)
+        stored["id"] = f"rec{self._next_id}"
+        stored["user_id"] = record.get("user_id", "")
+        self.records[stored["id"]] = stored
+        return copy.deepcopy(stored)
+
+    async def update_record(self, record_id: str, data: dict) -> dict:
+        await asyncio.sleep(0)
+        record = self.records[record_id]
+        self._apply(record, data)
+        return copy.deepcopy(record)
+
+    async def list_all_records(self, page_size: int = 500) -> list[dict]:
+        await asyncio.sleep(0)
+        return copy.deepcopy(list(self.records.values()))
+
+    async def count_records(self) -> int:
+        return len(self.records)
+
+    async def get_collection_fields(self) -> set[str]:
+        if self.schema_fields is None:
+            return set(economy._default_user()) | {"user_id"}
+        return set(self.schema_fields)
+
+    # -- test helpers -------------------------------------------------------
+    def record_for(self, user_id: int) -> dict:
+        for record in self.records.values():
+            if record.get("user_id") == str(user_id):
+                return record
+        raise KeyError(user_id)
+
+
+def _install(monkeypatch, fake: FakePocketBase) -> FakePocketBase:
+    for name in ("get_record", "create_record", "update_record",
+                 "list_all_records", "count_records", "get_collection_fields"):
+        monkeypatch.setattr(pb_client, name, getattr(fake, name))
+    # live house state is owned by economy.house (the package re-export is a snapshot)
+    monkeypatch.setattr(economy.house, "HOUSE_ID", None)
+    monkeypatch.setattr(economy.house, "_house_pb_id", None)
+    economy._user_locks.clear()
+    return fake
+
+
+@pytest.fixture
+def fake_pb(monkeypatch) -> FakePocketBase:
+    return _install(monkeypatch, FakePocketBase())
+
+
+@pytest.fixture
+def fake_pb_without_quest_fields(monkeypatch) -> FakePocketBase:
+    """A fake whose collection schema predates the quest migration."""
+    schema = set(economy._default_user().keys()) | {"user_id"}
+    schema -= {"quest_daily", "quest_weekly"}
+    return _install(monkeypatch, FakePocketBase(schema_fields=schema))
+
+
+def run(coro):
+    return asyncio.run(coro)

tests/test_consumables.py

@@ -0,0 +1,102 @@
+"""Tests for the consumables shop (repeatable, expiring coin sink)."""
+
+from datetime import datetime, timedelta, timezone
+
+from core import economy
+
+from conftest import run
+
+UID = 4242
+
+
+def _fixed_now(monkeypatch, dt: datetime):
+    # _clock is the time seam shared by every economy submodule
+    monkeypatch.setattr(economy.store, "_clock", lambda: dt)
+    return dt
+
+
+def _fund(fake_pb, amount: int) -> None:
+    run(economy.get_user(UID))
+    fake_pb.record_for(UID)["balance"] = amount
+
+
+class TestBuy:
+    def test_buy_earn_buff_deducts_and_activates(self, fake_pb):
+        _fund(fake_pb, 1000)
+        res = run(economy.do_buy_consumable(UID, "energy_xl"))
+        assert res["ok"] and not res["instant"]
+        assert res["balance"] == 500          # 1000 - 500 cost
+        user = run(economy.get_user(UID))
+        assert economy.earn_mult(user) == 2.0
+        assert economy.exp_buff_mult(user) == 1.0
+
+    def test_insufficient_funds_rejected(self, fake_pb):
+        _fund(fake_pb, 100)
+        res = run(economy.do_buy_consumable(UID, "energy_xl"))
+        assert not res["ok"] and res["reason"] == "insufficient"
+        assert res["need"] == 400
+        assert run(economy.get_user(UID))["balance"] == 100   # unchanged
+
+    def test_banned_rejected(self, fake_pb):
+        _fund(fake_pb, 1000)
+        fake_pb.record_for(UID)["eco_banned"] = True
+        res = run(economy.do_buy_consumable(UID, "energy_xl"))
+        assert not res["ok"] and res["reason"] == "banned"
+
+    def test_unknown_consumable(self, fake_pb):
+        _fund(fake_pb, 1000)
+        res = run(economy.do_buy_consumable(UID, "nope"))
+        assert not res["ok"] and res["reason"] == "not_found"
+
+
+class TestBuffLifecycle:
+    def test_buff_expires(self, fake_pb, monkeypatch):
+        t0 = _fixed_now(monkeypatch, datetime(2026, 8, 19, 12, tzinfo=timezone.utc))
+        _fund(fake_pb, 1000)
+        run(economy.do_buy_consumable(UID, "energy_xl"))
+        assert economy.earn_mult(run(economy.get_user(UID))) == 2.0
+        # 61 minutes later the 60-minute buff is gone
+        _fixed_now(monkeypatch, t0 + timedelta(minutes=61))
+        assert economy.earn_mult(run(economy.get_user(UID))) == 1.0
+
+    def test_rebuy_extends_duration(self, fake_pb, monkeypatch):
+        t0 = _fixed_now(monkeypatch, datetime(2026, 8, 19, 12, tzinfo=timezone.utc))
+        _fund(fake_pb, 2000)
+        run(economy.do_buy_consumable(UID, "energy_xl"))          # expiry = t0 + 60m
+        _fixed_now(monkeypatch, t0 + timedelta(minutes=30))
+        res = run(economy.do_buy_consumable(UID, "energy_xl"))    # extends, not resets
+        assert res["extended"] is True
+        # remaining should be ~90m (30m left + 60m added), not 60m
+        assert res["remaining"] > timedelta(minutes=85)
+
+
+class TestEffects:
+    def test_earn_buff_doubles_work(self, fake_pb, monkeypatch):
+        import random
+        _fixed_now(monkeypatch, datetime(2026, 8, 19, 12, tzinfo=timezone.utc))
+        _fund(fake_pb, 1000)
+        monkeypatch.setattr(random, "randint", lambda a, b: 50)
+        monkeypatch.setattr(random, "choice", lambda seq: seq[0])
+        monkeypatch.setattr(random, "random", lambda: 0.99)   # no energiajook luck
+        base = run(economy.do_work(UID))["earned"]
+        fake_pb.record_for(UID)["last_work"] = None            # clear cooldown
+        run(economy.do_buy_consumable(UID, "energy_xl"))
+        boosted = run(economy.do_work(UID))["earned"]
+        assert boosted == base * 2
+
+    def test_exp_buff_doubles_award(self, fake_pb):
+        _fund(fake_pb, 1000)
+        run(economy.do_buy_consumable(UID, "xp_potion"))
+        res = run(economy.award_exp(UID, 10))
+        assert res["gained"] == 20            # 10 * 2x exp buff
+
+    def test_kohv_clears_cooldowns(self, fake_pb, monkeypatch):
+        t0 = _fixed_now(monkeypatch, datetime(2026, 8, 19, 12, tzinfo=timezone.utc))
+        _fund(fake_pb, 1000)
+        rec = fake_pb.record_for(UID)
+        rec["last_work"] = t0.isoformat()     # on cooldown
+        res = run(economy.do_buy_consumable(UID, "kohv"))
+        assert res["ok"] and res["instant"]
+        user = run(economy.get_user(UID))
+        assert user["last_work"] is None      # cooldown wiped -> /work is ready
+        assert economy.store._cooldown_remaining(user, "work") is None

tests/test_economy_flows.py

@@ -0,0 +1,205 @@
+"""Tests for the async economy flows against the in-memory PocketBase fake."""
+
+import asyncio
+import random
+from datetime import datetime, timedelta, timezone
+
+from core import economy
+
+from conftest import run
+
+UID = 111
+OTHER = 222
+HOUSE = 999
+
+
+def _fixed_now(monkeypatch, dt: datetime):
+    # _clock is the time seam shared by every economy submodule
+    monkeypatch.setattr(economy.store, "_clock", lambda: dt)
+    return dt
+
+
+class TestGetUser:
+    def test_creates_default_record(self, fake_pb):
+        user = run(economy.get_user(UID))
+        assert user["balance"] == 0
+        assert fake_pb.record_for(UID)["user_id"] == str(UID)
+
+    def test_roundtrips_existing_data(self, fake_pb):
+        run(economy.get_user(UID))
+        fake_pb.record_for(UID)["balance"] = 1234
+        assert run(economy.get_user(UID))["balance"] == 1234
+
+
+class TestDaily:
+    def test_first_claim(self, fake_pb):
+        res = run(economy.do_daily(UID))
+        assert res["ok"] and res["streak"] == 1 and res["earned"] == 150
+
+    def test_cooldown_blocks_second_claim(self, fake_pb):
+        run(economy.do_daily(UID))
+        res = run(economy.do_daily(UID))
+        assert not res["ok"] and res["reason"] == "cooldown"
+
+    def test_streak_increments_next_day(self, fake_pb, monkeypatch):
+        t0 = _fixed_now(monkeypatch, datetime(2026, 7, 25, 12, tzinfo=timezone.utc))
+        run(economy.do_daily(UID))
+        _fixed_now(monkeypatch, t0 + timedelta(days=1))
+        res = run(economy.do_daily(UID))
+        assert res["ok"] and res["streak"] == 2
+
+    def test_streak_resets_after_missed_day(self, fake_pb, monkeypatch):
+        t0 = _fixed_now(monkeypatch, datetime(2026, 7, 25, 12, tzinfo=timezone.utc))
+        run(economy.do_daily(UID))
+        _fixed_now(monkeypatch, t0 + timedelta(days=3))
+        res = run(economy.do_daily(UID))
+        assert res["ok"] and res["streak"] == 1
+
+    def test_karikas_preserves_streak(self, fake_pb, monkeypatch):
+        t0 = _fixed_now(monkeypatch, datetime(2026, 7, 25, 12, tzinfo=timezone.utc))
+        run(economy.do_daily(UID))
+        fake_pb.record_for(UID)["items"] = ["karikas"]
+        fake_pb.record_for(UID)["daily_streak"] = 5
+        _fixed_now(monkeypatch, t0 + timedelta(days=3))
+        res = run(economy.do_daily(UID))
+        assert res["ok"] and res["streak"] == 5
+
+    def test_streak_multiplier_tiers(self, fake_pb, monkeypatch):
+        t0 = _fixed_now(monkeypatch, datetime(2026, 7, 25, 12, tzinfo=timezone.utc))
+        run(economy.get_user(UID))
+        rec = fake_pb.record_for(UID)
+        rec["daily_streak"] = 13
+        rec["last_streak_date"] = (t0.date() - timedelta(days=1)).isoformat()
+        res = run(economy.do_daily(UID))
+        assert res["streak"] == 14 and res["streak_mult"] == 3.0 and res["earned"] == 450
+
+
+class TestBuy:
+    def test_insufficient_funds(self, fake_pb):
+        res = run(economy.do_buy(UID, "gaming_hiir"))
+        assert not res["ok"] and res["reason"] == "insufficient"
+
+    def test_purchase_and_rebuy_blocked(self, fake_pb):
+        run(economy.get_user(UID))
+        fake_pb.record_for(UID)["balance"] = 1000
+        res = run(economy.do_buy(UID, "gaming_hiir"))
+        assert res["ok"] and res["balance"] == 500
+        assert "gaming_hiir" in fake_pb.record_for(UID)["items"]
+        res = run(economy.do_buy(UID, "gaming_hiir"))
+        assert not res["ok"] and res["reason"] == "owned"
+
+    def test_tier2_requires_level(self, fake_pb):
+        run(economy.get_user(UID))
+        fake_pb.record_for(UID)["balance"] = 100_000
+        res = run(economy.do_buy(UID, "jellyfin"))
+        assert not res["ok"] and res["reason"] == "level_required"
+        fake_pb.record_for(UID)["exp"] = economy.exp_for_level(10)
+        assert run(economy.do_buy(UID, "jellyfin"))["ok"]
+
+    def test_anticheat_repurchase_after_depletion(self, fake_pb):
+        run(economy.get_user(UID))
+        rec = fake_pb.record_for(UID)
+        rec["balance"] = 10_000
+        assert run(economy.do_buy(UID, "anticheat"))["ok"]
+        assert fake_pb.record_for(UID)["item_uses"]["anticheat"] == 2
+        fake_pb.record_for(UID)["item_uses"]["anticheat"] = 0
+        assert run(economy.do_buy(UID, "anticheat"))["ok"]
+        assert fake_pb.record_for(UID)["item_uses"]["anticheat"] == 2
+
+
+class TestGive:
+    def test_transfer(self, fake_pb):
+        run(economy.get_user(UID))
+        fake_pb.record_for(UID)["balance"] = 500
+        res = run(economy.do_give(UID, OTHER, 200))
+        assert res["ok"]
+        assert fake_pb.record_for(UID)["balance"] == 300
+        assert fake_pb.record_for(OTHER)["balance"] == 200
+
+    def test_insufficient(self, fake_pb):
+        res = run(economy.do_give(UID, OTHER, 50))
+        assert not res["ok"] and res["reason"] == "insufficient"
+
+    def test_opposite_transfers_do_not_deadlock(self, fake_pb):
+        async def both():
+            for uid in (UID, OTHER):
+                await economy.get_user(uid)
+                fake_pb.record_for(uid)["balance"] = 100
+            await asyncio.wait_for(
+                asyncio.gather(
+                    economy.do_give(UID, OTHER, 10),
+                    economy.do_give(OTHER, UID, 25),
+                ),
+                timeout=5,
+            )
+        run(both())
+        total = fake_pb.record_for(UID)["balance"] + fake_pb.record_for(OTHER)["balance"]
+        assert total == 200
+
+
+class TestRob:
+    def test_anticheat_blocks_and_depletes(self, fake_pb):
+        run(economy.get_user(UID))
+        run(economy.get_user(OTHER))
+        economy.set_house(HOUSE)
+        fake_pb.record_for(UID)["balance"] = 1000
+        target = fake_pb.record_for(OTHER)
+        target["balance"] = 1000
+        target["items"] = ["anticheat"]
+        target["item_uses"] = {"anticheat": 1}
+        res = run(economy.do_rob(UID, OTHER))
+        assert res["ok"] and not res["success"] and res["reason"] == "valvur"
+        assert fake_pb.record_for(UID)["balance"] == 1000 - res["fine"]
+        assert "anticheat" not in fake_pb.record_for(OTHER)["items"]
+        # the fine flows to the house
+        assert fake_pb.record_for(HOUSE)["balance"] == res["fine"]
+
+
+class TestGambling:
+    def test_roulette_conserves_money_with_house(self, fake_pb):
+        economy.set_house(HOUSE)
+        run(economy.get_user(UID))
+        fake_pb.record_for(UID)["balance"] = 1000
+        random.seed(3)
+        res = run(economy.do_roulette(UID, 100, "punane"))
+        assert res["ok"]
+        user_bal = fake_pb.record_for(UID)["balance"]
+        if res["won"]:
+            assert user_bal == 1000 + res["change"]
+        else:
+            assert user_bal == 900
+            assert fake_pb.record_for(HOUSE)["balance"] == 100
+
+    def test_bet_larger_than_balance_rejected(self, fake_pb):
+        res = run(economy.do_slots(UID, 50))
+        assert not res["ok"] and res["reason"] == "insufficient"
+
+    def test_blackjack_bet_and_payout(self, fake_pb):
+        economy.set_house(HOUSE)
+        run(economy.get_user(UID))
+        fake_pb.record_for(UID)["balance"] = 500
+        assert run(economy.do_blackjack_bet(UID, 100))["ok"]
+        assert fake_pb.record_for(UID)["balance"] == 400
+        # player loses: payout 0 of 100 invested -> house gains the bet
+        run(economy.do_blackjack_payout(UID, 0, total_invested=100))
+        assert fake_pb.record_for(UID)["balance"] == 400
+        assert fake_pb.record_for(HOUSE)["balance"] == 100
+
+
+class TestConcurrency:
+    """The per-user locks must serialize read-modify-write cycles."""
+
+    def test_concurrent_exp_awards_are_not_lost(self, fake_pb):
+        async def hammer():
+            await asyncio.gather(*(economy.award_exp(UID, 10) for _ in range(25)))
+        run(hammer())
+        assert fake_pb.record_for(UID)["exp"] == 250
+
+    def test_concurrent_credit_house_is_atomic(self, fake_pb):
+        economy.set_house(HOUSE)
+
+        async def hammer():
+            await economy.get_user(HOUSE)
+            await asyncio.gather(*(economy._credit_house(7) for _ in range(30)))
+        run(hammer())
+        assert fake_pb.record_for(HOUSE)["balance"] == 210

tests/test_economy_pure.py

@@ -0,0 +1,86 @@
+"""Tests for the pure (no-database) economy math."""
+
+import random
+from datetime import timedelta
+
+from core import economy
+
+
+class TestLevels:
+    def test_milestones(self):
+        assert economy.get_level(0) == 1
+        assert economy.get_level(249) == 4
+        assert economy.get_level(250) == 5
+        assert economy.get_level(1000) == 10
+        assert economy.get_level(4000) == 20
+        assert economy.get_level(9000) == 30
+
+    def test_exp_for_level_is_inverse(self):
+        for level in range(1, 41):
+            exp = economy.exp_for_level(level)
+            assert economy.get_level(exp) == level
+            if level > 1:
+                assert economy.get_level(exp - 1) == level - 1
+
+    def test_negative_exp_clamps_to_level_1(self):
+        assert economy.get_level(-500) == 1
+
+    def test_role_names(self):
+        assert economy.level_role_name(1) == "TipiNOOB"
+        assert economy.level_role_name(4) == "TipiNOOB"
+        assert economy.level_role_name(5) == "TipiGRINDER"
+        assert economy.level_role_name(10) == "TipiHUSTLER"
+        assert economy.level_role_name(20) == "TipiCHAD"
+        assert economy.level_role_name(30) == "TipiLEGEND"
+        assert economy.level_role_name(99) == "TipiLEGEND"
+
+
+class TestGambleExp:
+    def test_tiers(self):
+        assert economy.gamble_exp(0) == 0
+        assert economy.gamble_exp(9) == 0
+        assert economy.gamble_exp(10) == 5
+        assert economy.gamble_exp(99) == 5
+        assert economy.gamble_exp(100) == 10
+        assert economy.gamble_exp(999) == 10
+        assert economy.gamble_exp(1_000) == 15
+        assert economy.gamble_exp(9_999) == 15
+        assert economy.gamble_exp(10_000) == 20
+        assert economy.gamble_exp(99_999) == 20
+        assert economy.gamble_exp(100_000) == 25
+
+    def test_cap(self):
+        assert economy.gamble_exp(10_000_000) == 25
+
+
+class TestFormatTd:
+    def test_hours(self):
+        assert economy.format_td(timedelta(hours=1, minutes=23, seconds=45)) == "1t 23m"
+
+    def test_minutes(self):
+        assert economy.format_td(timedelta(minutes=45, seconds=12)) == "45m 12s"
+
+    def test_seconds(self):
+        assert economy.format_td(timedelta(seconds=8)) == "8s"
+
+
+class TestRollFish:
+    def test_rolls_are_valid(self):
+        random.seed(42)
+        for _ in range(500):
+            fish_id, weight = economy.roll_fish()
+            if fish_id == "junk":
+                assert weight == 0
+            else:
+                fish = economy.FISH_CATALOGUE[fish_id]
+                assert fish["weight"][0] <= weight <= fish["weight"][1]
+
+    def test_rarity_bump_shifts_every_catch_up_a_tier(self):
+        random.seed(7)
+        rarities = {
+            economy.FISH_CATALOGUE[fid]["rarity"]
+            for fid, _ in (economy.roll_fish(rarity_bump=True) for _ in range(1000))
+            if fid != "junk"
+        }
+        assert "common" not in rarities
+        assert "legendary" in rarities

tests/test_fienta.py

@@ -0,0 +1,101 @@
+"""Tests for the Fienta ticket parsing that feeds team-role sync.
+
+Covers the risky bit: turning raw Fienta ticket JSON into a reliable
+{discord identity -> team} + {team -> game} mapping, including which ticket
+types count as team members and how the game is detected.
+"""
+
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).parent.parent))
+
+import config  # noqa: E402
+from core import fienta  # noqa: E402
+
+
+def _ticket(ttype: str, *, team="", discord="", discord_id="", nick=""):
+    return {
+        "order_id": 1,
+        "rows": [{
+            "ticket_type": {"title": ttype},
+            "attendee": {
+                fienta._F_TEAM_NAME: team,
+                fienta._F_DISCORD_USERNAME: discord,
+                fienta._F_DISCORD_USERID: discord_id,
+                fienta._F_DISCORD_USERNAME.replace("discord", "x"): "",
+                "nickname_134815": nick,
+            },
+        }],
+    }
+
+
+CS2 = "Counter-Strike 2 Tournament - competitor ticket"
+LOL = "League of Legends Tournament - competitor ticket"
+
+
+def test_parse_maps_username_and_userid_to_team():
+    fienta.parse_tickets([
+        _ticket(CS2, team="KONE", discord="ar7enchik", discord_id="123"),
+    ])
+    assert fienta.get_team_for_username("ar7enchik") == "KONE"
+    assert fienta.get_team_for_username("AR7ENCHIK") == "KONE"  # case-insensitive
+    assert fienta.get_team_for_userid(123) == "KONE"
+    assert fienta.get_team_game("KONE") == "CS2"
+
+
+def test_parse_detects_game_from_ticket_type():
+    fienta.parse_tickets([
+        _ticket(CS2, team="KONE", discord="a"),
+        _ticket(LOL, team="Ööbik", discord="b"),
+    ])
+    assert fienta.get_team_game("KONE") == "CS2"
+    assert fienta.get_team_game("Ööbik") == "LoL"
+
+
+def test_parse_excludes_non_player_ticket_types():
+    fienta.parse_tickets([
+        _ticket("Visitor's Ticket", team="", discord=""),
+        _ticket("Early Bird - visitor ticket", team="X", discord="ghost"),
+        _ticket("Counter-Strike 2 Tournament Waiting List", team="WL", discord="waiter"),
+        _ticket("LAN area - Access Ticket", team="", discord=""),
+        _ticket(CS2, team="KONE", discord="real"),
+    ])
+    assert fienta.all_team_names() == {"KONE"}
+    assert fienta.get_team_for_username("ghost") is None
+    assert fienta.get_team_for_username("waiter") is None
+    assert fienta.get_team_for_username("real") == "KONE"
+
+
+def test_parse_includes_coach_and_substitute():
+    fienta.parse_tickets([
+        _ticket("Counter-Strike 2 Coach/Manager - competitor ticket", team="KONE", discord="coach"),
+        _ticket("CS2 Substitute Player - competitor ticket", team="KONE", discord="sub"),
+    ])
+    assert fienta.get_team_for_username("coach") == "KONE"
+    assert fienta.get_team_for_username("sub") == "KONE"
+
+
+def test_parse_skips_tickets_without_team_or_discord():
+    fienta.parse_tickets([
+        _ticket(CS2, team="", discord="noteam"),     # no team -> skipped
+        _ticket(CS2, team="KONE", discord=""),        # team but no discord -> team known, no user
+    ])
+    assert fienta.get_team_for_username("noteam") is None
+    assert "KONE" in fienta.all_team_names()
+
+
+def test_get_team_dividers_maps_via_game(monkeypatch):
+    monkeypatch.setattr(config, "TEAM_DIVIDERS", {"cs2_2026": 100, "lol_2026": 200})
+    fienta.parse_tickets([
+        _ticket(CS2, team="KONE", discord="a"),
+        _ticket(LOL, team="Ööbik", discord="b"),
+    ])
+    assert fienta.get_team_dividers() == {"KONE": 100, "Ööbik": 200}
+
+
+def test_strips_leading_at_from_discord_username():
+    fienta.parse_tickets([_ticket(CS2, team="KONE", discord="@handle")])
+    assert fienta.get_team_for_username("handle") == "KONE"

tests/test_money_safety_fixes.py

@@ -0,0 +1,91 @@
+"""Regression tests for the money-safety audit fixes.
+
+Covers the two pure-logic fixes:
+- heist payout conserves coins (no minting when the house is poor) and the win
+  path no longer crashes on the shadowed `house` local.
+- do_bail is idempotent: a jailed user can only be charged once per sentence, so
+  a double-click or a stale BailView cannot destroy coins with a second fine.
+"""
+
+from datetime import datetime, timedelta, timezone
+
+from core import economy
+
+from conftest import run
+
+UID = 111
+OTHER = 222
+HOUSE = 999
+
+
+def _fixed_now(monkeypatch, dt: datetime):
+    monkeypatch.setattr(economy.store, "_clock", lambda: dt)
+    return dt
+
+
+class TestHeistConservation:
+    def _setup_house(self, fake_pb, monkeypatch, balance: int):
+        monkeypatch.setattr(economy.house, "HOUSE_ID", HOUSE)
+        monkeypatch.setattr(economy.house, "_house_pb_id", None)
+        run(economy.get_user(HOUSE))
+        fake_pb.record_for(HOUSE)["balance"] = balance
+
+    def test_poor_house_win_does_not_mint(self, fake_pb, monkeypatch):
+        # Poor house is the case the pre-fix code minted from: the desired pot
+        # (floored at 300) exceeded the balance, so payouts outran the debit.
+        self._setup_house(fake_pb, monkeypatch, balance=100)
+        run(economy.get_user(UID))
+        run(economy.get_user(OTHER))
+
+        house_before = fake_pb.record_for(HOUSE)["balance"]
+        res = run(economy.do_heist_resolve([UID, OTHER], True))  # must not raise
+        assert res["ok"] and res["success"]
+
+        house_after = fake_pb.record_for(HOUSE)["balance"]
+        gains = fake_pb.record_for(UID)["balance"] + fake_pb.record_for(OTHER)["balance"]
+        # Coin conservation: the house loses exactly what the players gain.
+        assert house_before - house_after == gains
+        assert house_after >= 0
+        assert res["payout_each"] * 2 == gains
+
+    def test_rich_house_win_pays_out_and_conserves(self, fake_pb, monkeypatch):
+        self._setup_house(fake_pb, monkeypatch, balance=100_000)
+        run(economy.get_user(UID))
+        run(economy.get_user(OTHER))
+
+        house_before = fake_pb.record_for(HOUSE)["balance"]
+        res = run(economy.do_heist_resolve([UID, OTHER], True))
+        assert res["ok"] and res["payout_each"] > 0
+
+        house_after = fake_pb.record_for(HOUSE)["balance"]
+        gains = fake_pb.record_for(UID)["balance"] + fake_pb.record_for(OTHER)["balance"]
+        assert house_before - house_after == gains
+
+
+class TestBailIdempotency:
+    def _jail(self, fake_pb, now, balance: int):
+        run(economy.get_user(UID))
+        rec = fake_pb.record_for(UID)
+        rec["balance"] = balance
+        rec["jailed_until"] = (now + timedelta(minutes=30)).isoformat()
+
+    def test_second_bail_when_free_is_noop(self, fake_pb, monkeypatch):
+        now = _fixed_now(monkeypatch, datetime(2026, 7, 25, 12, tzinfo=timezone.utc))
+        self._jail(fake_pb, now, balance=1000)
+
+        first = run(economy.do_bail(UID))
+        assert first["ok"]
+        bal_after_first = fake_pb.record_for(UID)["balance"]
+        assert bal_after_first < 1000  # a fine was charged
+        assert fake_pb.record_for(UID)["jailed_until"] is None  # freed
+
+        # A double-click / stale view fires do_bail again while already free.
+        second = run(economy.do_bail(UID))
+        assert not second["ok"] and second["reason"] == "not_jailed"
+        assert fake_pb.record_for(UID)["balance"] == bal_after_first  # no second charge
+
+    def test_bail_charges_once_for_a_real_sentence(self, fake_pb, monkeypatch):
+        now = _fixed_now(monkeypatch, datetime(2026, 7, 25, 12, tzinfo=timezone.utc))
+        self._jail(fake_pb, now, balance=1000)
+        res = run(economy.do_bail(UID))
+        assert res["ok"] and res["fine"] >= economy.MIN_BAIL

tests/test_quests.py

@@ -0,0 +1,122 @@
+"""Tests for the quest system: rotation, progress, claiming, schema detection."""
+
+import logging
+from datetime import datetime, timedelta, timezone
+
+from core import economy
+
+from conftest import run
+
+UID = 111
+
+
+def _fixed_now(monkeypatch, dt: datetime):
+    monkeypatch.setattr(economy.store, "_clock", lambda: dt)
+    return dt
+
+
+def _complete_all_active_quests(fake_pb, user_id: int) -> tuple[int, int]:
+    """Push every active quest's tracked counter past its goal directly in the
+    store. Returns (expected_coins, expected_exp)."""
+    rec = fake_pb.record_for(user_id)
+    coins = exp = 0
+    for pool, block in (
+        (economy.QUESTS_DAILY, rec["quest_daily"]),
+        (economy.QUESTS_WEEKLY, rec["quest_weekly"]),
+    ):
+        for qid, state in block["quests"].items():
+            stat = pool[qid]["stat"]
+            rec[stat] = state["snap"] + pool[qid]["goal"]
+            coins += pool[qid]["coins"]
+            exp += pool[qid]["exp"]
+    return coins, exp
+
+
+class TestRotation:
+    def test_deterministic_per_seed(self):
+        a = economy._pick_quests(economy.QUESTS_DAILY, 3, "1:date:2026-07-26")
+        b = economy._pick_quests(economy.QUESTS_DAILY, 3, "1:date:2026-07-26")
+        assert a == b
+
+    def test_users_get_different_sets(self):
+        sets = {
+            tuple(economy._pick_quests(economy.QUESTS_DAILY, 3, f"{uid}:date:2026-07-26"))
+            for uid in range(50)
+        }
+        assert len(sets) > 1
+
+    def test_counts(self, fake_pb):
+        data = run(economy.get_quests(UID))
+        assert len(data["daily"]) == economy.DAILY_QUEST_COUNT
+        assert len(data["weekly"]) == economy.WEEKLY_QUEST_COUNT
+
+    def test_daily_rolls_over_weekly_stays(self, fake_pb, monkeypatch):
+        # a Tuesday, so day+1 stays inside the same ISO week
+        t0 = _fixed_now(monkeypatch, datetime(2026, 7, 21, 12, tzinfo=timezone.utc))
+        run(economy.get_quests(UID))
+        rec = fake_pb.record_for(UID)
+        daily_before, weekly_before = dict(rec["quest_daily"]), dict(rec["quest_weekly"])
+        _fixed_now(monkeypatch, t0 + timedelta(days=1))
+        run(economy.get_quests(UID))
+        rec = fake_pb.record_for(UID)
+        assert rec["quest_daily"]["date"] != daily_before["date"]
+        assert rec["quest_weekly"] == weekly_before
+
+
+class TestProgress:
+    def test_progress_tracks_counter_delta(self, fake_pb):
+        run(economy.get_quests(UID))
+        rec = fake_pb.record_for(UID)
+        qid, state = next(iter(rec["quest_daily"]["quests"].items()))
+        stat = economy.QUESTS_DAILY[qid]["stat"]
+        rec[stat] = state["snap"] + 1
+        data = run(economy.get_quests(UID))
+        quest = next(q for q in data["daily"] if q["id"] == qid)
+        assert quest["progress"] == 1
+
+    def test_pre_roll_stats_do_not_count(self, fake_pb):
+        run(economy.get_user(UID))
+        fake_pb.record_for(UID)["work_count"] = 500
+        data = run(economy.get_quests(UID))
+        assert all(q["progress"] == 0 for q in data["daily"] + data["weekly"])
+
+
+class TestClaim:
+    def test_claim_pays_and_is_idempotent(self, fake_pb):
+        run(economy.get_quests(UID))
+        coins, exp = _complete_all_active_quests(fake_pb, UID)
+        res = run(economy.claim_quests(UID))
+        assert res["ok"]
+        assert res["claimed"] == economy.DAILY_QUEST_COUNT + economy.WEEKLY_QUEST_COUNT
+        assert res["coins"] == coins and res["exp"] == exp
+        assert fake_pb.record_for(UID)["balance"] == coins
+        res = run(economy.claim_quests(UID))
+        assert not res["ok"] and res["reason"] == "nothing"
+
+    def test_claim_with_nothing_done(self, fake_pb):
+        run(economy.get_quests(UID))
+        res = run(economy.claim_quests(UID))
+        assert not res["ok"]
+
+
+class TestSchemaDetection:
+    def test_missing_fields_reported(self, fake_pb_without_quest_fields):
+        assert run(economy.missing_schema_fields()) == ["quest_daily", "quest_weekly"]
+
+    def test_healthy_schema_reports_nothing(self, fake_pb):
+        assert run(economy.missing_schema_fields()) == []
+
+    def test_missing_quest_fields_warn_and_zero_progress(
+        self, fake_pb_without_quest_fields, caplog
+    ):
+        """Reproduces the live 'quests never progress' symptom: when the
+        collection schema lacks quest_daily/quest_weekly, PocketBase drops the
+        rolled quest block, so every call re-rolls with a fresh snapshot."""
+        fake = fake_pb_without_quest_fields
+        with caplog.at_level(logging.WARNING):
+            run(economy.get_quests(UID))
+        assert any("quest fields" in r.message for r in caplog.records)
+        # counters advance, but progress stays 0 because the snapshot re-rolls
+        fake.record_for(UID)["work_count"] = 500
+        data = run(economy.get_quests(UID))
+        assert all(q["progress"] == 0 for q in data["daily"] + data["weekly"])

tests/test_strings.py

@@ -0,0 +1,77 @@
+"""Guard tests for the strings/ package.
+
+strings/ is split into domain submodules whose names are re-exported from
+strings/__init__.py so callers keep using `strings.NAME`. It's easy to add a
+constant to a submodule and forget to re-export it (or to shadow a name across
+two submodules) - both would only surface as a runtime crash in a command.
+These tests catch that at test time instead.
+"""
+
+import importlib
+import pkgutil
+
+import strings
+
+# Auto-discover submodules so a newly added one is covered without editing this.
+SUBMODULES = sorted(m.name for m in pkgutil.iter_modules(strings.__path__))
+
+
+def _submodule(name):
+    return importlib.import_module(f"strings.{name}")
+
+
+class TestStringsPackage:
+    def test_submodules_discovered(self):
+        # Sanity: the split actually produced multiple domain modules.
+        assert len(SUBMODULES) >= 2, SUBMODULES
+
+    def test_every_submodule_declares_all(self):
+        for name in SUBMODULES:
+            mod = _submodule(name)
+            assert hasattr(mod, "__all__"), f"strings.{name} is missing __all__"
+
+    def test_all_entries_exist_in_their_submodule(self):
+        for name in SUBMODULES:
+            mod = _submodule(name)
+            for const in mod.__all__:
+                assert hasattr(mod, const), (
+                    f"{const} is listed in strings.{name}.__all__ "
+                    f"but not defined in that module"
+                )
+
+    def test_every_name_is_reexported_from_package(self):
+        for name in SUBMODULES:
+            mod = _submodule(name)
+            for const in mod.__all__:
+                assert hasattr(strings, const), (
+                    f"{const} is defined in strings.{name} but not re-exported "
+                    f"from strings/__init__.py - add it to the imports there"
+                )
+                assert getattr(strings, const) is getattr(mod, const), (
+                    f"strings.{const} is not the same object as strings.{name}.{const}"
+                )
+
+    def test_no_name_defined_in_two_submodules(self):
+        origin = {}
+        for name in SUBMODULES:
+            for const in _submodule(name).__all__:
+                assert const not in origin, (
+                    f"{const} is defined in both strings.{origin[const]} "
+                    f"and strings.{name}"
+                )
+                origin[const] = name
+
+    def test_package_all_matches_submodule_union(self):
+        union = set()
+        for name in SUBMODULES:
+            union |= set(_submodule(name).__all__)
+        assert set(strings.__all__) == union, {
+            "missing_from_package_all": sorted(union - set(strings.__all__)),
+            "extra_in_package_all": sorted(set(strings.__all__) - union),
+        }
+
+    def test_public_constants_all_declared(self):
+        # Every UPPER_CASE constant exposed on the package is accounted for in
+        # __all__ (E, the emoji helper, is an implementation detail, not a string).
+        public = {n for n in vars(strings) if n.isupper() and n != "E"}
+        assert public == set(strings.__all__)

tests/test_team_sync.py

@@ -0,0 +1,383 @@
+"""Tests for team-role sync from the tournament registration sheet.
+
+Covers the risky parsing (turning a messy, multi-section, merged-cell sheet
+into {team: [discord usernames]}) and the roster-independent add/remove/
+auto-create behaviour of sync_team_role, using lightweight fakes for discord
++ the sheets cache.
+"""
+
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).parent.parent))
+
+import config  # noqa: E402
+from core import member_sync, sheets  # noqa: E402
+from tests.conftest import run  # noqa: E402
+
+
+# --- parse_lineup ----------------------------------------------------------
+
+def test_parse_lineup_strips_citizenship_and_splits():
+    cell = "TFT (EST), nqmm (EST), sn1rk (EST), Kevka (EST), Kalatexx (EST)"
+    assert sheets.parse_lineup(cell) == ["TFT", "nqmm", "sn1rk", "Kevka", "Kalatexx"]
+
+
+def test_parse_lineup_keeps_names_containing_commas_and_semicolons():
+    # A single player's descriptive name contains a ';' - must stay one name.
+    cell = "Onu Klaus ; vahepeal ka mõni teine tegelane (EST), Lurban (EST)"
+    assert sheets.parse_lineup(cell) == [
+        "Onu Klaus ; vahepeal ka mõni teine tegelane",
+        "Lurban",
+    ]
+
+
+def test_parse_lineup_handles_odd_usernames():
+    cell = "-acc +vac (EST), m (EST), M1X3RRRRRR (EST)"
+    assert sheets.parse_lineup(cell) == ["-acc +vac", "m", "M1X3RRRRRR"]
+
+
+def test_parse_lineup_mixed_citizenship():
+    cell = "imp (LAT), milteg (EST), Freesies (EST)"
+    assert sheets.parse_lineup(cell) == ["imp", "milteg", "Freesies"]
+
+
+def test_parse_lineup_empty():
+    assert sheets.parse_lineup("") == []
+    assert sheets.parse_lineup("   ") == []
+
+
+def test_parse_lineup_fallback_without_citizenship():
+    assert sheets.parse_lineup("alice, bob") == ["alice", "bob"]
+
+
+# --- parse_team_rosters (multi-section sheet) ------------------------------
+
+# Mirrors the real sheet: merged title rows, a header row, team rows, a blank
+# separator, then a SECOND section with a different column count.
+SHEET_ROWS = [
+    ["", "", "", "", "", "", ""],
+    ["name", "members", "vrs ranking", "registration_date", "game", "", ""],
+    ["[merged] TipiLAN 2026 CS2 Registration Log"] + [""] * 6,
+    ["No", "Team Name", "Lineup (nickname, citizenship)", "VRS Ranking",
+     "Registration Timestamp", "Status", "Participation confirmed?"],
+    ["1", "Piirivalvurid", "TFT (EST), nqmm (EST)", "N/A", "01.05.2026 15:07", "Confirmed", "Yes"],
+    ["2", "GENESIS", "kapa (EST), neaQ (EST)", "N/A", "01.05.2026 15:24", "Confirmed", "Yes"],
+    ["", "", "", "", "", "", ""],
+    ["[merged] TipiLAN 2026 LoL Registration Log"] + [""] * 4,
+    ["No", "Team Name", "Lineup (nickname, citizenship)",
+     "Registration Timestamp (dd.mm.yyyy hh:mm)", "Confirmation  Status"],
+    ["1", "Pushing 30s", "Onu Klaus (EST), Lurban (EST)", "01.05.2026 21:40", ""],
+    ["", "", "", "", ""],
+]
+
+
+def test_parse_team_rosters_multiple_sections():
+    rosters = sheets.parse_team_rosters(SHEET_ROWS)
+    assert rosters == {
+        "Piirivalvurid": ["TFT", "nqmm"],
+        "GENESIS": ["kapa", "neaQ"],
+        "Pushing 30s": ["Onu Klaus", "Lurban"],
+    }
+
+
+def test_parse_team_rosters_ignores_non_table_content():
+    # No header row anywhere -> nothing extracted, no crash.
+    assert sheets.parse_team_rosters([["just", "some", "prose"], ["more"]]) == {}
+
+
+# --- parse_team_sections (which game/year a block of teams came from) ------
+
+def test_parse_team_sections_tags_each_block_with_its_title():
+    sections = sheets.parse_team_sections(SHEET_ROWS)
+    assert [(s.title, sorted(s.rosters)) for s in sections] == [
+        ("[merged] TipiLAN 2026 CS2 Registration Log", ["GENESIS", "Piirivalvurid"]),
+        ("[merged] TipiLAN 2026 LoL Registration Log", ["Pushing 30s"]),
+    ]
+
+
+def test_parse_team_sections_title_does_not_leak_to_untitled_block():
+    rows = [
+        ["[merged] TipiLAN 2026 CS2 Registration Log"] + [""] * 2,
+        ["No", "Team Name", "Lineup (nickname)"],
+        ["1", "GENESIS", "kapa (EST)"],
+        ["", "", ""],
+        ["No", "Team Name", "Lineup (nickname)"],  # second block, no title above it
+        ["1", "Nameless", "someone (EST)"],
+    ]
+    titles = [s.title for s in sheets.parse_team_sections(rows)]
+    assert titles == ["[merged] TipiLAN 2026 CS2 Registration Log", ""]
+
+
+# --- resolve_divider (section title -> configured divider role) ------------
+
+DIVIDERS = {
+    "cs2_2026": 1498736834656604251,
+    "lol_2026": 1498736949706490017,
+}
+
+
+def test_resolve_divider_matches_game_and_year():
+    assert sheets.resolve_divider(
+        "[merged] TipiLAN 2026 CS2 Registration Log", DIVIDERS
+    ) == 1498736834656604251
+    assert sheets.resolve_divider(
+        "[merged] TipiLAN 2026 LoL Registration Log", DIVIDERS
+    ) == 1498736949706490017
+
+
+def test_resolve_divider_year_scoped_key_ignores_other_years():
+    assert sheets.resolve_divider("TipiLAN 2025 CS2 Registration Log", DIVIDERS) is None
+
+
+def test_resolve_divider_prefers_the_most_specific_match():
+    dividers = {"cs2": 111, "cs2_2026": 222}
+    assert sheets.resolve_divider("TipiLAN 2026 CS2 Log", dividers) == 222
+    assert sheets.resolve_divider("TipiLAN 2025 CS2 Log", dividers) == 111
+
+
+def test_resolve_divider_no_config_or_no_title_is_none():
+    assert sheets.resolve_divider("TipiLAN 2026 CS2 Log", {}) is None
+    assert sheets.resolve_divider("", DIVIDERS) is None
+
+
+def test_title_survives_notice_rows_below_it():
+    # Real sheets stack the game/year title above single-cell notice rows; the
+    # title's keywords must survive so resolve_divider still matches (regression:
+    # notice rows used to overwrite the title, yielding a None divider).
+    rows = [
+        ["TipiLAN 2026 CS2 Registration Log"] + [""] * 4,
+        ["This log is updated automatically."] + [""] * 4,
+        ["If a team from the Top 32 withdraws, ..."] + [""] * 4,
+        ["No", "Team Name", "Lineup (nickname, citizenship)", "", ""],
+        ["1", "GENESIS", "kapa (EST)", "", ""],
+    ]
+    section = sheets.parse_team_sections(rows)[0]
+    assert "CS2" in section.title and "2026" in section.title
+    assert sheets.resolve_divider(section.title, DIVIDERS) == 1498736834656604251
+
+
+# --- plan_team_positions (pure role-ordering maths) ------------------------
+
+def test_plan_moves_teams_directly_under_their_divider():
+    # Ascending = bottom-up, so the Discord UI renders this list reversed.
+    ordered = ["@everyone", "60hz", "999", "Raid", "CS2-2026", "LOL-2026", "Bot"]
+    plan = member_sync.plan_team_positions(
+        ordered, {"Bot"}, {"CS2-2026": ["60hz", "999", "Raid"]}
+    )
+    final = sorted(set(ordered), key=lambda n: plan.get(n, ordered.index(n)))
+    # Teams end up just below the divider, alphabetical downwards in the UI.
+    assert final == ["@everyone", "Raid", "999", "60hz", "CS2-2026", "LOL-2026", "Bot"]
+
+
+def test_plan_groups_each_divider_separately():
+    ordered = ["@everyone", "Alpha", "Pushing 30s", "CS2-2026", "LOL-2026", "Bot"]
+    plan = member_sync.plan_team_positions(
+        ordered,
+        {"Bot"},
+        {"CS2-2026": ["Alpha"], "LOL-2026": ["Pushing 30s"]},
+    )
+    final = sorted(set(ordered), key=lambda n: plan.get(n, ordered.index(n)))
+    assert final == ["@everyone", "Alpha", "CS2-2026", "Pushing 30s", "LOL-2026", "Bot"]
+
+
+def test_plan_is_a_noop_when_already_positioned():
+    ordered = ["@everyone", "Raid", "999", "60hz", "CS2-2026", "Bot"]
+    assert member_sync.plan_team_positions(
+        ordered, {"Bot"}, {"CS2-2026": ["60hz", "999", "Raid"]}
+    ) == {}
+
+
+def test_plan_skips_missing_divider_and_leaves_its_teams_alone():
+    ordered = ["@everyone", "60hz", "CS2-2026", "Bot"]
+    plan = member_sync.plan_team_positions(
+        ordered, {"Bot"}, {"LOL-2026": ["60hz"]}  # divider not in the guild
+    )
+    assert plan == {}
+
+
+def test_plan_never_moves_managed_roles():
+    ordered = ["@everyone", "60hz", "CS2-2026", "Nitro", "Bot"]
+    plan = member_sync.plan_team_positions(
+        ordered, {"Nitro", "Bot"}, {"CS2-2026": ["60hz", "Nitro"]}
+    )
+    assert "Nitro" not in plan and "Bot" not in plan
+
+
+def test_build_username_index_is_case_insensitive():
+    index = sheets.build_username_index({"GENESIS": ["Kapa", "neaQ"]})
+    assert index == {"kapa": "GENESIS", "neaq": "GENESIS"}
+
+
+# --- sync_team_role behaviour (roster-independent) -------------------------
+
+class FakeRole:
+    def __init__(self, rid: int, name: str):
+        self.id = rid
+        self.name = name
+
+    def __eq__(self, other):
+        return isinstance(other, FakeRole) and other.id == self.id
+
+    def __hash__(self):
+        return hash(self.id)
+
+
+class FakeMember:
+    def __init__(self, uid: int, name: str, roles, bot: bool = False):
+        self.id = uid
+        self.name = name
+        self.display_name = name
+        self.bot = bot
+        self.roles = list(roles)
+
+    async def add_roles(self, *roles, reason=None):
+        self.roles.extend(roles)
+
+    async def remove_roles(self, *roles, reason=None):
+        self.roles = [r for r in self.roles if r not in roles]
+
+
+class FakeGuild:
+    def __init__(self, roles, members=None):
+        self.roles = list(roles)
+        self.members = list(members or [])
+        self._next = 9000
+        self.created: list[str] = []
+
+    async def create_role(self, name, reason=None):
+        self._next += 1
+        role = FakeRole(self._next, name)
+        self.roles.append(role)
+        self.created.append(name)
+        return role
+
+    def get_role(self, rid):
+        return next((r for r in self.roles if r.id == rid), None)
+
+
+def test_sync_creates_missing_team_role_and_removes_old_one(monkeypatch):
+    old_team = FakeRole(1, "OldTeam")
+    keeper = FakeRole(2, "Member")  # not a team role - must be left alone
+    member = FakeMember(1, "tft", roles=[old_team, keeper])
+    guild = FakeGuild([old_team, keeper])
+
+    monkeypatch.setattr(sheets, "get_team_for_username",
+                        lambda n: "GENESIS" if n.lower() == "tft" else None)
+    monkeypatch.setattr(sheets, "all_team_names", lambda: {"GENESIS", "OldTeam"})
+
+    result = run(member_sync.sync_team_role(member, guild))
+
+    assert result.created == "GENESIS"          # auto-created the missing role
+    assert "GENESIS" in guild.created
+    assert result.added == "GENESIS"
+    assert result.removed == ["OldTeam"]        # left their previous team
+    role_names = {r.name for r in member.roles}
+    assert "GENESIS" in role_names
+    assert "OldTeam" not in role_names
+    assert "Member" in role_names               # unrelated role untouched
+
+
+def test_sync_uses_existing_team_role(monkeypatch):
+    genesis = FakeRole(3, "GENESIS")
+    member = FakeMember(1, "kapa", roles=[])
+    guild = FakeGuild([genesis])
+
+    monkeypatch.setattr(sheets, "get_team_for_username", lambda n: "GENESIS")
+    monkeypatch.setattr(sheets, "all_team_names", lambda: {"GENESIS"})
+
+    result = run(member_sync.sync_team_role(member, guild))
+
+    assert guild.created == []                   # did NOT create a duplicate
+    assert result.created is None
+    assert result.added == "GENESIS"
+    assert genesis in member.roles
+
+
+def test_sync_grants_game_divider_role(monkeypatch):
+    genesis = FakeRole(3, "GENESIS")
+    cs2_div = FakeRole(100, "====== CS2 2026 ======")
+    member = FakeMember(1, "kapa", roles=[])
+    guild = FakeGuild([genesis, cs2_div])
+
+    monkeypatch.setattr(sheets, "get_team_for_username", lambda n: "GENESIS")
+    monkeypatch.setattr(sheets, "all_team_names", lambda: {"GENESIS"})
+    monkeypatch.setattr(sheets, "get_team_dividers", lambda: {"GENESIS": 100})
+    monkeypatch.setattr(config, "TEAM_DIVIDERS", {"cs2_2026": 100, "lol_2026": 200})
+
+    result = run(member_sync.sync_team_role(member, guild))
+
+    assert result.divider_added == "====== CS2 2026 ======"
+    assert cs2_div in member.roles
+
+
+def test_sync_swaps_divider_role_on_game_switch(monkeypatch):
+    genesis = FakeRole(3, "GENESIS")
+    cs2_div = FakeRole(100, "CS2")
+    lol_div = FakeRole(200, "LoL")
+    member = FakeMember(1, "kapa", roles=[lol_div])  # was LoL, now on a CS2 team
+    guild = FakeGuild([genesis, cs2_div, lol_div])
+
+    monkeypatch.setattr(sheets, "get_team_for_username", lambda n: "GENESIS")
+    monkeypatch.setattr(sheets, "all_team_names", lambda: {"GENESIS"})
+    monkeypatch.setattr(sheets, "get_team_dividers", lambda: {"GENESIS": 100})
+    monkeypatch.setattr(config, "TEAM_DIVIDERS", {"cs2_2026": 100, "lol_2026": 200})
+
+    result = run(member_sync.sync_team_role(member, guild))
+
+    assert result.divider_added == "CS2"
+    assert result.divider_removed == ["LoL"]
+    ids = {r.id for r in member.roles}
+    assert 100 in ids and 200 not in ids
+
+
+def test_sync_strips_team_role_when_not_registered(monkeypatch):
+    old_team = FakeRole(1, "OldTeam")
+    member = FakeMember(1, "ghost", roles=[old_team])
+    guild = FakeGuild([old_team])
+
+    monkeypatch.setattr(sheets, "get_team_for_username", lambda n: None)
+    monkeypatch.setattr(sheets, "all_team_names", lambda: {"OldTeam"})
+
+    result = run(member_sync.sync_team_role(member, guild))
+
+    assert result.removed == ["OldTeam"]
+    assert result.added is None
+    assert old_team not in member.roles
+
+
+def test_sync_no_team_sheet_is_noop(monkeypatch):
+    keeper = FakeRole(2, "Member")
+    member = FakeMember(1, "someone", roles=[keeper])
+    guild = FakeGuild([keeper])
+
+    # Empty caches = feature switched off: no removals even of a stale team role.
+    monkeypatch.setattr(sheets, "get_team_for_username", lambda n: None)
+    monkeypatch.setattr(sheets, "all_team_names", lambda: set())
+
+    result = run(member_sync.sync_team_role(member, guild))
+
+    assert result.removed == []
+    assert guild.created == []
+    assert keeper in member.roles
+
+
+def test_sync_all_team_roles_aggregates_and_skips_bots(monkeypatch):
+    genesis = FakeRole(3, "GENESIS")
+    m1 = FakeMember(1, "kapa", roles=[])          # will get GENESIS
+    m2 = FakeMember(2, "nobody", roles=[])        # not registered, unchanged
+    bot_member = FakeMember(3, "botto", roles=[], bot=True)  # skipped
+    guild = FakeGuild([genesis], members=[m1, m2, bot_member])
+
+    teams = {"kapa": "GENESIS"}
+    monkeypatch.setattr(sheets, "get_team_for_username", lambda n: teams.get(n.lower()))
+    monkeypatch.setattr(sheets, "all_team_names", lambda: {"GENESIS"})
+
+    summary = run(member_sync.sync_all_team_roles(guild))
+
+    assert summary.scanned == 2                   # bot excluded
+    assert summary.assigned == 1
+    assert summary.removed == 0
+    assert summary.changes == ["kapa: +GENESIS"]