docs(dev-notes): list new economy submodules and commands

Reflects bank/lootbox/achievements/lottery/consumables/vanity modules, the
pending-wager escrow + reconcile, effective_cooldown/ITEM_COOLDOWNS, and the
net-worth leaderboard/economy-stats helpers.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_013VbAVsrZuYesea99mPMmPT

.env.example

@@ -9,21 +9,6 @@ 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; drives /teamsync + hourly team-role sync on
-# the economy/community bot. Leave unset to disable team-role sync entirely.
-TEAM_SHEET_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
 
@@ -46,6 +31,12 @@ BIRTHDAY_CHANNEL_ID=
 # How many days before a birthday the on-join check counts as "coming up"
 BIRTHDAY_WINDOW_DAYS=7
 
+# Channel ID where the daily lottery draw result is announced (optional - the
+# draw still runs and pays the winner if unset; per-profile like BIRTHDAY_CHANNEL)
+LOTTERY_CHANNEL_ID_DEV=
+LOTTERY_CHANNEL_ID_ECONOMY=
+LOTTERY_CHANNEL_ID=
+
 # PocketBase backend (https://pocketbase.io)
 PB_URL=http://127.0.0.1:8090
 PB_ADMIN_EMAIL=admin@example.com

CLAUDE.md

@@ -0,0 +1,66 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+
+## What this is
+
+Discord bot for the TipiLAN community (`discord.py`). Two responsibilities: **member management** (syncs nicknames/roles from a Google Sheet, birthday announcements) and the **TipiCOIN economy** (a large game economy stored in PocketBase). User-facing text is **Estonian**; only `docs/PATCHNOTES.md` content is English.
+
+See `README.md` for the full feature/gameplay spec and `docs/DEV_NOTES.md` for the developer reference (add-a-command / add-a-shop-item checklists, constants).
+
+## Commands
+
+```bash
+# Run tests (pure logic + economy flows against an in-memory PocketBase fake)
+python -m pytest tests/ -q
+
+# Single file / single test
+python -m pytest tests/test_economy_pure.py -q
+python -m pytest tests/test_economy_flows.py::TestDaily::test_streak -q
+
+# Run the bot (requires .env; PocketBase must already be running)
+BOT_PROFILE=dev python bot.py        # or BOT_PROFILE=economy
+```
+
+Deps: `pip install -r requirements-dev.txt` (dev = runtime + pytest). CI (`.gitea/workflows/deploy.yml`) runs `pytest tests/ -q` on push to `master`, then deploys to the host by restarting `tipibot_dev` (canary) and `tipibot_eco` systemd units. The bot runs on host `tipilan-bots:/root/tipibot`; the local checkout has no `.env`/live DB.
+
+## Architecture
+
+Three layers, deliberately decoupled:
+
+- **`core/`** — domain logic, **no Discord objects**. `core/economy/` is the economy package.
+- **`commands/`** — one Discord slash-command group per file. Each exposes `register_<group>_commands(tree, bot, ...)`.
+- **`bot.py`** — thin wiring layer: Discord client, event handlers (`on_ready`, `on_member_join`), background tasks, shared helpers, and it calls every `register_*_commands(...)` on startup, passing shared helpers down (`coin`, `cd_ts`, `award_exp`, `maybe_remind`, `parse_amount`).
+
+### Dual-profile design (dev vs economy)
+
+`BOT_PROFILE` env var (`dev` | `economy`) selects **everything** at import time in `config.py`: which Discord token, guild ID, birthday channel, and **PocketBase collection** (`economy_users_dev` vs `economy_users_prod`) are used. Legacy non-suffixed env vars act as fallbacks. Logs and `data/` are also namespaced per profile (`logs/<profile>/`, `data/<profile>/`). `/check`, `/member`, `/birthdays` are **dev-profile only**. When adding config, follow the `_DEV` / `_ECONOMY` + legacy-fallback pattern.
+
+### The re-export pattern (important — two places)
+
+Both `strings/` and `core/economy/` are packages split into submodules but **re-exported flat** through their `__init__.py`, so callers use `import strings as S; S.NAME` and `from core import economy; economy.do_daily(...)` unchanged.
+
+- **Edit the submodule**, not the `__init__`. Strings live in `strings/{common,commands,member,economy,admin,games,fishing}.py`; economy logic in `core/economy/{store,income,gambling,fishing,jail,heist,prestige,shop,levels,quests,leaderboards,house,admin}.py`.
+- `tests/test_strings.py` guards that every submodule name is re-exported — a new string that isn't re-exported fails CI.
+- Caveat (see `tests/conftest.py:93`): the re-exported `economy.house` mutable state is a snapshot; live house state is owned by `economy.house`. Patch the submodule, not the alias.
+
+### Economy persistence & concurrency (`core/economy/store.py`)
+
+- Every mutation is a **read-modify-write**: `get_user(id)` → mutate the `UserData` dict → `await _commit(id, user)`. Money/EXP changes must also call `_txn(...)` for the transaction log.
+- **Per-user async locks** serialize commits. Public mutating functions are decorated with `@_locked_by(<arg positions of user ids>)`. Two hard rules to avoid deadlock/lost-writes:
+  1. A `@_locked_by` function must **never call another `@_locked_by` function**.
+  2. House balance changes go through `_credit_house` (an atomic PocketBase increment, no lock) so they're safe to call while holding user locks.
+  Multi-user functions (`do_give`, `do_rob`) list both positions and acquire locks in sorted order.
+- **PocketBase silently drops writes to fields not in the collection schema** — this is the #1 footgun. Adding any new persisted field means adding it to `_default_user()` **and** running `python scripts/sync_pb_schema.py` (reconciles both dev + prod collections). `store.missing_schema_fields()` / `/status` surface drift.
+
+### Command result convention
+
+`core.economy` functions return a dict with a `"reason"` key describing the outcome (success, `"cooldown"`, `"jailed"`, `"banned"`, insufficient funds, ...). The command handler in `commands/` maps every possible `res["reason"]` to a string/embed. On success it calls `award_exp(interaction, economy.EXP_REWARDS["<cmd>"])` and `maybe_remind(...)` where relevant.
+
+## Adding an economy command or shop item
+
+Follow the exact ordered checklists in `docs/DEV_NOTES.md` ("Adding a New Economy Command", "Adding a New Shop Item"). They enumerate every touchpoint across `core/economy/`, `strings/`, `commands/`, and `bot.py` (cooldowns, EXP rewards, help embed, reminders, item-modified cooldown branches). Missing a step generally means a silently broken feature rather than an error.
+
+## Tests
+
+No `pytest-asyncio`. Async tests wrap coroutines with the `run(coro)` helper from `tests/conftest.py` (which is `asyncio.run`). The `fake_pb` fixture monkeypatches `core.pb_client` with an in-memory `FakePocketBase` that mimics real PocketBase behaviour — including atomic `field+`/`field-` increments and **silently dropping writes to fields missing from the schema** (use `fake_pb_without_quest_fields` to simulate pre-migration schema drift). Prefer testing `core/` logic directly; there's no Discord in the test path.

README.md

@@ -10,9 +10,8 @@ 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. [Tournament Team Roles](#tournament-team-roles)
-6. [TipiCOIN Economy](#tipicoin-economy)
-7. [Project Structure](#project-structure)
+5. [TipiCOIN Economy](#tipicoin-economy)
+6. [Project Structure](#project-structure)
 
 ---
 
@@ -108,8 +107,6 @@ cp .env.example .env
 | `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
 
@@ -171,7 +168,6 @@ Admins (bot lacks permission to modify them) are silently skipped and still mark
 |---|---|---|
 | `/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 |
@@ -224,46 +220,6 @@ 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 `core/pb_client.py`). The currency is **TipiCOIN** (⬡), displayed as a custom Discord emoji configured in `core/economy/store.py → COIN`.
@@ -289,7 +245,7 @@ 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. Bot Farm 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 and adds +25 ⬡. 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 ⬡ | Hiirematt reduces cooldown to 3min. Mehaaniline klaviatuur multiplies earnings ×2. |
 | `/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. |
@@ -380,11 +336,19 @@ The **ECONOMY** role is granted on your first EXP award (i.e. first successful e
 | `/rank [@user]` | EXP total, current level, progress bar to next level, leaderboard rank. |
 | `/stats [@user]` | Lifetime statistics: economy totals, work/beg counts, gambling records, crime/heist history, social totals, best streak. |
 | `/cooldowns` | All cooldowns at a glance with live Discord timestamps. Shows jail timer if jailed. |
-| `/leaderboard` | Paginated leaderboard with 6 tabs: 🪙 Coins, 📊 EXP, 🏆 Season EXP, 🔥 Prestige, 🎲 Wagered, 🎣 Fish caught. House pinned at #0 on coins tab. |
+| `/leaderboard` | Paginated leaderboard with 6 tabs: 🪙 Coins (net worth = wallet + bank), 📊 EXP, 🏆 Season EXP, 🔥 Prestige, 🎲 Wagered, 🎣 Fish caught. House pinned at #0 on coins tab. |
 | `/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). |
+| `/bank` | View your vault. Banked coins are **rob-proof** (`/rob` and `/heist` only touch liquid balance) but earn no Bot Farm interest and can't be spent until withdrawn. |
+| `/deposit <amount>` | Move coins from your wallet into the bank. `all` deposits everything liquid. |
+| `/withdraw <amount>` | Move coins from the bank back to your wallet. `all` withdraws everything banked. |
+| `/consumables` | Buy repeatable, expiring boosts (earn ×2, EXP ×2, or an instant cooldown wipe). A recurring coin sink. |
+| `/lootbox` | Open a mystery box for **1 000 ⬡**. Weighted random reward: coin tiers (usually a small net loss), a 30-min earn/EXP ×2 buff, or a rare jackpot. |
+| `/vanity` | Status shop — buy and equip cosmetic badges/titles (shown on `/profile`). Coins are **burned**, not recirculated. No gameplay effect. |
 | `/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. |
+| `/achievements` | Milestone badges over your lifetime stats (work/wealth/gambling/crime/fishing/streaks/prestige). Each unlocks once and pays a one-time coin reward; opening the command claims any newly earned. |
+| `/lottery [amount]` | View the pot or buy tickets (200 ⬡ each, max 100/draw). One winner is drawn daily at 21:00 Tallinn time and takes the whole pot — more tickets = higher weighted chance. Coins are conserved (the pot equals total ticket spend). Announced in `LOTTERY_CHANNEL_ID` if set. |
 | `/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. |
@@ -468,7 +432,7 @@ All items are **permanent** once purchased **except Anticheat**, which expires a
 | Hiirematt | 600 ⬡ | `/beg` cooldown 5min → 3min |
 | 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 |
+| Kõrvaklapid | 1 200 ⬡ | `/daily` cooldown 20h → 18h and +25 ⬡ bonus |
 | LAN pilet | 1 200 ⬡ | `/daily` reward ×2 |
 | Bot Farm | 1 500 ⬡ | `/daily` adds 5% interest on balance (capped at 500 ⬡/day) |
 

bot.py

@@ -23,7 +23,7 @@ import config
 import strings as S
 from core import economy, pb_client, sheets
 from core.admin import is_bot_admin
-from core.member_sync import SyncResult, sync_all_team_roles
+from core.member_sync import SyncResult
 from commands.dev_member_commands import register_dev_member_commands
 from commands.dev_member_runtime import handle_member_join, run_birthday_daily
 from commands.economy_admin_commands import register_economy_admin_commands
@@ -35,7 +35,6 @@ from commands.economy_prestige_commands import register_prestige_commands
 from commands.economy_quests_commands import register_economy_quests_commands
 from commands.economy_profile_commands import register_economy_profile_commands
 from commands.economy_support_commands import register_economy_support_commands
-from commands.economy_team_commands import register_economy_team_commands
 from commands.ops_channel_commands import register_ops_channel_commands
 from commands.ops_admin_commands import register_ops_admin_commands
 from commands.info_commands import register_info_commands
@@ -337,40 +336,69 @@ async def before_birthday_daily():
     await bot.wait_until_ready()
 
 
-@tasks.loop(hours=1)
-async def team_sync_hourly():
-    """Reload the tournament registration sheet and re-apply team roles.
+# ---------------------------------------------------------------------------
+# Daily lottery draw (Tallinn-time DRAW_HOUR:00)
+# ---------------------------------------------------------------------------
+async def _resolve_channel(channel_id: int):
+    """Best-effort fetch of a text channel by id (cache, then API)."""
+    if not channel_id:
+        return None
+    channel = bot.get_channel(channel_id)
+    if channel is None:
+        try:
+            channel = await bot.fetch_channel(channel_id)
+        except (discord.NotFound, discord.Forbidden, discord.HTTPException):
+            return None
+    return channel
 
-    Economy profile only (the tournament players live in the community guild).
-    Runs the first iteration immediately on start, so this also covers the
-    initial load at boot. No-op when TEAM_SHEET_ID is unset.
-    """
-    if IS_DEV_PROFILE or not config.TEAM_SHEET_ID:
-        return
+
+@tasks.loop(time=datetime.time(hour=economy.lottery.DRAW_HOUR, minute=0, tzinfo=TALLINN_TZ))
+async def lottery_draw_daily():
+    """Draw the day's lottery winner and announce it (if a channel is set)."""
+    period = datetime.datetime.now(TALLINN_TZ).date().isoformat()
     try:
-        rosters = await sheets.refresh_teams()
-    except Exception as e:
-        log.error("team_sync_hourly: failed to load team sheet: %s", e)
+        result = await economy.do_lottery_draw(period)
+    except Exception:
+        log.exception("Lottery draw failed for %s", period)
         return
-    if not rosters:
+    channel = await _resolve_channel(config.LOTTERY_CHANNEL_ID)
+    if result is None:
+        log.info("Lottery draw %s: no participants", period)
+        if channel:
+            try:
+                await channel.send(S.LOTTERY_UI["draw_none"])
+            except discord.HTTPException:
+                pass
         return
-    guild = bot.get_guild(config.GUILD_ID)
-    if guild is None:
-        log.warning("team_sync_hourly: guild %s not found", config.GUILD_ID)
+    if not result.get("ok"):
+        log.error("Lottery draw %s could not pay winner %s (pot %s)",
+                  period, result.get("winner_id"), result.get("pot"))
         return
-    summary = await sync_all_team_roles(guild, log)
-    if summary.assigned or summary.removed or summary.created or summary.positioned or summary.errors:
-        log.info(
-            "team_sync_hourly: assigned=%d, removed=%d, created=%d, positioned=%d, errors=%d",
-            summary.assigned, summary.removed, len(summary.created),
-            summary.positioned, len(summary.errors),
+    log.info("Lottery draw %s: winner %s won %s (%s/%s tickets)",
+             period, result["winner_id"], result["pot"],
+             result["winner_tickets"], result["total_tickets"])
+    if channel:
+        mention = f"<@{result['winner_id']}>"
+        embed = discord.Embed(
+            title=S.LOTTERY_UI["draw_title"],
+            description=S.LOTTERY_UI["draw_win"].format(
+                winner=mention,
+                pot=_coin(result["pot"]),
+                tickets=result["winner_tickets"],
+                total=result["total_tickets"],
+                chance=round(result["win_chance"] * 100, 1),
+                players=result["participants"],
+            ),
+            color=0xF4C430,
         )
-        for err in summary.errors:
-            log.warning("team_sync_hourly: %s", err)
+        try:
+            await channel.send(content=mention, embed=embed)
+        except discord.HTTPException:
+            pass
 
 
-@team_sync_hourly.before_loop
-async def before_team_sync_hourly():
+@lottery_draw_daily.before_loop
+async def before_lottery_draw_daily():
     await bot.wait_until_ready()
 
 
@@ -471,10 +499,10 @@ async def on_ready():
         birthday_daily.start()
         log.info("Birthday daily task started (fires 09:00 Tallinn time)")
 
-    # Start hourly tournament team-role sync (economy/community guild)
-    if not IS_DEV_PROFILE and config.TEAM_SHEET_ID and not team_sync_hourly.is_running():
-        team_sync_hourly.start()
-        log.info("Team-role sync task started (hourly, from the registration sheet)")
+    # Start daily lottery draw (runs in every profile; each has its own collection)
+    if not lottery_draw_daily.is_running():
+        lottery_draw_daily.start()
+        log.info("Lottery draw task started (fires %02d:00 Tallinn time)", economy.lottery.DRAW_HOUR)
 
     # Start rotating rich presence
     if not _rotate_presence.is_running():
@@ -484,6 +512,16 @@ async def on_ready():
     # Re-schedule any reminder tasks lost on restart
     await _restore_reminders()
 
+    # Refund stakes escrowed by interactive games (blackjack/RPS PvP) that a
+    # restart interrupted, so a mid-hand crash never eats a player's coins.
+    try:
+        refunded = await economy.reconcile_pending_wagers()
+        if refunded:
+            total = sum(amt for _, amt, _ in refunded)
+            log.info("Reconciled %d interrupted wager(s), refunded %d coins", len(refunded), total)
+    except Exception:
+        log.exception("Pending-wager reconciliation failed")
+
     # Notify the channel where /restart was triggered
     if _RESTART_FILE.exists():
         try:
@@ -533,10 +571,6 @@ if IS_DEV_PROFILE:
         has_announced_today=_has_announced_today,
         mark_announced_today=_mark_announced_today,
     )
-else:
-    # Tournament team-role sync lives on the economy/community bot, where the
-    # registered players actually are (see commands/economy_team_commands.py).
-    register_economy_team_commands(tree, bot, log)
 
 register_ops_admin_commands(
     tree,
@@ -735,8 +769,10 @@ register_prestige_commands(
 
 def _parse_amount(value: str, balance: int) -> tuple[int | None, str | None]:
     """Parse an amount string; 'all' resolves to the user's full balance.
-    Accepts plain integers and valid thousand-separated numbers (1,000 / 1.000 / 1 000).
-    Rejects decimals and ambiguous inputs like 1,1 or 1.5.
+    Accepts plain non-negative integers and valid thousand-separated numbers
+    (1,000 / 1.000 / 1 000). Rejects decimals, ambiguous inputs like 1,1 or 1.5,
+    and negative amounts (a negative bet/give would mint coins on loss/transfer
+    paths that trust the caller's sign).
     Returns (amount, None) on success or (None, error_msg) on failure."""
     v = value.strip()
     if v.lower() == "all":
@@ -745,9 +781,12 @@ def _parse_amount(value: str, balance: int) -> tuple[int | None, str | None]:
     if re.fullmatch(r'\d{1,3}([,. ]\d{3})*', v):
         v = re.sub(r'[,. ]', '', v)
     try:
-        return int(v), None
+        amount = int(v)
     except ValueError:
         return None, S.ERR["invalid_amount"]
+    if amount < 0:
+        return None, S.ERR["invalid_amount"]
+    return amount, None
 
 
 # ---------------------------------------------------------------------------
@@ -814,17 +853,7 @@ async def _restore_reminders() -> None:
             last_str = user.get(last_key)
             if not last_str:
                 continue
-            items = user.get("items", [])
-            if cmd == "work" and "monitor" in items:
-                cooldown = datetime.timedelta(minutes=40)
-            elif cmd == "beg" and "hiirematt" in items:
-                cooldown = datetime.timedelta(minutes=3)
-            elif cmd == "daily" and "korvaklapid" in items:
-                cooldown = datetime.timedelta(hours=18)
-            elif cmd == "fish" and "ussipurk" in items:
-                cooldown = datetime.timedelta(seconds=90)
-            else:
-                cooldown = economy.COOLDOWNS.get(cmd)
+            cooldown = economy.effective_cooldown(cmd, user.get("items", []))
             if not cooldown:
                 continue
             last_dt = datetime.datetime.fromisoformat(last_str)
@@ -843,17 +872,7 @@ async def _maybe_remind(user_id: int, cmd: str) -> None:
     user_data = await economy.get_user(user_id)
     if cmd not in user_data.get("reminders", []):
         return
-    items = set(user_data.get("items", []))
-    if cmd == "work" and "monitor" in items:
-        delay = datetime.timedelta(minutes=40)
-    elif cmd == "beg" and "hiirematt" in items:
-        delay = datetime.timedelta(minutes=3)
-    elif cmd == "daily" and "korvaklapid" in items:
-        delay = datetime.timedelta(hours=18)
-    elif cmd == "fish" and "ussipurk" in items:
-        delay = datetime.timedelta(seconds=90)
-    else:
-        delay = economy.COOLDOWNS.get(cmd, datetime.timedelta(hours=1))
+    delay = economy.effective_cooldown(cmd, user_data.get("items", [])) or datetime.timedelta(hours=1)
     _schedule_reminder(user_id, cmd, delay)
 
 

commands/_replies.py

@@ -0,0 +1,25 @@
+"""Shared reply helpers for command handlers."""
+
+from __future__ import annotations
+
+import discord
+
+import strings as S
+
+
+async def reply_db_error(interaction: discord.Interaction) -> None:
+    """Tell the user the database is unavailable.
+
+    Economy core functions return {"ok": False, "reason": "db_error"} on a
+    PocketBase outage. Without this, handlers either fall through silently (a
+    deferred interaction hangs on "thinking...") or show a misleading "you're
+    broke" message. Works whether or not the interaction was already deferred.
+    """
+    msg = S.ERR["db_error"]
+    try:
+        if interaction.response.is_done():
+            await interaction.followup.send(msg, ephemeral=True)
+        else:
+            await interaction.response.send_message(msg, ephemeral=True)
+    except discord.HTTPException:
+        pass

commands/economy_admin_commands.py

@@ -211,17 +211,29 @@ def register_economy_admin_commands(
         prestige_pp = data.get("prestige_points", 0)
         total_fish = data.get("total_fish_caught", 0)
         inv_fish = len(data.get("fish_inventory") or [])
+        pw = data.get("pending_wager") or {}
+        wager_str = f"{pw.get('amount', 0):,} ({pw.get('kind')})" if pw.get("amount") else "-"
         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_bank"], value=f"{data.get('bank_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_extras"],
+            value=S.ADMINVIEW_UI["extras_val"].format(
+                ach=len(data.get("achievements_earned") or []),
+                lootboxes=data.get("lootboxes_opened", 0),
+                wager=wager_str,
+            ),
+            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)

commands/economy_extra_commands.py

@@ -5,6 +5,7 @@ import datetime
 import random
 import time
 from collections.abc import Awaitable, Callable, MutableSet
+from zoneinfo import ZoneInfo
 
 import discord
 from discord import app_commands
@@ -13,6 +14,10 @@ from core import economy
 from core.emoji import EMOJI as E
 import strings as S
 
+from ._replies import reply_db_error
+
+_TALLINN = ZoneInfo("Europe/Tallinn")
+
 
 def register_economy_extra_commands(
     tree: app_commands.CommandTree,
@@ -120,6 +125,9 @@ def register_economy_extra_commands(
                 return
             res = await economy.do_heist_check(interaction.user.id)
             if not res["ok"]:
+                if res["reason"] == "db_error":
+                    await reply_db_error(interaction)
+                    return
                 if res["reason"] == "banned":
                     await interaction.response.send_message(S.MSG_BANNED, ephemeral=True)
                 elif res["reason"] == "jailed":
@@ -270,6 +278,9 @@ def register_economy_extra_commands(
             return
         res = await economy.do_heist_check(interaction.user.id)
         if not res["ok"]:
+            if res["reason"] == "db_error":
+                await reply_db_error(interaction)
+                return
             if res["reason"] == "banned":
                 await interaction.response.send_message(S.MSG_BANNED, ephemeral=True)
             elif res["reason"] == "jailed":
@@ -518,6 +529,9 @@ def register_economy_extra_commands(
 
         res = await economy.do_give(interaction.user.id, kasutaja.id, summa_int)
         if not res["ok"]:
+            if res["reason"] == "db_error":
+                await reply_db_error(interaction)
+                return
             if res["reason"] == "banned":
                 await interaction.response.send_message(S.MSG_BANNED, ephemeral=True)
             elif res["reason"] == "jailed":
@@ -543,6 +557,64 @@ def register_economy_extra_commands(
         )
         await interaction.response.send_message(embed=embed)
 
+    # -----------------------------------------------------------------------
+    # /lottery - daily draw, one weighted winner takes the pot
+    # -----------------------------------------------------------------------
+    @tree.command(name="lottery", description=S.CMD["lottery"])
+    @app_commands.describe(kogus=S.OPT["lottery_kogus"])
+    async def cmd_lottery(interaction: discord.Interaction, kogus: int | None = None):
+        period = economy.period_for(datetime.datetime.now(_TALLINN))
+
+        if kogus is None:
+            state = await economy.get_lottery_state(period, interaction.user.id)
+            embed = discord.Embed(
+                title=S.LOTTERY_UI["title"],
+                description=S.LOTTERY_UI["desc"].format(
+                    draw_time=f"{economy.DRAW_HOUR}:00", cost=coin(state["ticket_cost"])
+                ),
+                color=0xF4C430,
+            )
+            embed.add_field(name=S.LOTTERY_UI["f_pot"], value=coin(state["pot"]), inline=True)
+            embed.add_field(name=S.LOTTERY_UI["f_players"], value=str(state["participants"]), inline=True)
+            if state["your_tickets"]:
+                chance = round(state["your_tickets"] / state["total_tickets"] * 100, 1)
+                embed.add_field(
+                    name=S.LOTTERY_UI["f_your"],
+                    value=S.LOTTERY_UI["your_val"].format(tickets=state["your_tickets"], chance=chance),
+                    inline=False,
+                )
+            else:
+                embed.add_field(name=S.LOTTERY_UI["f_your"], value=S.LOTTERY_UI["your_none"], inline=False)
+            await interaction.response.send_message(embed=embed)
+            return
+
+        if kogus <= 0:
+            await interaction.response.send_message(S.ERR["positive_amount"], ephemeral=True)
+            return
+        res = await economy.do_buy_ticket(interaction.user.id, kogus, period)
+        if not res["ok"]:
+            if res["reason"] == "db_error":
+                await reply_db_error(interaction)
+            elif res["reason"] == "banned":
+                await interaction.response.send_message(S.MSG_BANNED, ephemeral=True)
+            elif res["reason"] == "max_tickets":
+                await interaction.response.send_message(
+                    S.LOTTERY_UI["max_tickets"].format(cap=res["cap"], held=res["held"]), 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["invalid_amount"], ephemeral=True)
+            return
+        await interaction.response.send_message(
+            S.LOTTERY_UI["bought"].format(
+                count=res["bought"], cost=coin(res["cost"]),
+                tickets=res["tickets"], balance=coin(res["balance"]),
+            )
+        )
+
     class LeaderboardView(discord.ui.View):
         PER_PAGE = 10
 
@@ -751,14 +823,13 @@ def register_economy_extra_commands(
     @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),
-        )
+        lbs = await economy.get_all_leaderboards()  # single collection scan for all six tabs
+        coins_raw = lbs["coins"]
+        exp_raw = lbs["exp"]
+        season_raw = lbs["season"]
+        prestige_raw = lbs["prestige"]
+        wagered_raw = lbs["wagered"]
+        fish_raw = lbs["fish"]
 
         house_entry = None
         regular = []
@@ -865,6 +936,9 @@ def register_economy_extra_commands(
     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"] == "db_error":
+                await reply_db_error(interaction)
+                return
             if res["reason"] == "banned":
                 await interaction.response.send_message(S.MSG_BANNED, ephemeral=True)
             elif res["reason"] == "owned":

commands/economy_fish_commands.py

@@ -10,6 +10,8 @@ from discord import app_commands
 from core import economy
 import strings as S
 
+from ._replies import reply_db_error
+
 
 def register_economy_fish_commands(
     tree: app_commands.CommandTree,
@@ -218,6 +220,9 @@ def register_economy_fish_commands(
 
         res = await economy.do_fish_start(interaction.user.id)
         if not res["ok"]:
+            if res["reason"] == "db_error":
+                await reply_db_error(interaction)
+                return
             if res["reason"] == "banned":
                 await interaction.response.send_message(S.MSG_BANNED, ephemeral=True)
             elif res["reason"] == "cooldown":

commands/economy_games_commands.py

@@ -12,6 +12,8 @@ from core import economy
 from core.emoji import EMOJI as E
 import strings as S
 
+from ._replies import reply_db_error
+
 
 def register_economy_games_commands(
     tree: app_commands.CommandTree,
@@ -116,6 +118,9 @@ def register_economy_games_commands(
         res = await economy.do_roulette(interaction.user.id, panus_int, värv.value)
         if not res["ok"]:
             active_games.discard(interaction.user.id)
+            if res["reason"] == "db_error":
+                await reply_db_error(interaction)
+                return
             if res["reason"] == "banned":
                 await interaction.response.send_message(S.MSG_BANNED, ephemeral=True)
             elif res["reason"] == "jailed":
@@ -202,7 +207,14 @@ def register_economy_games_commands(
             bet_line = ""
             if self.bet > 0:
                 res = await economy.do_game_bet(interaction.user.id, self.bet, outcome)
-                if outcome == "win":
+                if not res.get("ok"):
+                    if res.get("reason") == "db_error":
+                        await reply_db_error(interaction)
+                        return
+                    # Player was jailed/went broke since the duel started - show the
+                    # result without a bet line rather than crashing on res["balance"].
+                    bet_line = ""
+                elif outcome == "win":
                     bet_line = S.RPS_UI["bet_win"].format(amount=coin(self.bet), balance=coin(res["balance"]))
                 elif outcome == "lose":
                     bet_line = S.RPS_UI["bet_lose"].format(amount=coin(self.bet), balance=coin(res["balance"]))
@@ -278,10 +290,12 @@ def register_economy_games_commands(
             if self.bet > 0:
                 if winner == "a":
                     await economy.do_rps_pvp_payout(self.player_a.id, self.bet)
+                    await economy.do_rps_pvp_forfeit(self.player_b.id)
                     bet_line_a = f"\n+{coin(self.bet)}"
                     bet_line_b = f"\n-{coin(self.bet)}"
                 elif winner == "b":
                     await economy.do_rps_pvp_payout(self.player_b.id, self.bet)
+                    await economy.do_rps_pvp_forfeit(self.player_a.id)
                     bet_line_a = f"\n-{coin(self.bet)}"
                     bet_line_b = f"\n+{coin(self.bet)}"
                 else:
@@ -652,6 +666,9 @@ def register_economy_games_commands(
         res = await economy.do_slots(interaction.user.id, panus_int)
         if not res["ok"]:
             active_games.discard(interaction.user.id)
+            if res["reason"] == "db_error":
+                await reply_db_error(interaction)
+                return
             if res["reason"] == "banned":
                 await interaction.response.send_message(S.MSG_BANNED, ephemeral=True)
                 return
@@ -926,13 +943,17 @@ def register_economy_games_commands(
             embed = self._cur_embed(game_over=True, hand_results=hand_results)
             embed.title = S.TITLE[title_key]
             embed.color = color
+            if res.get("ok"):
+                result_line = result_str + S.BJ_UI["balance_line"].format(balance=coin(res["balance"]))
+            else:
+                result_line = result_str + "\n" + S.ERR["payout_failed"]
             embed.add_field(
                 name=S.BJ["result_field"],
-                value=result_str + S.BJ_UI["balance_line"].format(balance=coin(res["balance"])),
+                value=result_line,
                 inline=False,
             )
             await self.message.edit(embed=embed, view=self)
-            if total_payout > total_invested:
+            if res.get("ok") and total_payout > total_invested:
                 asyncio.create_task(award_exp(interaction, economy.gamble_exp(total_invested)))
 
         async def _do_dealer_reveal(self, interaction: discord.Interaction) -> None:
@@ -1013,6 +1034,9 @@ def register_economy_games_commands(
             try:
                 res = await economy.do_blackjack_bet(self.user_id, self.bet)
                 if not res["ok"]:
+                    if res["reason"] == "db_error":
+                        await reply_db_error(interaction)
+                        return
                     await interaction.response.send_message(
                         S.ERR["broke"].format(bal=coin(res.get("balance", 0))), ephemeral=True
                     )
@@ -1038,6 +1062,9 @@ def register_economy_games_commands(
             try:
                 res = await economy.do_blackjack_bet(self.user_id, self.bet)
                 if not res["ok"]:
+                    if res["reason"] == "db_error":
+                        await reply_db_error(interaction)
+                        return
                     await interaction.response.send_message(
                         S.ERR["broke"].format(bal=coin(res.get("balance", 0))), ephemeral=True
                     )
@@ -1097,6 +1124,9 @@ def register_economy_games_commands(
 
         res = await economy.do_blackjack_bet(interaction.user.id, bet)
         if not res["ok"]:
+            if res["reason"] == "db_error":
+                await reply_db_error(interaction)
+                return
             if res["reason"] == "banned":
                 await interaction.response.send_message(S.MSG_BANNED, ephemeral=True)
             elif res["reason"] == "jailed":
@@ -1150,32 +1180,37 @@ def register_economy_games_commands(
             await asyncio.sleep(_BJ_DEAL_DELAY)
             if _bj_is_blackjack(dealer_hand):
                 push_res = await economy.do_blackjack_payout(interaction.user.id, bet, bet)
+                push_line = (
+                    S.BJ["push_result"] + S.BJ_UI["balance_line"].format(balance=coin(push_res["balance"]))
+                    if push_res.get("ok")
+                    else S.BJ["push_result"] + "\n" + S.ERR["payout_failed"]
+                )
                 embed = _bj_embed(
                     player_hand,
                     dealer_hand,
                     S.TITLE["blackjack_push"],
                     0x99AAB5,
                     hide_dealer=False,
-                    result_field=(
-                        S.BJ["result_field"],
-                        S.BJ["push_result"] + S.BJ_UI["balance_line"].format(balance=coin(push_res["balance"])),
-                    ),
+                    result_field=(S.BJ["result_field"], push_line),
                 )
             else:
                 payout = bet + int(bet * 1.5)
                 bj_res = await economy.do_blackjack_payout(interaction.user.id, payout, bet)
+                bj_line = (
+                    f"+{coin(payout)}" + S.BJ_UI["balance_line"].format(balance=coin(bj_res["balance"]))
+                    if bj_res.get("ok")
+                    else f"+{coin(payout)}" + "\n" + S.ERR["payout_failed"]
+                )
                 embed = _bj_embed(
                     player_hand,
                     dealer_hand,
                     S.TITLE["blackjack_bj"],
                     0xF4C430,
                     hide_dealer=False,
-                    result_field=(
-                        S.BJ["result_field"],
-                        f"+{coin(payout)}" + S.BJ_UI["balance_line"].format(balance=coin(bj_res["balance"])),
-                    ),
+                    result_field=(S.BJ["result_field"], bj_line),
                 )
-                asyncio.create_task(award_exp(interaction, economy.gamble_exp(bet)))
+                if bj_res.get("ok"):
+                    asyncio.create_task(award_exp(interaction, economy.gamble_exp(bet)))
             active_games.discard(interaction.user.id)
             await msg.edit(embed=embed)
             return

commands/economy_income_commands.py

@@ -10,6 +10,8 @@ from discord import app_commands
 from core import economy
 import strings as S
 
+from ._replies import reply_db_error
+
 
 def register_economy_income_commands(
     tree: app_commands.CommandTree,
@@ -25,6 +27,9 @@ def register_economy_income_commands(
         await interaction.response.defer()
         res = await economy.do_daily(interaction.user.id)
         if not res["ok"]:
+            if res["reason"] == "db_error":
+                await reply_db_error(interaction)
+                return
             if res["reason"] == "banned":
                 await interaction.followup.send(S.MSG_BANNED, ephemeral=True)
             elif res["reason"] == "cooldown":
@@ -63,6 +68,9 @@ def register_economy_income_commands(
         await interaction.response.defer()
         res = await economy.do_work(interaction.user.id)
         if not res["ok"]:
+            if res["reason"] == "db_error":
+                await reply_db_error(interaction)
+                return
             if res["reason"] == "banned":
                 await interaction.followup.send(S.MSG_BANNED, ephemeral=True)
             elif res["reason"] == "cooldown":
@@ -97,6 +105,9 @@ def register_economy_income_commands(
         await interaction.response.defer()
         res = await economy.do_beg(interaction.user.id)
         if not res["ok"]:
+            if res["reason"] == "db_error":
+                await reply_db_error(interaction)
+                return
             if res["reason"] == "banned":
                 await interaction.followup.send(S.MSG_BANNED, ephemeral=True)
             elif res["reason"] == "cooldown":
@@ -128,6 +139,9 @@ def register_economy_income_commands(
         await interaction.response.defer()
         res = await economy.do_crime(interaction.user.id)
         if not res["ok"]:
+            if res["reason"] == "db_error":
+                await reply_db_error(interaction)
+                return
             if res["reason"] == "banned":
                 await interaction.followup.send(S.MSG_BANNED, ephemeral=True)
             elif res["reason"] == "cooldown":
@@ -187,6 +201,9 @@ def register_economy_income_commands(
         await interaction.response.defer()
         res = await economy.do_rob(interaction.user.id, sihtmärk.id)
         if not res["ok"]:
+            if res["reason"] == "db_error":
+                await reply_db_error(interaction)
+                return
             if res["reason"] == "banned":
                 await interaction.followup.send(S.MSG_BANNED, ephemeral=True)
             elif res["reason"] == "cooldown":

commands/economy_prestige_commands.py

@@ -9,6 +9,8 @@ from discord import app_commands
 from core import economy
 import strings as S
 
+from ._replies import reply_db_error
+
 
 def register_prestige_commands(
     tree: app_commands.CommandTree,
@@ -127,6 +129,9 @@ def register_prestige_commands(
                     return
                 await interaction.response.defer()
                 res = await economy.do_prestige(self.user_id)
+                if not res["ok"] and res.get("reason") == "db_error":
+                    await reply_db_error(interaction)
+                    return
                 self.clear_items()
                 if not res["ok"]:
                     embed = discord.Embed(
@@ -166,6 +171,9 @@ def register_prestige_commands(
                 await interaction.response.defer()
                 res = await economy.do_prestige_buy(self.user_id, upgrade_id)
                 if not res["ok"]:
+                    if res["reason"] == "db_error":
+                        await reply_db_error(interaction)
+                        return
                     if res["reason"] == "insufficient_pp":
                         err = S.PRESTIGE_UI["buy_no_pp"].format(have=res["have"], need=res["need"])
                     elif res["reason"] == "maxed":
@@ -221,6 +229,9 @@ def register_prestige_commands(
             return
         res = await economy.do_prestige_buy(interaction.user.id, upgrade.strip().lower())
         if not res["ok"]:
+            if res["reason"] == "db_error":
+                await reply_db_error(interaction)
+                return
             if res["reason"] == "banned":
                 await interaction.response.send_message(S.MSG_BANNED, ephemeral=True)
             elif res["reason"] == "not_found":

commands/economy_profile_commands.py

@@ -10,6 +10,8 @@ from discord import app_commands
 from core import economy
 import strings as S
 
+from ._replies import reply_db_error
+
 
 def register_economy_profile_commands(
     tree: app_commands.CommandTree,
@@ -29,10 +31,15 @@ def register_economy_profile_commands(
         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,
+        badge = economy.vanity_badge(data)
+        title = (
+            f"{badge[0]} {target.display_name}"
+            if badge
+            else S.PROFILE_UI["main_title"].format(name=target.display_name)
         )
+        embed = discord.Embed(title=title, color=0xF4C430)
+        if badge:
+            embed.set_author(name=badge[1])
         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"],
@@ -148,7 +155,12 @@ def register_economy_profile_commands(
         )
         embed.add_field(
             name=S.STATS_UI["records_field"],
-            value=S.STATS_UI["records_val"].format(streak=_s("best_daily_streak")),
+            value=S.STATS_UI["records_val"].format(
+                streak=_s("best_daily_streak"),
+                lootboxes=_s("lootboxes_opened"),
+                achievements=len(data.get("achievements_earned") or []),
+                ach_total=len(economy.ACHIEVEMENTS),
+            ),
             inline=True,
         )
         return embed
@@ -287,6 +299,9 @@ def register_economy_profile_commands(
             color=0xF4C430,
         )
         embed.add_field(name=S.BALANCE_UI["saldo"], value=coin(data["balance"]), inline=True)
+        bank_balance = data.get("bank_balance", 0)
+        if bank_balance:
+            embed.add_field(name=S.BANK_UI["f_bank"], value=coin(bank_balance), inline=True)
         streak = data.get("daily_streak", 0)
         if streak:
             embed.add_field(
@@ -334,6 +349,53 @@ def register_economy_profile_commands(
         data = await economy.get_user(target.id)
         await interaction.response.send_message(embed=_balance_embed(target, data))
 
+    @tree.command(name="achievements", description=S.CMD["achievements"])
+    async def cmd_achievements(
+        interaction: discord.Interaction, kasutaja: discord.Member | None = None
+    ):
+        target = kasutaja or interaction.user
+        note = ""
+        # Only the invoker's own view claims newly-earned achievements.
+        if target.id == interaction.user.id:
+            res = await economy.do_check_achievements(interaction.user.id)
+            if not res["ok"]:
+                await reply_db_error(interaction)
+                return
+            if res["new"]:
+                names = ", ".join(
+                    f"{economy.ACHIEVEMENTS[a]['emoji']} {economy.ACHIEVEMENTS[a]['name']}"
+                    for a in res["new"]
+                )
+                note = S.ACHIEVEMENTS_UI["unlocked_note"].format(
+                    names=names, reward=coin(res["reward"])
+                ) + "\n\n"
+
+        data = await economy.get_user(target.id)
+        rows = economy.achievements_view(data)
+        earned_count = sum(1 for r in rows if r["earned"])
+        lines = [
+            S.ACHIEVEMENTS_UI["row_earned"].format(
+                emoji=r["emoji"], name=r["name"], reward=coin(r["reward"])
+            )
+            if r["earned"]
+            else S.ACHIEVEMENTS_UI["row_locked"].format(
+                emoji=r["emoji"], name=r["name"], progress=r["progress"],
+                goal=r["goal"], reward=coin(r["reward"]),
+            )
+            for r in rows
+        ]
+        title = S.ACHIEVEMENTS_UI["title"]
+        if target.id != interaction.user.id:
+            title += f"  ·  {target.display_name}"
+        embed = discord.Embed(
+            title=title,
+            description=note
+            + S.ACHIEVEMENTS_UI["desc"].format(earned=earned_count, total=len(rows))
+            + "\n\n" + "\n".join(lines),
+            color=0xF4C430,
+        )
+        await interaction.response.send_message(embed=embed)
+
     @tree.command(name="cooldowns", description=S.CMD["cooldowns"])
     async def cmd_cooldowns(interaction: discord.Interaction):
         data = await economy.get_user(interaction.user.id)
@@ -539,7 +601,12 @@ def register_economy_profile_commands(
         )
         embed.add_field(
             name=S.STATS_UI["records_field"],
-            value=S.STATS_UI["records_val"].format(streak=_s("best_daily_streak")),
+            value=S.STATS_UI["records_val"].format(
+                streak=_s("best_daily_streak"),
+                lootboxes=_s("lootboxes_opened"),
+                achievements=len(data.get("achievements_earned") or []),
+                ach_total=len(economy.ACHIEVEMENTS),
+            ),
             inline=True,
         )
         await interaction.response.send_message(embed=embed, ephemeral=True)

commands/economy_support_commands.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import asyncio
 from collections.abc import Callable
 
 import discord
@@ -8,6 +9,8 @@ from discord import app_commands
 from core import economy
 import strings as S
 
+from ._replies import reply_db_error
+
 
 def register_economy_support_commands(
     tree: app_commands.CommandTree,
@@ -47,6 +50,9 @@ def register_economy_support_commands(
             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
+                if res["reason"] == "db_error":
+                    await reply_db_error(interaction)
+                    return
                 data = await economy.get_user(interaction.user.id)
                 await interaction.response.send_message(
                     S.ERR["broke"].format(bal=coin(data["balance"])), ephemeral=True
@@ -212,6 +218,9 @@ def register_economy_support_commands(
 
         res = await economy.do_buy_consumable(interaction.user.id, ese.value)
         if not res["ok"]:
+            if res["reason"] == "db_error":
+                await reply_db_error(interaction)
+                return
             if res["reason"] == "banned":
                 await interaction.response.send_message(S.MSG_BANNED, ephemeral=True)
             elif res["reason"] == "insufficient":
@@ -224,6 +233,10 @@ def register_economy_support_commands(
 
         cons = res["consumable"]
         if res["instant"]:
+            # Kohv wiped these cooldowns, so any reminder DM already scheduled for
+            # them is now stale - cancel it (the next command run reschedules).
+            for cmd in economy.INSTANT_RESET_COMMANDS:
+                cancel_reminder_task(interaction.user.id, cmd)
             desc = S.CONSUMABLES_UI["bought_instant"].format(balance=coin(res["balance"]))
         else:
             key = "bought_extended" if res["extended"] else "bought_buff"
@@ -238,6 +251,181 @@ def register_economy_support_commands(
         )
         await interaction.response.send_message(embed=embed)
 
+    # -- /vanity ------------------------------------------------------------
+    def _vanity_embed(user_data: dict) -> discord.Embed:
+        owned = set(user_data.get("vanity_owned") or [])
+        active = user_data.get("vanity_active")
+        embed = discord.Embed(
+            title=S.VANITY_UI["title"],
+            description=S.VANITY_UI["desc"].format(bal=coin(user_data.get("balance", 0))),
+            color=0xF4C430,
+        )
+        for vid, v in economy.VANITY.items():
+            if vid == active:
+                status = S.VANITY_UI["line_active"]
+            elif vid in owned:
+                status = S.VANITY_UI["line_owned"]
+            else:
+                status = f"{v['cost']} {economy.COIN}"
+            embed.add_field(
+                name=f"{v['emoji']} {v['name']}  ·  {status}",
+                value=S.VANITY_UI["entry_title"].format(title=v["title"]),
+                inline=False,
+            )
+        embed.set_footer(text=S.VANITY_UI["footer"])
+        return embed
+
+    @tree.command(name="vanity", description=S.CMD["vanity"])
+    @app_commands.describe(ese=S.OPT["vanity_ese"])
+    @app_commands.choices(
+        ese=[
+            app_commands.Choice(name=f"{v['emoji']} {v['title']} ({v['cost']} TipiCOINi)", value=vid)
+            for vid, v in economy.VANITY.items()
+        ]
+        + [app_commands.Choice(name=S.VANITY_UI["none_choice"], value=economy.vanity.NONE_ID)]
+    )
+    async def cmd_vanity(
+        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=_vanity_embed(data), ephemeral=True
+            )
+            return
+
+        res = await economy.do_vanity_select(interaction.user.id, ese.value)
+        if not res["ok"]:
+            if res["reason"] == "db_error":
+                await reply_db_error(interaction)
+                return
+            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
+
+        action = res["action"]
+        if action == "unequipped":
+            await interaction.response.send_message(S.VANITY_UI["unequipped"], ephemeral=True)
+            return
+        v = res["vanity"]
+        if action == "bought":
+            msg = S.VANITY_UI["bought"].format(
+                emoji=v["emoji"], title=v["title"], balance=coin(res["balance"])
+            )
+        else:
+            msg = S.VANITY_UI["equipped"].format(emoji=v["emoji"], title=v["title"])
+        await interaction.response.send_message(msg)
+
+    # -- /lootbox -----------------------------------------------------------
+    @tree.command(name="lootbox", description=S.CMD["lootbox"])
+    async def cmd_lootbox(interaction: discord.Interaction):
+        res = await economy.do_open_lootbox(interaction.user.id)
+        if not res["ok"]:
+            if res["reason"] == "db_error":
+                await reply_db_error(interaction)
+            elif res["reason"] == "banned":
+                await interaction.response.send_message(S.MSG_BANNED, ephemeral=True)
+            else:
+                await interaction.response.send_message(
+                    S.ERR["broke_need"].format(need=coin(res["need"])), ephemeral=True
+                )
+            return
+
+        # Suspense: show the box opening, then reveal the reward.
+        await interaction.response.send_message(
+            embed=discord.Embed(
+                title=S.LOOTBOX_UI["title"], description=S.LOOTBOX_UI["opening"], color=0xF4C430
+            )
+        )
+        msg = await interaction.original_response()
+        await asyncio.sleep(1.2)
+
+        if res["buff_kind"]:
+            line = S.LOOTBOX_UI["buff_" + res["buff_kind"]].format(min=res["buff_min"])
+            foot = S.LOOTBOX_UI["foot_buff"].format(balance=coin(res["balance"]))
+            color = 0x5865F2
+        else:
+            line = S.LOOTBOX_UI[res["outcome"]].format(coins=coin(res["reward_coins"]))
+            if res["net"] >= 0:
+                foot = S.LOOTBOX_UI["foot_win"].format(net=coin(res["net"]), balance=coin(res["balance"]))
+                color = 0x57F287
+            else:
+                foot = S.LOOTBOX_UI["foot_loss"].format(net=coin(abs(res["net"])), balance=coin(res["balance"]))
+                color = 0xF4C430 if res["outcome"] != "coins_small" else 0xED4245
+        embed = discord.Embed(title=S.LOOTBOX_UI["title"], description=line, color=color)
+        embed.set_footer(text=foot)
+        await msg.edit(embed=embed)
+
+    # -- /bank, /deposit, /withdraw -----------------------------------------
+    @tree.command(name="bank", description=S.CMD["bank"])
+    async def cmd_bank(interaction: discord.Interaction):
+        data = await economy.get_user(interaction.user.id)
+        embed = discord.Embed(
+            title=S.BANK_UI["title"], description=S.BANK_UI["desc"], color=0xF4C430
+        )
+        embed.add_field(name=S.BANK_UI["f_liquid"], value=coin(data.get("balance", 0)), inline=True)
+        embed.add_field(name=S.BANK_UI["f_bank"], value=coin(data.get("bank_balance", 0)), inline=True)
+        await interaction.response.send_message(embed=embed, ephemeral=True)
+
+    @tree.command(name="deposit", description=S.CMD["deposit"])
+    @app_commands.describe(summa=S.OPT["deposit_summa"])
+    async def cmd_deposit(interaction: discord.Interaction, summa: str):
+        data = await economy.get_user(interaction.user.id)
+        amount, err = parse_amount(summa, data.get("balance", 0))
+        if err or amount is None:
+            await interaction.response.send_message(err or S.ERR["invalid_amount"], ephemeral=True)
+            return
+        if amount <= 0:
+            await interaction.response.send_message(S.ERR["positive_amount"], ephemeral=True)
+            return
+        res = await economy.do_deposit(interaction.user.id, amount)
+        if not res["ok"]:
+            if res["reason"] == "db_error":
+                await reply_db_error(interaction)
+            elif res["reason"] == "banned":
+                await interaction.response.send_message(S.MSG_BANNED, ephemeral=True)
+            else:
+                await interaction.response.send_message(S.BANK_UI["nothing_liquid"], ephemeral=True)
+            return
+        await interaction.response.send_message(
+            S.BANK_UI["deposited"].format(
+                amount=coin(res["amount"]), balance=coin(res["balance"]), bank=coin(res["bank"])
+            )
+        )
+
+    @tree.command(name="withdraw", description=S.CMD["withdraw"])
+    @app_commands.describe(summa=S.OPT["withdraw_summa"])
+    async def cmd_withdraw(interaction: discord.Interaction, summa: str):
+        data = await economy.get_user(interaction.user.id)
+        amount, err = parse_amount(summa, data.get("bank_balance", 0))
+        if err or amount is None:
+            await interaction.response.send_message(err or S.ERR["invalid_amount"], ephemeral=True)
+            return
+        if amount <= 0:
+            await interaction.response.send_message(S.ERR["positive_amount"], ephemeral=True)
+            return
+        res = await economy.do_withdraw(interaction.user.id, amount)
+        if not res["ok"]:
+            if res["reason"] == "db_error":
+                await reply_db_error(interaction)
+            elif res["reason"] == "banned":
+                await interaction.response.send_message(S.MSG_BANNED, ephemeral=True)
+            else:
+                await interaction.response.send_message(S.BANK_UI["nothing_bank"], ephemeral=True)
+            return
+        await interaction.response.send_message(
+            S.BANK_UI["withdrawn"].format(
+                amount=coin(res["amount"]), balance=coin(res["balance"]), bank=coin(res["bank"])
+            )
+        )
+
     class RemindersSelect(discord.ui.Select):
         def __init__(self, user_id: int, current: list[str]):
             self.user_id = user_id

commands/economy_team_commands.py

@@ -1,90 +0,0 @@
-"""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 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()
-        except Exception as e:
-            await interaction.followup.send(
-                S.TEAMSYNC_UI["refresh_error"].format(error=e), ephemeral=True
-            )
-            return
-        if not rosters:
-            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, errors=%d",
-            summary.scanned,
-            summary.assigned,
-            summary.removed,
-            len(summary.created),
-            summary.positioned,
-            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.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/ops_admin_commands.py

@@ -13,9 +13,9 @@ from pathlib import Path
 import discord
 from discord import app_commands
 
+from core import economy
 from core.admin import bot_admin_check
 import strings as S
-from core.admin import bot_admin_check
 
 
 def register_ops_admin_commands(
@@ -45,6 +45,7 @@ def register_ops_admin_commands(
         latency_ms = round(bot.latency * 1000, 1)
         cache_size = get_member_cache_size()
         user_count = await count_economy_users()
+        eco_stats = await economy.get_economy_stats()
 
         embed = discord.Embed(title=S.STATUS_UI["title"], color=0x57F287)
         embed.add_field(
@@ -82,6 +83,18 @@ def register_ops_admin_commands(
             value=str(cache_size),
             inline=True,
         )
+        total = eco_stats["total_coins"]
+        house_pct = round(eco_stats["house_balance"] / total * 100) if total else 0
+        embed.add_field(
+            name=S.STATUS_UI["supply_field"],
+            value=S.STATUS_UI["supply_val"].format(
+                total=f"{total:,}".replace(",", " "),
+                players=f"{eco_stats['player_coins']:,}".replace(",", " "),
+                house=f"{eco_stats['house_balance']:,}".replace(",", " "),
+                house_pct=house_pct,
+            ),
+            inline=False,
+        )
 
         log_lines = [
             S.STATUS_UI["log_line"].format(name=p.name, size_kb=f"{p.stat().st_size / 1024:.1f}")

config.py

@@ -23,9 +23,6 @@ DISCORD_TOKEN = (
 ) 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")
 
 _LEGACY_GUILD_ID = _env_int("GUILD_ID", 0)
@@ -45,6 +42,15 @@ BIRTHDAY_CHANNEL_ID = (
 BIRTHDAY_WINDOW_DAYS = int(os.getenv("BIRTHDAY_WINDOW_DAYS", "7"))
 BASE_ROLE_IDS: list[int] = [1478304631930228779, 1478302278862766190]
 
+# Channel where the daily lottery draw result is announced. Optional - if unset,
+# the draw still runs and pays the winner, it just isn't announced.
+_LEGACY_LOTTERY_CHANNEL_ID = _env_int("LOTTERY_CHANNEL_ID", 0)
+LOTTERY_CHANNEL_ID_DEV = _env_int("LOTTERY_CHANNEL_ID_DEV", _LEGACY_LOTTERY_CHANNEL_ID)
+LOTTERY_CHANNEL_ID_ECONOMY = _env_int("LOTTERY_CHANNEL_ID_ECONOMY", 0)
+LOTTERY_CHANNEL_ID = (
+    LOTTERY_CHANNEL_ID_ECONOMY if BOT_PROFILE == "economy" else LOTTERY_CHANNEL_ID_DEV
+)
+
 
 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...".
@@ -69,43 +75,6 @@ def _parse_admin_roles(raw: str) -> dict[int, set[int]]:
 
 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", "")

core/economy/__init__.py

@@ -16,9 +16,12 @@ from .store import (
 )
 from .house import *
 from .house import _credit_house, _house_record_id
+from .bank import *
 from .levels import *
 from .shop import *
 from .consumables import *
+from .vanity import *
+from .lootbox import *
 from .fishing import *
 from .quests import *
 from .quests import _ensure_quests, _pick_quests, _quest_view
@@ -28,9 +31,12 @@ from .gambling import *
 from .prestige import *
 from .leaderboards import *
 from .heist import *
+from .achievements import *
+from .lottery 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,
+    achievements, admin, bank, consumables, fishing, gambling, heist, house,
+    income, jail, leaderboards, levels, lootbox, lottery, prestige, quests,
+    shop, store, vanity,
 )

core/economy/achievements.py

@@ -0,0 +1,111 @@
+"""Achievements: one-time milestone badges over the lifetime stat counters.
+
+Each achievement watches a monotonic stat the bot already tracks and unlocks once
+that stat crosses a threshold, paying a modest one-time coin reward. Detection is
+lazy: do_check_achievements is called when the player opens /achievements (like
+quests roll on view), so no hook is needed on every command. Rewards are bounded
+(each pays once) so this is a small, capped coin source.
+"""
+
+from __future__ import annotations
+
+from typing import TypedDict
+
+from ..pb_client import DatabaseError
+from .store import _commit, _locked_by, _txn, get_user
+
+__all__ = [
+    "Achievement",
+    "ACHIEVEMENTS",
+    "newly_earned",
+    "achievements_view",
+    "do_check_achievements",
+]
+
+
+class Achievement(TypedDict):
+    stat: str     # UserData counter this milestone watches
+    goal: int
+    name: str
+    emoji: str
+    reward: int   # one-time coin payout
+
+
+# Ordered roughly easy -> hard within each theme. Rewards scale with difficulty.
+ACHIEVEMENTS: dict[str, Achievement] = {
+    # Grind
+    "work_10":     {"stat": "work_count",        "goal": 10,     "name": "Töömesilane",        "emoji": "🐝", "reward": 250},
+    "work_100":    {"stat": "work_count",        "goal": 100,    "name": "Töönarkomaan",       "emoji": "🛠️", "reward": 1_500},
+    "beg_50":      {"stat": "beg_count",         "goal": 50,     "name": "Elukutseline kerjus", "emoji": "🥺", "reward": 500},
+    # Wealth
+    "earned_50k":  {"stat": "lifetime_earned",   "goal": 50_000, "name": "Jõukas",             "emoji": "💰", "reward": 1_000},
+    "earned_500k": {"stat": "lifetime_earned",   "goal": 500_000, "name": "TipiRIKAS",         "emoji": "🤑", "reward": 5_000},
+    # Gambling
+    "wager_10k":   {"stat": "total_wagered",     "goal": 10_000, "name": "Hasartmängur",       "emoji": "🎲", "reward": 750},
+    "wager_100k":  {"stat": "total_wagered",     "goal": 100_000, "name": "Kõrgete panuste mängija", "emoji": "🃏", "reward": 3_000},
+    "jackpot_1":   {"stat": "slots_jackpots",    "goal": 1,      "name": "Jackpot!",           "emoji": "🎰", "reward": 1_000},
+    # Crime & heists
+    "crime_25":    {"stat": "crimes_succeeded",  "goal": 25,     "name": "Kurjategija",        "emoji": "🦹", "reward": 1_000},
+    "heist_5":     {"stat": "heists_won",        "goal": 5,      "name": "Pangaröövel",        "emoji": "💣", "reward": 1_500},
+    # Fishing
+    "fish_25":     {"stat": "total_fish_caught", "goal": 25,     "name": "Kalur",              "emoji": "🎣", "reward": 500},
+    "fish_250":    {"stat": "total_fish_caught", "goal": 250,    "name": "Kalapüügimeister",   "emoji": "🐟", "reward": 3_000},
+    # Dedication
+    "streak_7":    {"stat": "best_daily_streak", "goal": 7,      "name": "Püsiv",              "emoji": "🔥", "reward": 500},
+    "streak_30":   {"stat": "best_daily_streak", "goal": 30,     "name": "Pühendunud",         "emoji": "🗓️", "reward": 2_500},
+    "prestige_1":  {"stat": "prestige_level",    "goal": 1,      "name": "Taassünd",           "emoji": "♻️", "reward": 2_000},
+}
+
+
+def _earned_ids(user) -> set[str]:
+    return set(user.get("achievements_earned") or [])
+
+
+def newly_earned(user) -> list[str]:
+    """Achievement ids whose threshold is met but which are not yet claimed."""
+    earned = _earned_ids(user)
+    return [
+        aid for aid, a in ACHIEVEMENTS.items()
+        if aid not in earned and int(user.get(a["stat"], 0) or 0) >= a["goal"]
+    ]
+
+
+def achievements_view(user) -> list[dict]:
+    """Display rows for every achievement: progress + earned flag (ordered as
+    defined, earned last so unfinished goals surface first)."""
+    earned = _earned_ids(user)
+    rows = []
+    for aid, a in ACHIEVEMENTS.items():
+        prog = int(user.get(a["stat"], 0) or 0)
+        rows.append({
+            "id": aid, "name": a["name"], "emoji": a["emoji"],
+            "goal": a["goal"], "reward": a["reward"],
+            "progress": min(prog, a["goal"]), "earned": aid in earned,
+        })
+    rows.sort(key=lambda r: r["earned"])  # unearned first
+    return rows
+
+
+@_locked_by(0)
+async def do_check_achievements(user_id: int) -> dict:
+    """Claim any newly-earned achievements and pay their one-time rewards."""
+    try:
+        user = await get_user(user_id)
+    except DatabaseError:
+        return {"ok": False, "reason": "db_error"}
+    new = newly_earned(user)
+    if not new:
+        return {"ok": True, "new": [], "reward": 0, "balance": user["balance"]}
+
+    earned = list(user.get("achievements_earned") or [])
+    total = 0
+    for aid in new:
+        earned.append(aid)
+        total += ACHIEVEMENTS[aid]["reward"]
+    user["achievements_earned"] = earned
+    user["balance"] += total
+    user["lifetime_earned"] = user.get("lifetime_earned", 0) + total
+    user["peak_balance"] = max(user.get("peak_balance", 0), user["balance"])
+    await _commit(user_id, user)
+    _txn("ACHIEVEMENTS", user=user_id, unlocked=",".join(new), reward=f"+{total}", bal=user["balance"])
+    return {"ok": True, "new": new, "reward": total, "balance": user["balance"]}

core/economy/admin.py

@@ -22,6 +22,7 @@ async def do_season_reset(top_n: int = 10) -> list[tuple[str, int, int]]:
     reset_fields = {
         "exp": 0,
         "balance": 0,
+        "bank_balance": 0,
         "items": [],
         "item_uses": {},
         "last_daily": None,

core/economy/bank.py

@@ -0,0 +1,63 @@
+"""Bank vault: rob-proof coin storage.
+
+Coins moved to the bank are safe from /rob and /heist (those target the liquid
+`balance` only), but they earn no interest and cannot be spent, gambled or given
+until withdrawn. This is the deliberate trade-off against keeping coins liquid,
+where Bot Farm can earn interest but a robber can take a cut. Net worth
+(balance + bank_balance) is what the coins leaderboard ranks, so banking never
+hides you from the leaderboard.
+"""
+
+from __future__ import annotations
+
+from ..pb_client import DatabaseError
+from .store import _commit, _locked_by, _txn, get_user
+
+__all__ = ["do_deposit", "do_withdraw"]
+
+
+@_locked_by(0)
+async def do_deposit(user_id: int, amount: int) -> dict:
+    """Move `amount` coins from liquid balance into the bank vault."""
+    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 amount <= 0:
+        return {"ok": False, "reason": "invalid"}
+    if user["balance"] < amount:
+        return {"ok": False, "reason": "insufficient", "balance": user["balance"]}
+    user["balance"] -= amount
+    user["bank_balance"] = user.get("bank_balance", 0) + amount
+    try:
+        await _commit(user_id, user)
+    except DatabaseError:
+        return {"ok": False, "reason": "db_error"}
+    _txn("BANK_DEPOSIT", user=user_id, amount=amount, bal=user["balance"], bank=user["bank_balance"])
+    return {"ok": True, "amount": amount, "balance": user["balance"], "bank": user["bank_balance"]}
+
+
+@_locked_by(0)
+async def do_withdraw(user_id: int, amount: int) -> dict:
+    """Move `amount` coins from the bank vault back to liquid balance."""
+    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 amount <= 0:
+        return {"ok": False, "reason": "invalid"}
+    bank = user.get("bank_balance", 0)
+    if bank < amount:
+        return {"ok": False, "reason": "insufficient", "bank": bank}
+    user["bank_balance"] = bank - amount
+    user["balance"] += amount
+    try:
+        await _commit(user_id, user)
+    except DatabaseError:
+        return {"ok": False, "reason": "db_error"}
+    _txn("BANK_WITHDRAW", user=user_id, amount=amount, bal=user["balance"], bank=user["bank_balance"])
+    return {"ok": True, "amount": amount, "balance": user["balance"], "bank": user["bank_balance"]}

core/economy/consumables.py

@@ -23,6 +23,18 @@ from ..pb_client import DatabaseError
 from ..emoji import EMOJI as E
 from .store import _commit, _locked_by, _now, _parse_dt, _txn, get_user
 
+__all__ = [
+    "Consumable",
+    "CONSUMABLES",
+    "INSTANT_RESET_COMMANDS",
+    "active_buffs",
+    "buff_remaining",
+    "earn_mult",
+    "exp_buff_mult",
+    "grant_buff",
+    "do_buy_consumable",
+]
+
 
 class Consumable(TypedDict):
     name: str
@@ -66,6 +78,11 @@ _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")
 
+# The slash-command names whose cooldowns an instant "kohv" clears. The Discord
+# layer uses these to cancel any pending reminder DMs, since the cooldowns they
+# were scheduled for no longer exist.
+INSTANT_RESET_COMMANDS = tuple(f.removeprefix("last_") for f in _COOLDOWN_FIELDS)
+
 
 # ---------------------------------------------------------------------------
 # Buff inspection helpers (pure - safe to call while holding a user lock)
@@ -100,6 +117,19 @@ def exp_buff_mult(user) -> float:
     return _BUFF_MULT["exp"] if "exp" in active_buffs(user) else 1.0
 
 
+def grant_buff(user, kind: str, duration_min: int) -> bool:
+    """Add/extend a timed buff of `kind` on `user` in place. Stacks: extends from
+    the current expiry if still active, else starts now. Returns True if it
+    extended an existing buff. Pure - safe under a user lock (caller commits)."""
+    buffs = dict(user.get("active_buffs") or {})
+    current = _parse_dt(buffs.get(kind))
+    extended = current is not None and current > _now()
+    start = current if extended else _now()
+    buffs[kind] = (start + timedelta(minutes=duration_min)).isoformat()
+    user["active_buffs"] = buffs
+    return extended
+
+
 # ---------------------------------------------------------------------------
 # /consumables purchase
 # ---------------------------------------------------------------------------
@@ -125,13 +155,7 @@ async def do_buy_consumable(user_id: int, cons_id: str) -> dict:
         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
+        extended = grant_buff(user, cons["kind"], cons["duration_min"])
 
     await _commit(user_id, user)
     _txn("BUY_CONSUMABLE", user=user_id, item=cons_id, cost=f"-{cons['cost']}", bal=user["balance"])

core/economy/fishing.py

@@ -3,12 +3,11 @@
 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,
+    _cooldown_remaining, _commit, _is_jailed, _locked_by, _now,
+    _prestige_mult, _txn, effective_cooldown, get_user,
 )
 
 
@@ -81,7 +80,7 @@ async def do_fish_start(user_id: int) -> dict:
     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"]
+    fish_cd = effective_cooldown("fish", user["items"])
     if cd := _cooldown_remaining(user, "fish", override_cd=fish_cd):
         return {"ok": False, "reason": "cooldown", "remaining": cd}
 

core/economy/gambling.py

@@ -6,7 +6,10 @@ 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 .store import (
+    _commit, _is_jailed, _locked_by, _log, _txn, add_pending_wager,
+    clear_pending_wager, get_user,
+)
 from .house import _credit_house
 
 
@@ -105,6 +108,7 @@ async def do_rps_pvp_deposit(user_id: int, bet: int) -> dict:
         return {"ok": False, "reason": "insufficient"}
     user["balance"] -= bet
     user["total_wagered"] = user.get("total_wagered", 0) + bet
+    add_pending_wager(user, "rps", bet)  # escrow survives a restart
     try:
         await _commit(user_id, user)
     except DatabaseError:
@@ -125,6 +129,7 @@ async def do_rps_pvp_payout(winner_id: int, bet: int) -> dict:
     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"])
+    clear_pending_wager(user)  # winner's escrow settled
     try:
         await _commit(winner_id, user)
     except DatabaseError:
@@ -133,6 +138,23 @@ async def do_rps_pvp_payout(winner_id: int, bet: int) -> dict:
     return {"ok": True, "balance": user["balance"]}
 
 
+@_locked_by(0)
+async def do_rps_pvp_forfeit(loser_id: int) -> dict:
+    """Release the loser's escrow marker without refunding - their stake was paid
+    to the winner as part of the 2*bet payout. Without this the loser's
+    pending_wager would linger and be wrongly refunded on the next restart."""
+    try:
+        user = await get_user(loser_id)
+    except DatabaseError:
+        return {"ok": False, "reason": "db_error"}
+    clear_pending_wager(user)
+    try:
+        await _commit(loser_id, user)
+    except DatabaseError:
+        return {"ok": False, "reason": "db_error"}
+    return {"ok": True}
+
+
 @_locked_by(0)
 async def do_rps_pvp_refund(user_id: int, bet: int) -> dict:
     """Refund a previously escrowed bet (tie / timeout / cancel)."""
@@ -142,6 +164,7 @@ async def do_rps_pvp_refund(user_id: int, bet: int) -> dict:
         return {"ok": False, "reason": "db_error"}
     user["balance"] = user.get("balance", 0) + bet
     user["total_wagered"] = max(0, user.get("total_wagered", 0) - bet)
+    clear_pending_wager(user)  # escrow returned
     try:
         await _commit(user_id, user)
     except DatabaseError:
@@ -248,14 +271,29 @@ async def do_blackjack_bet(user_id: int, bet: int) -> dict:
     if user["balance"] < bet:
         return {"ok": False, "reason": "insufficient", "balance": user["balance"]}
     user["balance"] -= bet
-    await _commit(user_id, user)
+    # Escrow the stake in the same commit (accumulates across double/split), so a
+    # restart mid-hand refunds it via reconcile_pending_wagers instead of eating it.
+    add_pending_wager(user, "blackjack", bet)
+    try:
+        await _commit(user_id, user)
+    except DatabaseError:
+        # Deduction never persisted, so the player was not charged - report it
+        # instead of raising through the interaction handler.
+        return {"ok": False, "reason": "db_error"}
     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)
+    """Credit the net payout. House receives the difference when payout < total_invested.
+
+    The stake was already deducted in do_blackjack_bet, so a DB failure here must
+    not raise through the interaction handler and swallow the player's winnings:
+    report db_error like every other mutation so the caller can surface it."""
+    try:
+        user = await get_user(user_id)
+    except DatabaseError:
+        return {"ok": False, "reason": "db_error"}
     user["balance"] += payout
     user["balance"] = max(0, user["balance"])
     user["total_wagered"] = user.get("total_wagered", 0) + total_invested
@@ -267,7 +305,18 @@ async def do_blackjack_payout(user_id: int, payout: int, total_invested: int = 0
     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)
+    clear_pending_wager(user)  # hand settled - release the escrow marker
+    try:
+        await _commit(user_id, user)
+    except DatabaseError:
+        # The stake is already gone (deducted in do_blackjack_bet) and this credit
+        # did not persist. Nothing to roll back locally - log the owed amount so an
+        # admin can reconcile with /admincoins.
+        _log.critical(
+            "blackjack payout commit failed for %s: owed payout=%s (invested=%s)",
+            user_id, payout, total_invested,
+        )
+        return {"ok": False, "reason": "db_error"}
     house_gain = total_invested - payout
     if house_gain > 0:
         await _credit_house(house_gain)

core/economy/heist.py

@@ -8,7 +8,7 @@ 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
+from .house import _credit_house, _refund_house_safe, _debit_house_safe
 
 
 # ---------------------------------------------------------------------------
@@ -98,6 +98,6 @@ async def do_heist_resolve(user_ids: list[int], success: bool) -> dict:
                 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)
+                    await _debit_house_safe(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

@@ -75,9 +75,10 @@ async def _refund_house_safe(amount: int, context: str, related_uid: int) -> Non
         )
 
 
-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."""
+async def _debit_house_safe(amount: int, context: str, uid: int) -> None:
+    """Best-effort atomic debit of `amount` from the house. Compensates a fine
+    that was credited to the house but whose matching user debit failed to persist
+    (the coins must be pulled back out of the house). Logs critical if it fails."""
     if HOUSE_ID is None or amount <= 0:
         return
     try:

core/economy/income.py

@@ -3,15 +3,16 @@
 from __future__ import annotations
 
 import random
-from datetime import date, timedelta
+from datetime import date
 
 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,
+    JAIL_DURATION, PRESTIGE_SHOP, _commit, _cooldown_remaining,
+    _is_jailed, _locked_by, _log, _now, _prestige_mult, _txn, effective_cooldown,
+    get_user,
 )
 from .house import _credit_house
 from .consumables import earn_mult
@@ -29,7 +30,7 @@ async def do_daily(user_id: int) -> dict:
     if user.get("eco_banned"):
         return {"ok": False, "reason": "banned"}
 
-    daily_cd = timedelta(hours=18) if "korvaklapid" in user["items"] else COOLDOWNS["daily"]
+    daily_cd = effective_cooldown("daily", user["items"])
     if cd := _cooldown_remaining(user, "daily", override_cd=daily_cd):
         return {"ok": False, "reason": "cooldown", "remaining": cd}
 
@@ -109,7 +110,7 @@ async def do_work(user_id: int) -> dict:
     if user.get("eco_banned"):
         return {"ok": False, "reason": "banned"}
 
-    work_cd = timedelta(minutes=40) if "monitor" in user["items"] else COOLDOWNS["work"]
+    work_cd = effective_cooldown("work", user["items"])
     if cd := _cooldown_remaining(user, "work", override_cd=work_cd):
         return {"ok": False, "reason": "cooldown", "remaining": cd}
     if jail := _is_jailed(user):
@@ -163,7 +164,7 @@ async def do_beg(user_id: int) -> dict:
     if user.get("eco_banned"):
         return {"ok": False, "reason": "banned"}
 
-    beg_cd = timedelta(minutes=3) if "hiirematt" in user["items"] else COOLDOWNS["beg"]
+    beg_cd = effective_cooldown("beg", user["items"])
     if cd := _cooldown_remaining(user, "beg", override_cd=beg_cd):
         return {"ok": False, "reason": "cooldown", "remaining": cd}
 

core/economy/leaderboards.py

@@ -3,14 +3,21 @@
 from __future__ import annotations
 
 from .. import pb_client
+from . import house
 from .levels import get_level
 
 
+def _net_worth(r: dict) -> int:
+    """Coins that count toward wealth: liquid balance + banked vault."""
+    return (r.get("balance", 0) or 0) + (r.get("bank_balance", 0) or 0)
+
+
 async def get_leaderboard(top_n: int | None = 10) -> list[tuple[str, int]]:
-    """Return top_n (user_id_str, balance) pairs sorted descending."""
+    """Return top_n (user_id_str, net_worth) pairs sorted descending.
+    Net worth = balance + bank_balance, so banking coins does not hide them."""
     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")),
+        ((r["user_id"], _net_worth(r)) for r in records if r.get("user_id")),
         key=lambda x: x[1],
         reverse=True,
     )
@@ -80,3 +87,60 @@ async def get_leaderboard_fish(top_n: int | None = 10) -> list[tuple[str, int]]:
         reverse=True,
     )
     return result if top_n is None else result[:top_n]
+
+
+async def get_all_leaderboards() -> dict[str, list[tuple]]:
+    """Build every leaderboard view from a SINGLE collection scan.
+
+    /leaderboard shows six tabs; calling each get_leaderboard_* separately would
+    read the whole collection six times. This reads once and sorts in memory,
+    returning the same tuple shapes the individual functions produce (unbounded -
+    the command paginates)."""
+    records = await pb_client.list_all_records()
+    users = [r for r in records if r.get("user_id")]
+
+    def desc(keyfn) -> list[dict]:
+        return sorted(users, key=keyfn, reverse=True)
+
+    return {
+        "coins":    [(r["user_id"], _net_worth(r))
+                     for r in desc(_net_worth)],
+        "exp":      [(r["user_id"], r.get("exp", 0), get_level(r.get("exp", 0)))
+                     for r in desc(lambda r: r.get("exp", 0))],
+        "season":   [(r["user_id"], r.get("season_total_exp", 0), r.get("prestige_level", 0))
+                     for r in desc(lambda r: r.get("season_total_exp", 0))],
+        "prestige": [(r["user_id"], r.get("prestige_level", 0), r.get("prestige_points", 0))
+                     for r in desc(lambda r: (r.get("prestige_level", 0), r.get("prestige_points", 0)))],
+        "wagered":  [(r["user_id"], r.get("total_wagered", 0))
+                     for r in desc(lambda r: r.get("total_wagered", 0))],
+        "fish":     [(r["user_id"], r.get("total_fish_caught", 0))
+                     for r in desc(lambda r: r.get("total_fish_caught", 0))],
+    }
+
+
+async def get_economy_stats() -> dict[str, int]:
+    """Money-supply snapshot from a single scan: total coins in circulation, how
+    much players hold vs. the house. Lets /status show whether the sinks (house,
+    vanity burn, bail, fines) are keeping pace with minted income."""
+    records = await pb_client.list_all_records()
+    house_id = str(house.HOUSE_ID) if house.HOUSE_ID is not None else None
+    total = 0
+    house_balance = 0
+    player_count = 0
+    for r in records:
+        uid = r.get("user_id")
+        if not uid:
+            continue
+        # Banked coins are still part of the money supply.
+        worth = (r.get("balance", 0) or 0) + (r.get("bank_balance", 0) or 0)
+        total += worth
+        if uid == house_id:
+            house_balance = worth
+        else:
+            player_count += 1
+    return {
+        "total_coins": total,
+        "house_balance": house_balance,
+        "player_coins": total - house_balance,
+        "player_count": player_count,
+    }

core/economy/lootbox.py

@@ -0,0 +1,91 @@
+"""Mystery box (/lootbox): a pay-to-open coin sink with a weighted reward.
+
+Buying always burns LOOTBOX_COST; the reward is usually worth less than the cost
+(a deliberate sink, like consumables/vanity) but occasionally pays out big or
+grants a timed buff. All randomness lives in do_open_lootbox so it stays a single,
+testable core function; the command layer only renders the result.
+"""
+
+from __future__ import annotations
+
+import random
+
+from ..pb_client import DatabaseError
+from .store import _commit, _locked_by, _txn, get_user
+from .consumables import grant_buff
+
+__all__ = ["LOOTBOX_COST", "do_open_lootbox"]
+
+LOOTBOX_COST = 1_000
+_BUFF_DURATION_MIN = 30
+
+# (weight, outcome_key). Weights need not sum to 100. Coin outcomes roll an
+# amount in the ranges below; "buff" grants a random 30-min earn/exp boost.
+_OUTCOMES: list[tuple[int, str]] = [
+    (42, "coins_small"),   # usually a net loss - the sink
+    (28, "coins_medium"),
+    (15, "buff"),
+    (10, "coins_big"),
+    (5,  "jackpot"),
+]
+
+_COIN_RANGES: dict[str, tuple[int, int]] = {
+    "coins_small":  (50, 500),
+    "coins_medium": (500, 1_200),
+    "coins_big":    (1_200, 2_500),
+    "jackpot":      (4_000, 9_000),
+}
+
+_BUFF_KINDS = ("earn", "exp")
+
+
+@_locked_by(0)
+async def do_open_lootbox(user_id: int) -> dict:
+    """Charge LOOTBOX_COST and grant one weighted reward. Returns the outcome."""
+    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 user["balance"] < LOOTBOX_COST:
+        return {"ok": False, "reason": "insufficient", "need": LOOTBOX_COST - user["balance"]}
+
+    user["balance"] -= LOOTBOX_COST
+
+    outcome = random.choices(
+        [k for _, k in _OUTCOMES], weights=[w for w, _ in _OUTCOMES], k=1
+    )[0]
+
+    reward_coins = 0
+    buff_kind = None
+    if outcome == "buff":
+        buff_kind = random.choice(_BUFF_KINDS)
+        grant_buff(user, buff_kind, _BUFF_DURATION_MIN)
+    else:
+        lo, hi = _COIN_RANGES[outcome]
+        reward_coins = random.randint(lo, hi)
+        user["balance"] += reward_coins
+        user["lifetime_earned"] = user.get("lifetime_earned", 0) + reward_coins
+        user["peak_balance"] = max(user.get("peak_balance", 0), user["balance"])
+        if outcome == "jackpot":
+            user["biggest_win"] = max(user.get("biggest_win", 0), reward_coins)
+
+    net = reward_coins - LOOTBOX_COST
+    user["lootboxes_opened"] = user.get("lootboxes_opened", 0) + 1
+    await _commit(user_id, user)
+    _txn(
+        "LOOTBOX", user=user_id, outcome=outcome,
+        reward=f"+{reward_coins}" if reward_coins else (buff_kind or "-"),
+        net=f"{net:+}", bal=user["balance"],
+    )
+
+    return {
+        "ok": True,
+        "outcome": outcome,
+        "reward_coins": reward_coins,
+        "buff_kind": buff_kind,
+        "buff_min": _BUFF_DURATION_MIN if buff_kind else 0,
+        "net": net,
+        "balance": user["balance"],
+    }

core/economy/lottery.py

@@ -0,0 +1,149 @@
+"""Daily lottery: buy tickets, one weighted winner takes the whole pot.
+
+Coin flow is conserved without any shared pot record: each ticket's cost is
+deducted from the buyer at purchase, and at draw time the winner is credited
+exactly the sum of every ticket's cost (tickets * TICKET_COST). More tickets =
+higher win chance (weighted draw). Ticket state lives on each user's own record
+keyed by the draw period, so a full scan is only needed at draw time and for the
+/lottery pot view - never on the hot path.
+
+The period is a draw-date ISO string computed by the caller (Tallinn-time aware);
+core functions take it explicitly so they stay timezone-agnostic and testable.
+"""
+
+from __future__ import annotations
+
+import random
+from datetime import timedelta
+
+from .. import pb_client
+from ..pb_client import DatabaseError
+from .store import _commit, _txn, _user_lock, get_user
+
+__all__ = [
+    "TICKET_COST",
+    "MAX_TICKETS_PER_DRAW",
+    "DRAW_HOUR",
+    "period_for",
+    "do_buy_ticket",
+    "do_lottery_draw",
+    "get_lottery_state",
+]
+
+TICKET_COST = 200
+MAX_TICKETS_PER_DRAW = 100  # per-user cap so one whale can't guarantee a win
+DRAW_HOUR = 21  # Tallinn-time hour the daily draw fires
+
+
+def period_for(now_local) -> str:
+    """Draw-date (ISO) that tickets bought at `now_local` (a tz-aware local
+    datetime) count toward: today before DRAW_HOUR, else tomorrow (today's draw
+    has already fired). The draw loop itself draws for `now_local.date()`."""
+    d = now_local.date()
+    if now_local.hour >= DRAW_HOUR:
+        d = d + timedelta(days=1)
+    return d.isoformat()
+
+
+async def do_buy_ticket(user_id: int, count: int, period: str) -> dict:
+    """Buy `count` tickets for the draw on `period`. Deducts count*TICKET_COST."""
+    if count <= 0:
+        return {"ok": False, "reason": "invalid"}
+    async with _user_lock(user_id):
+        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"}
+        # A new period resets any tickets left over from a previous draw.
+        held = user.get("lottery_tickets", 0) if user.get("lottery_period") == period else 0
+        if held + count > MAX_TICKETS_PER_DRAW:
+            return {"ok": False, "reason": "max_tickets", "held": held, "cap": MAX_TICKETS_PER_DRAW}
+        cost = count * TICKET_COST
+        if user["balance"] < cost:
+            return {"ok": False, "reason": "insufficient", "need": cost - user["balance"]}
+        user["balance"] -= cost
+        user["lottery_tickets"] = held + count
+        user["lottery_period"] = period
+        try:
+            await _commit(user_id, user)
+        except DatabaseError:
+            return {"ok": False, "reason": "db_error"}
+        _txn("LOTTERY_BUY", user=user_id, tickets=count, period=period, cost=f"-{cost}", bal=user["balance"])
+        return {
+            "ok": True,
+            "bought": count,
+            "tickets": user["lottery_tickets"],
+            "cost": cost,
+            "balance": user["balance"],
+        }
+
+
+def _participants(records: list[dict], period: str) -> list[tuple[str, int]]:
+    """(user_id, tickets) for everyone holding tickets for `period`."""
+    out = []
+    for r in records:
+        uid = r.get("user_id")
+        if uid and r.get("lottery_period") == period and (r.get("lottery_tickets", 0) or 0) > 0:
+            out.append((uid, int(r["lottery_tickets"])))
+    return out
+
+
+async def get_lottery_state(period: str, user_id: int | None = None) -> dict:
+    """Pot / participant snapshot for the /lottery view."""
+    records = await pb_client.list_all_records()
+    parts = _participants(records, period)
+    total_tickets = sum(t for _, t in parts)
+    your_tickets = 0
+    if user_id is not None:
+        your_tickets = next((t for uid, t in parts if uid == str(user_id)), 0)
+    return {
+        "pot": total_tickets * TICKET_COST,
+        "total_tickets": total_tickets,
+        "participants": len(parts),
+        "your_tickets": your_tickets,
+        "ticket_cost": TICKET_COST,
+    }
+
+
+async def do_lottery_draw(period: str) -> dict | None:
+    """Draw the winner for `period` and credit them the whole pot (minted, since
+    ticket costs were burned at purchase - net conserved). Returns the result, or
+    None if nobody entered."""
+    records = await pb_client.list_all_records()
+    parts = _participants(records, period)
+    if not parts:
+        return None
+    total_tickets = sum(t for _, t in parts)
+    pot = total_tickets * TICKET_COST
+    winner_id = int(random.choices(
+        [uid for uid, _ in parts], weights=[t for _, t in parts], k=1
+    )[0])
+    winner_tickets = next(t for uid, t in parts if uid == str(winner_id))
+
+    async with _user_lock(winner_id):
+        try:
+            winner = await get_user(winner_id)
+        except DatabaseError:
+            return {"ok": False, "reason": "db_error", "winner_id": winner_id, "pot": pot}
+        winner["balance"] += pot
+        winner["lifetime_earned"] = winner.get("lifetime_earned", 0) + pot
+        winner["biggest_win"] = max(winner.get("biggest_win", 0), pot)
+        winner["peak_balance"] = max(winner.get("peak_balance", 0), winner["balance"])
+        winner["lottery_tickets"] = 0  # consumed
+        try:
+            await _commit(winner_id, winner)
+        except DatabaseError:
+            return {"ok": False, "reason": "db_error", "winner_id": winner_id, "pot": pot}
+    _txn("LOTTERY_DRAW", winner=winner_id, period=period, pot=f"+{pot}",
+         tickets=winner_tickets, total_tickets=total_tickets, players=len(parts))
+    return {
+        "ok": True,
+        "winner_id": winner_id,
+        "pot": pot,
+        "winner_tickets": winner_tickets,
+        "total_tickets": total_tickets,
+        "participants": len(parts),
+        "win_chance": winner_tickets / total_tickets,
+    }

core/economy/quests.py

@@ -32,7 +32,7 @@ QUESTS_DAILY: dict[str, QuestDef] = {
     "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},
+    "give200":   {"stat": "total_given",       "goal": 200,   "coins": 100,  "exp": 15},
 }
 
 QUESTS_WEEKLY: dict[str, QuestDef] = {

core/economy/store.py

@@ -87,6 +87,26 @@ COOLDOWNS: dict[str, timedelta] = {
     "fish":   timedelta(minutes=2),
 }
 
+# Items that shorten a command's cooldown: command -> (item_id, reduced cooldown).
+# Single source of truth so the cooldown check (do_*), the reminder scheduler
+# (_maybe_remind) and the restart restore (_restore_reminders) never drift apart.
+ITEM_COOLDOWNS: dict[str, tuple[str, timedelta]] = {
+    "work":  ("monitor",     timedelta(minutes=40)),
+    "beg":   ("hiirematt",   timedelta(minutes=3)),
+    "daily": ("korvaklapid", timedelta(hours=18)),
+    "fish":  ("ussipurk",    timedelta(seconds=90)),
+}
+
+
+def effective_cooldown(cmd: str, items) -> timedelta | None:
+    """The cooldown for `cmd` given the user's owned `items`, applying any
+    item-based reduction. Returns None for commands with no cooldown."""
+    override = ITEM_COOLDOWNS.get(cmd)
+    if override is not None and override[0] in items:
+        return override[1]
+    return COOLDOWNS.get(cmd)
+
+
 JAIL_DURATION  = timedelta(minutes=30)
 HEIST_JAIL     = timedelta(hours=1, minutes=30)
 
@@ -94,7 +114,8 @@ HEIST_JAIL     = timedelta(hours=1, minutes=30)
 # User schema
 # ---------------------------------------------------------------------------
 class UserData(TypedDict, total=False):
-    balance: int
+    balance: int                    # liquid coins - spendable, gamblable, robbable
+    bank_balance: int               # vaulted coins - safe from /rob and /heist, not spendable until withdrawn
     exp: int                        # lifetime EXP (resets each season)
     last_daily: str | None
     last_work: str | None
@@ -107,6 +128,8 @@ class UserData(TypedDict, total=False):
     items: list[str]
     item_uses: dict                 # {item_id: remaining_uses} for consumables
     active_buffs: dict              # {buff_kind: expiry_iso} for timed consumable boosts
+    vanity_owned: list[str]         # cosmetic badge ids the user has purchased
+    vanity_active: str | None       # currently-equipped vanity badge id (shown on /profile)
     jailed_until: str | None       # ISO datetime or None
     jailbreak_used: bool
     reminders: list[str]           # command names user wants DM reminders for
@@ -130,6 +153,10 @@ class UserData(TypedDict, total=False):
     total_given: int
     total_received: int
     best_daily_streak: int
+    lootboxes_opened: int
+    achievements_earned: list         # ids of achievements already claimed
+    lottery_tickets: int              # tickets held for the current lottery period
+    lottery_period: str | None        # draw-date the held tickets count for (ISO date)
     heist_global_cd_until: float
     # Prestige system
     prestige_level: int
@@ -144,11 +171,17 @@ class UserData(TypedDict, total=False):
     # Quest system
     quest_daily: dict               # {"date": "YYYY-MM-DD", "quests": {qid: {snap, claimed}}}
     quest_weekly: dict              # {"week": "YYYY-Www",   "quests": {qid: {snap, claimed}}}
+    # Coins a running interactive game (blackjack/RPS PvP) has deducted but not
+    # yet settled. {"kind": ..., "amount": int, "ts": iso} while escrowed, {}
+    # otherwise. Reconciled (refunded) on startup so a restart mid-game never
+    # eats the stake. See reconcile_pending_wagers.
+    pending_wager: dict
 
 
 def _default_user() -> UserData:
     return {
         "balance": 0,
+        "bank_balance": 0,
         "exp": 0,
         "last_daily": None,
         "last_work": None,
@@ -161,6 +194,8 @@ def _default_user() -> UserData:
         "items": [],
         "item_uses": {},
         "active_buffs": {},
+        "vanity_owned": [],
+        "vanity_active": None,
         "jailed_until": None,
         "jailbreak_used": False,
         "reminders": ["daily", "work", "beg", "crime", "rob"],
@@ -184,6 +219,10 @@ def _default_user() -> UserData:
         "total_given":     0,
         "total_received":  0,
         "best_daily_streak": 0,
+        "lootboxes_opened": 0,
+        "achievements_earned": [],
+        "lottery_tickets": 0,
+        "lottery_period": None,
         "heist_global_cd_until": 0.0,
         # ── Prestige ─────────────────────────────────────────────────────────
         "prestige_level":    0,
@@ -198,6 +237,8 @@ def _default_user() -> UserData:
         # ── Quests ───────────────────────────────────────────────────────────
         "quest_daily":       {},
         "quest_weekly":      {},
+        # ── Interactive-game escrow (blackjack / RPS PvP) ────────────────────
+        "pending_wager":     {},
     }
 
 
@@ -375,6 +416,59 @@ async def _commit(user_id: int, user: UserData) -> dict | None:
         raise DatabaseError(f"Failed to persist user {user_id}: {exc}") from exc
 
 
+# ---------------------------------------------------------------------------
+# Pending-wager escrow (interactive games survive a restart)
+# ---------------------------------------------------------------------------
+# Interactive games (blackjack, RPS PvP) deduct a stake up front and hold it in
+# an in-memory View until the hand resolves. A restart would drop the View and
+# lose the coins. To prevent that, the deduction commit also records the escrowed
+# amount on the user (add_pending_wager), the settlement commit clears it
+# (clear_pending_wager), and reconcile_pending_wagers refunds anything still
+# outstanding at startup. All three mutate the user dict in place so the escrow
+# state rides along in the SAME commit as the balance change (atomic).
+def add_pending_wager(user: UserData, kind: str, amount: int) -> None:
+    """Record/accumulate `amount` coins as escrowed by a `kind` game."""
+    pw = dict(user.get("pending_wager") or {})
+    pw = {
+        "kind": kind,
+        "amount": int(pw.get("amount", 0) or 0) + amount,
+        "ts": _now().isoformat(),
+    }
+    user["pending_wager"] = pw
+
+
+def clear_pending_wager(user: UserData) -> None:
+    """Mark the user's escrow settled (call in the settlement commit)."""
+    user["pending_wager"] = {}
+
+
+async def reconcile_pending_wagers() -> list[tuple[int, int, str]]:
+    """Refund every stake left escrowed by a game that a restart interrupted.
+
+    Runs once at startup (before commands are served). Returns the list of
+    (user_id, refunded_amount, kind) so the caller can log a summary."""
+    refunded: list[tuple[int, int, str]] = []
+    for uid_str, snapshot in (await get_all_users_raw()).items():
+        pw = snapshot.get("pending_wager") or {}
+        if int(pw.get("amount", 0) or 0) <= 0:
+            continue
+        uid = int(uid_str)
+        async with _user_lock(uid):
+            user = await get_user(uid)
+            pw = user.get("pending_wager") or {}
+            amount = int(pw.get("amount", 0) or 0)
+            if amount <= 0:
+                continue
+            kind = str(pw.get("kind", "?"))
+            user["balance"] += amount
+            clear_pending_wager(user)
+            await _commit(uid, user)
+            _txn("WAGER_RECONCILE", user=uid, refund=f"+{amount}", kind=kind, bal=user["balance"])
+            _log.info("Refunded interrupted %s wager: %s coins to user %s", kind, amount, uid)
+            refunded.append((uid, amount, kind))
+    return refunded
+
+
 # ---------------------------------------------------------------------------
 # /reminders
 # ---------------------------------------------------------------------------

core/economy/vanity.py

@@ -0,0 +1,98 @@
+"""Vanity shop: cosmetic badges/titles - a pure status sink for the wealthy.
+
+No gameplay effect whatsoever. Buying burns the coins (they are NOT credited
+to the house, so they leave circulation for good) and unlocks a badge the
+player can equip; the equipped badge shows on /profile. Prices scale steeply
+on purpose - this is where the richest players dump coins for bragging rights,
+draining the top end of the economy where inflation hurts most.
+
+A single entry point, do_vanity_select, handles buy / equip / unequip so the
+whole feature fits one slash command.
+"""
+
+from __future__ import annotations
+
+from typing import TypedDict
+
+from ..pb_client import DatabaseError
+from .store import _commit, _locked_by, _txn, get_user
+
+__all__ = [
+    "Vanity",
+    "VANITY",
+    "NONE_ID",
+    "vanity_badge",
+    "do_vanity_select",
+]
+
+
+class Vanity(TypedDict):
+    name: str    # short shop name
+    emoji: str   # the badge shown next to the player
+    title: str   # the flavour title shown on /profile
+    cost: int
+
+
+# Ordered cheapest -> priciest: a LAN/gaming status ladder from casual couch
+# gamer to LAN legend. The top rungs are the deliberate whale sink.
+VANITY: dict[str, Vanity] = {
+    "couch":   {"name": "Sohvapadi",     "emoji": "🎮", "title": "Sohvasõdur",          "cost": 5_000},
+    "cables":  {"name": "Võrgukaabel",   "emoji": "🔌", "title": "Kaablihaldur",        "cost": 8_000},
+    "discord": {"name": "Peakomplekt",   "emoji": "🎧", "title": "Discordi Admin",      "cost": 12_000},
+    "aimbot":  {"name": "Kahtlane Hiir", "emoji": "🖱️", "title": "Aimbot Kahtlusalune", "cost": 18_000},
+    "sniper":  {"name": "360Hz Monitor", "emoji": "🎯", "title": "Snaipripüss",         "cost": 25_000},
+    "champ":   {"name": "Meistrikarikas", "emoji": "🏆", "title": "Turniirivõitja",     "cost": 40_000},
+    "legend":  {"name": "Mängurijaam",   "emoji": "🖥️", "title": "LAN Legend",          "cost": 75_000},
+}
+
+# Sentinel choice value that unequips the active badge.
+NONE_ID = "none"
+
+
+def vanity_badge(user) -> tuple[str, str] | None:
+    """Return (emoji, title) for the user's equipped badge, or None."""
+    vid = user.get("vanity_active")
+    vanity = VANITY.get(vid) if vid else None
+    return (vanity["emoji"], vanity["title"]) if vanity else None
+
+
+@_locked_by(0)
+async def do_vanity_select(user_id: int, vanity_id: str) -> dict:
+    """Buy (if unowned), equip (if owned), or unequip (NONE_ID) a badge."""
+    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 vanity_id == NONE_ID:
+        user["vanity_active"] = None
+        await _commit(user_id, user)
+        _txn("VANITY_UNEQUIP", user=user_id)
+        return {"ok": True, "action": "unequipped"}
+
+    if vanity_id not in VANITY:
+        return {"ok": False, "reason": "not_found"}
+
+    owned = list(user.get("vanity_owned") or [])
+    vanity = VANITY[vanity_id]
+
+    # Already owned -> just equip it (free).
+    if vanity_id in owned:
+        user["vanity_active"] = vanity_id
+        await _commit(user_id, user)
+        _txn("VANITY_EQUIP", user=user_id, item=vanity_id)
+        return {"ok": True, "action": "equipped", "vanity": vanity}
+
+    # Not owned -> purchase (burns the coins) and auto-equip.
+    if user["balance"] < vanity["cost"]:
+        return {"ok": False, "reason": "insufficient", "need": vanity["cost"] - user["balance"]}
+
+    user["balance"] -= vanity["cost"]          # burned: not credited to the house
+    owned.append(vanity_id)
+    user["vanity_owned"] = owned
+    user["vanity_active"] = vanity_id
+    await _commit(user_id, user)
+    _txn("VANITY_BUY", user=user_id, item=vanity_id, cost=f"-{vanity['cost']}", bal=user["balance"])
+    return {"ok": True, "action": "bought", "vanity": vanity, "balance": user["balance"]}

core/member_sync.py

@@ -48,6 +48,7 @@ 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
     birthday_today: bool = False
     not_found: bool = False
@@ -56,32 +57,7 @@ class SyncResult:
 
     @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
-    errors: list[str] = field(default_factory=list)
-
-    @property
-    def changed(self) -> bool:
-        return bool(self.added or self.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
-    changes: list[str] = field(default_factory=list)  # human-readable per-member lines
-    errors: list[str] = field(default_factory=list)
+        return self.nickname_changed or self.roles_added or self.roles_removed
 
 
 def _format_nickname(full_name: str) -> str:
@@ -248,222 +224,6 @@ async def sync_member(
     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).
-
-    Only role NAMES present in the team sheet 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 = sheets.get_team_for_username(member.name)
-    all_teams = sheets.all_team_names()
-    if not all_teams:
-        return result  # feature switched off (no team sheet loaded)
-
-    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}")
-
-    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_dividers = sheets.get_team_dividers()  # {team: divider role ID}
-    if not team_dividers:
-        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_dividers.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}")
-        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.changed:
-            bits: list[str] = []
-            if res.added:
-                bits.append(f"+{res.added}")
-            if res.removed:
-                bits.append("-" + ", -".join(res.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,

core/sheets.py

@@ -8,8 +8,6 @@ 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
@@ -252,248 +250,3 @@ def _add_new_member_row_sync(username: str, discord_id: int) -> None:
 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)

docs/DEV_NOTES.md

@@ -16,10 +16,10 @@ The codebase is split into **`core/`** (domain logic), **`commands/`** (Discord
 
 | 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/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`, `ITEM_COOLDOWNS`/`effective_cooldown`, `JAIL_DURATION`, `COIN`, `get_user`/`_commit`/`_txn`, `pending_wager` escrow + `reconcile_pending_wagers`), `income.py`, `gambling.py`, `fishing.py`, `jail.py`, `heist.py`, `prestige.py`, `shop.py`, `consumables.py` (timed buffs + `grant_buff`), `vanity.py` (cosmetic badges), `lootbox.py` (mystery box), `bank.py` (rob-proof vault), `achievements.py` (milestone badges), `lottery.py` (daily draw), `levels.py`, `quests.py`, `leaderboards.py` (incl. `get_all_leaderboards`/`get_economy_stats`, net-worth = balance+bank), `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 |
+| `core/member_sync.py` | Birthday/member sync helpers |
 
 ### `commands/` - one slash-command group per file
 
@@ -31,10 +31,10 @@ Each file exposes a `register_<group>_commands(tree, bot, ...)` function. `bot.p
 | `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_extra_commands.py` | `/heist`, `/jailbreak`, `/reminders`, `/request`, `/give`, `/lottery`, `/leaderboard`, ... |
 | `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_profile_commands.py` | `/balance`, `/rank`, `/stats`, `/cooldowns`, `/achievements` |
+| `commands/economy_support_commands.py` | `/shop`, `/buy`, `/economysetup`, `/consumables`, `/vanity`, `/lootbox`, `/bank`, `/deposit`, `/withdraw` |
 | `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` |
@@ -58,7 +58,7 @@ Pick the `commands/economy_*_commands.py` file that matches the new command's ca
 Checklist - do all of these, in order:
 
 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. **`core/economy/store.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. Compute the effective cooldown in `do_<cmd>` with `effective_cooldown("<cmd>", user["items"])` rather than an inline `timedelta(...) if item in items else ...`
 3. **`core/economy/levels.py`** - add the EXP reward to `EXP_REWARDS` dict
 4. **`strings/commands.py` `CMD`** - add the slash command description
 5. **`strings/commands.py` `OPT`** - add any parameter descriptions
@@ -66,11 +66,11 @@ Checklist - do all of these, in order:
 7. **`strings/common.py` `ERR`** - add any error messages (banned, cooldown uses `CD_MSG`, jailed uses `CD_MSG["jailed"]`)
 8. **`strings/common.py` `CD_MSG`** - add cooldown message if command has a cooldown
 9. **`strings/commands.py` `HELP_CATEGORIES["tipibot"]["fields"]`** - add the command to the help embed
-10. **`commands/economy_<group>_commands.py`** - inside `register_*_commands`, add `@tree.command(name="<cmd>", ...)` `cmd_<name>`; 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. If `do_<cmd>` can return `db_error` (any function that calls `get_user`/`_commit`), handle it first in the failure block with `await reply_db_error(interaction); return` (import from `._replies`) - otherwise a DB outage hangs the deferred interaction or shows a misleading message
 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. **`commands/economy_<group>_commands.py`** - call `await award_exp(interaction, economy.EXP_REWARDS["<cmd>"])` on success
 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 (this helper still lives in `bot.py` and is shared across all command modules)
+14. **`core/economy/store.py` `ITEM_COOLDOWNS`** - if an item shortens the command's cooldown, add `"<cmd>": ("<item_id>", timedelta(...))` here. This is the single source of truth: `effective_cooldown` (used by `do_<cmd>`), `_maybe_remind`, and `_restore_reminders` all read it, so you no longer edit the reminder helpers by hand
 
 ---
 
@@ -116,7 +116,7 @@ All economy state is stored in **PocketBase** (`economy_users` collection). `cor
 
 | Command | Cooldown | Base Earn | Notes |
 |---|---|---|---|
-| `/daily` | 20h (18h w/ korvaklapid) | 150⬡ | ×streak multiplier, ×2 w/ lan_pass, +5% interest w/ gaming_laptop |
+| `/daily` | 20h (18h w/ korvaklapid) | 150⬡ | ×streak multiplier, ×2 w/ lan_pass, +25⬡ w/ korvaklapid, +5% interest w/ gaming_laptop |
 | `/work` | 1h (40min w/ monitor) | 15-75⬡ | ×1.5 w/ gaming_hiir, ×1.25 w/ reguleeritav_laud, ×3 30% chance w/ energiajook |
 | `/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 |
@@ -148,37 +148,6 @@ Gambling EXP is bet-scaled via `gamble_exp(bet)`; fish EXP is per-species in `FI
 
 ---
 
-## 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.
-
----
-
 ## Role Hierarchy (Discord)
 
 Order top to bottom in server roles:

scripts/sync_pb_schema.py

@@ -34,10 +34,12 @@ 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
+# _default_user() keys with a None/str default that PocketBase stores as text
+# (ISO date/datetime strings, plus the vanity badge id).
 _TEXT_FIELDS = {
     "last_daily", "last_work", "last_beg", "last_crime", "last_rob",
     "last_heist", "last_fish", "last_streak_date", "jailed_until",
+    "vanity_active", "lottery_period",
 }
 
 

strings/__init__.py

@@ -44,7 +44,6 @@ from .member import (
     BIRTHDAY_UI,
     BIRTHDAY_MONTHS,
     CHECK_UI,
-    TEAMSYNC_UI,
 )
 
 from .economy import (
@@ -59,6 +58,11 @@ from .economy import (
     ITEM_DESCRIPTIONS,
     CONSUMABLES_UI,
     CONSUMABLE_DESCRIPTIONS,
+    VANITY_UI,
+    LOOTBOX_UI,
+    BANK_UI,
+    ACHIEVEMENTS_UI,
+    LOTTERY_UI,
     JAILED_UI,
     SHOP_BTN,
     DAILY_UI,
@@ -140,7 +144,6 @@ __all__ = [
     'BIRTHDAY_UI',
     'BIRTHDAY_MONTHS',
     'CHECK_UI',
-    'TEAMSYNC_UI',
     'WORK_JOBS',
     'BEG_LINES',
     'BEG_JAIL_LINES',
@@ -152,6 +155,11 @@ __all__ = [
     'ITEM_DESCRIPTIONS',
     'CONSUMABLES_UI',
     'CONSUMABLE_DESCRIPTIONS',
+    'VANITY_UI',
+    'LOOTBOX_UI',
+    'BANK_UI',
+    'ACHIEVEMENTS_UI',
+    'LOTTERY_UI',
     'JAILED_UI',
     'SHOP_BTN',
     'DAILY_UI',

strings/admin.py

@@ -19,6 +19,9 @@ ADMINVIEW_UI: dict[str, str] = {
     "banned_yes":      "🚫 JAH",
     "banned_no":       "✅ Ei",
     "f_balance":       "💰 Saldo",
+    "f_bank":          "🏦 Pangas",
+    "f_extras":        "🏅 Muu",
+    "extras_val":      "Saavutusi: {ach}\nÕnnekaste: {lootboxes}\nOotel panus: {wager}",
     "f_exp":           "📊 EXP / Tase",
     "f_streak":        "🔥 Streak",
     "f_banned":        "🚫 Keelatud",

strings/commands.py

@@ -24,7 +24,6 @@ CMD: dict[str, str] = {
     "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)",
@@ -75,6 +74,13 @@ CMD: dict[str, str] = {
     "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)",
+    "vanity":         "Staatusepood - osta ja kanna kosmeetilisi tiitleid",
+    "lootbox":        "Ava õnnekast - juhuslik auhind müntide või boonuse näol",
+    "achievements":   "Vaata oma saavutusi ja teeni märkide eest ühekordseid preemiaid",
+    "bank":           "Vaata oma panka - röövikindel hoius",
+    "deposit":        "Pane münte panka (röövikindel, aga ei teeni intressi)",
+    "withdraw":       "Võta münte pangast rahakotti",
+    "lottery":        "Vaata TipiLOTO potti või osta pileteid (tühjaks jättes näeb infot)",
 }
 
 # ---------------------------------------------------------------------------
@@ -92,7 +98,11 @@ OPT: dict[str, str] = {
     "give_kasutaja":      "Kellele annad?",
     "give_summa":         "Kui palju annad? ('all' = kogu saldo)",
     "buy_ese":            "Eseme nimi (vaata /shop)",
+    "deposit_summa":      "Kui palju panna panka? ('all' = kogu vaba raha)",
+    "withdraw_summa":     "Kui palju pangast välja võtta? ('all' = kogu pangas)",
+    "lottery_kogus":      "Mitu piletit osta (tühjaks jättes näeb potti)",
     "consumable_ese":     "Turgutus, mida osta (tühjaks jättes näeb menüüd)",
+    "vanity_ese":         "Tiitel, mida osta või kanda (tühjaks jättes näeb poodi)",
     "rps_panus":          "Valikuline TipiCOINide panus ('all' = kogu saldo)",
     "rps_vastane":        "Väljakutse teisele mängijale (PvP)",
     "slots_panus":        "Panus TipiCOINides ('all' = kogu saldo)",
@@ -148,10 +158,18 @@ HELP_CATEGORIES: dict[str, dict] = {
             ("/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"),
+            ("/bank", "Vaata oma panka. Panka pandud mündid on röövikindlad (/rob ja /heist ei puuduta)."),
+            ("/deposit <amount>", "Pane münte panka (röövikindel hoius, ei teeni intressi)."),
+            ("/withdraw <amount>", "Võta münte pangast rahakotti."),
             ("/quests", "Vaata oma päeva- ja nädalaülesandeid ning nõua auhinnad (uueneb iga päev/nädal)."),
+            ("/achievements", "Vaata oma saavutusi. Iga lukust lahti saanud märk annab ühekordse müntipreemia."),
+            ("/lottery [kogus]", "Vaata TipiLOTO potti või osta pileteid. Loosimine iga päev - üks võitja saab kogu poti (rohkem pileteid = suurem võiduvõimalus)."),
             ("/leaderboard", "TipiBOTi edetabel - kes on kõige rikkam?"),
             ("/shop", "Sirvi TipiBOTi poodi"),
             ("/buy <item>", "Osta ese TipiBOTi poodist"),
+            ("/consumables", "Osta korduvostetavaid turgutusi (ajutised boostid)."),
+            ("/lootbox", "Ava õnnekast (1000 ⬡) - juhuslik auhind: mündid või ajutine boonus."),
+            ("/vanity", "Staatusepood - osta ja kanna kosmeetilisi tiitleid (näha /profile-l)."),
             ("/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."),
         ],

strings/common.py

@@ -175,6 +175,8 @@ ERR: dict[str, str] = {
     "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}.",
+    "payout_failed":     "⚠️ Tehniline viga võidu väljamaksmisel - see on logitud ja admin taastab su TipiCOINid. Vabandame!",
+    "db_error":          "⚠️ Andmebaas ei vasta praegu. Proovi hetke pärast uuesti.",
 }
 
 # ---------------------------------------------------------------------------
@@ -241,6 +243,8 @@ STATUS_UI: dict[str, str] = {
     "tasks_field": "🔄 Async tasks",
     "eco_players_field": "👤 Eco players",
     "members_cache_field": "📋 Liikmed (cache)",
+    "supply_field": "💰 Rahavaru",
+    "supply_val": "Kokku {total}\nMängijatel {players}\nKassas {house} ({house_pct}%)",
     "log_files_field": "📂 Log files",
     "log_line": "`{name}` - {size_kb} KB",
     "none": "-",

strings/economy.py

@@ -17,6 +17,11 @@ __all__ = [
     'ITEM_DESCRIPTIONS',
     'CONSUMABLES_UI',
     'CONSUMABLE_DESCRIPTIONS',
+    'VANITY_UI',
+    'LOOTBOX_UI',
+    'BANK_UI',
+    'ACHIEVEMENTS_UI',
+    'LOTTERY_UI',
     'JAILED_UI',
     'SHOP_BTN',
     'DAILY_UI',
@@ -240,6 +245,84 @@ CONSUMABLES_UI: dict[str, str] = {
     "bought_instant":  "☕ Kõik ooteajad nullitud!\nUus saldo: {balance}",
 }
 
+# ---------------------------------------------------------------------------
+# Vanity shop  (cosmetic badges/titles - a pure status sink, no gameplay effect)
+# ---------------------------------------------------------------------------
+VANITY_UI: dict[str, str] = {
+    "title":       "👑 Staatusepood",
+    "desc":        "Puhtalt uhkuse pärast - märgid ja tiitlid ilma igasuguse mänguefektita. Kantud märk paistab su `/profile`-l.\nSaldo: {bal}",
+    "line_owned":  "✅ Olemas",
+    "line_active": "⭐ Kantud",
+    "entry_title": "„{title}“",
+    "footer":      "Osta või kanna: /vanity <märk>  ·  „Eemalda märk“ võtab tiitli maha",
+    "none_choice": "❌ Eemalda märk",
+    "bought":      "{emoji} Ostsid tiitli **{title}** ja panid selle kohe kandma!\nUus saldo: {balance}",
+    "equipped":    "{emoji} Kannad nüüd tiitlit **{title}**.",
+    "unequipped":  "Märk eemaldatud - su profiil on jälle tavaline.",
+}
+
+# ---------------------------------------------------------------------------
+# Lootbox  (pay-to-open mystery box, a coin sink with a random reward)
+# ---------------------------------------------------------------------------
+LOOTBOX_UI: dict[str, str] = {
+    "title":         "🎁 Õnnekast",
+    "opening":       "🎁 Avan õnnekasti...",
+    "coins_small":   "🪙 Leidsid põhjast paar münti: **+{coins}**",
+    "coins_medium":  "💰 Korralik saak: **+{coins}**",
+    "coins_big":     "💎 Suur õnn: **+{coins}**",
+    "jackpot":       "🎉 **JACKPOT!** **+{coins}**",
+    "buff_earn":     "⚡ Boonus: teenimine **×2** järgmiseks **{min} minutiks**!",
+    "buff_exp":      "✨ Boonus: EXP **×2** järgmiseks **{min} minutiks**!",
+    "foot_win":      "Netovõit: +{net}  ·  Saldo: {balance}",
+    "foot_loss":     "Netokahjum: {net}  ·  Saldo: {balance}",
+    "foot_buff":     "Saldo: {balance}",
+}
+
+# ---------------------------------------------------------------------------
+# Bank vault  (rob-proof storage; liquid vs banked coins)
+# ---------------------------------------------------------------------------
+BANK_UI: dict[str, str] = {
+    "title":        "🏦 TipiPANK",
+    "desc":         "Panka pandud mündid on **röövikindlad** (`/rob` ja `/heist` neid ei puuduta), aga neid ei saa kulutada ega panustada enne väljavõtmist ega teeni Botikoopa intressi.",
+    "f_liquid":     "💵 Rahakotis (vaba)",
+    "f_bank":       "🏦 Pangas (kaitstud)",
+    "deposited":    "🏦 Panid **{amount}** panka.\n💵 Rahakotis: {balance}  ·  🏦 Pangas: {bank}",
+    "withdrawn":    "💵 Võtsid **{amount}** pangast välja.\n💵 Rahakotis: {balance}  ·  🏦 Pangas: {bank}",
+    "nothing_liquid": "❌ Sul pole nii palju vaba raha rahakotis.",
+    "nothing_bank":   "❌ Sul pole nii palju raha pangas.",
+}
+
+# ---------------------------------------------------------------------------
+# Achievements  (one-time milestone badges over lifetime stats)
+# ---------------------------------------------------------------------------
+ACHIEVEMENTS_UI: dict[str, str] = {
+    "title":         "🏅 Saavutused",
+    "desc":          "Iga lukust lahti saanud märk annab ühekordse müntipreemia.\nAvatud: **{earned}/{total}**",
+    "row_earned":    "✅ {emoji} **{name}**  ·  +{reward}",
+    "row_locked":    "🔒 {emoji} {name}  ·  {progress}/{goal}  ·  +{reward}",
+    "unlocked_note": "🎉 **Uued saavutused avatud:** {names}\n💰 Preemia: +{reward}",
+}
+
+# ---------------------------------------------------------------------------
+# Lottery  (daily draw; one weighted winner takes the pot)
+# ---------------------------------------------------------------------------
+LOTTERY_UI: dict[str, str] = {
+    "title":        "🎟️ TipiLOTO",
+    "desc":         "Osta pileteid ja võida kogu pott! Loosimine iga päev **{draw_time}**. Iga pilet = **{cost}**, rohkem pileteid = suurem võiduvõimalus.",
+    "f_pot":        "💰 Praegune pott",
+    "f_players":    "👥 Osalejaid",
+    "f_your":       "🎟️ Sinu piletid",
+    "your_val":     "{tickets} tk  ·  võiduvõimalus **{chance}%**",
+    "your_none":    "Sul pole veel pileteid. Osta käsuga `/lottery <kogus>`.",
+    "bought":       "🎟️ Ostsid **{count}** piletit ({cost}).\nSul on nüüd **{tickets}** piletit selle päeva loosimises.\nSaldo: {balance}",
+    "max_tickets":  "❌ Maksimaalne piletite arv ühes loosimises on {cap} (sul on {held}).",
+    "empty_pot":    "🎟️ Pott on tühi - ole esimene, kes piletit ostab!",
+    # Draw announcement
+    "draw_title":   "🎟️ TipiLOTO loosimine!",
+    "draw_win":     "🎉 Võitja: {winner}\n💰 Võit: **{pot}**\n🎟️ {tickets}/{total} piletit ({chance}%)\n👥 {players} osalejat",
+    "draw_none":    "🎟️ Täna keegi pileteid ei ostnud - loosimist ei toimunud.",
+}
+
 JAILED_UI: dict[str, str] = {
     "title":      "🔒 Praegu vanglas",
     "empty":      "Kõik on vabad! Vanglas pole kedagi.",
@@ -279,7 +362,7 @@ STATS_UI: dict[str, str] = {
     "social_field":    "🤝 Sotsiaalne",
     "social_val":      "Kingitud: {given}\nSaadud: {received}",
     "records_field":   "🔥 Rekordid",
-    "records_val":     "Pikim päevane streak: **{streak}** päeva",
+    "records_val":     "Pikim päevane streak: **{streak}** päeva\n🎁 Õnnekaste avatud: **{lootboxes}**\n🏅 Saavutusi: **{achievements}/{ach_total}**",
 }
 
 # ---------------------------------------------------------------------------

strings/member.py

@@ -11,7 +11,6 @@ __all__ = [
     'BIRTHDAY_UI',
     'BIRTHDAY_MONTHS',
     'CHECK_UI',
-    'TEAMSYNC_UI',
 ]
 
 # ---------------------------------------------------------------------------
@@ -95,23 +94,3 @@ CHECK_UI: dict[str, str] = {
     "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}",
-    "errors":         "⚠️ Vead: {count}",
-    "no_changes":     "✨ Kõik tiimirollid olid juba korras.",
-    "changes_header": "**Muudatused:**",
-    "changes_more":   "... ja {count} rohkem",
-}

tests/test_achievements.py

@@ -0,0 +1,78 @@
+"""Tests for the achievements system (one-time milestone rewards)."""
+
+from core import economy
+
+from conftest import run
+
+UID = 4747
+
+
+def _fund(fake_pb, **stats) -> None:
+    run(economy.get_user(UID))
+    rec = fake_pb.record_for(UID)
+    rec.update(stats)
+
+
+class TestNewlyEarned:
+    def test_threshold_met_is_newly_earned(self, fake_pb):
+        _fund(fake_pb, work_count=10)
+        user = run(economy.get_user(UID))
+        assert "work_10" in economy.newly_earned(user)
+
+    def test_below_threshold_not_earned(self, fake_pb):
+        _fund(fake_pb, work_count=9)
+        user = run(economy.get_user(UID))
+        assert "work_10" not in economy.newly_earned(user)
+
+    def test_already_claimed_not_repeated(self, fake_pb):
+        _fund(fake_pb, work_count=10, achievements_earned=["work_10"])
+        user = run(economy.get_user(UID))
+        assert "work_10" not in economy.newly_earned(user)
+
+
+class TestClaim:
+    def test_claims_and_pays_reward_once(self, fake_pb):
+        _fund(fake_pb, work_count=10, balance=0)
+        reward = economy.ACHIEVEMENTS["work_10"]["reward"]
+
+        res = run(economy.do_check_achievements(UID))
+        assert res["ok"] and res["new"] == ["work_10"]
+        assert res["reward"] == reward
+        assert fake_pb.record_for(UID)["balance"] == reward
+        assert "work_10" in fake_pb.record_for(UID)["achievements_earned"]
+
+        # Second call: nothing new, no double pay.
+        res2 = run(economy.do_check_achievements(UID))
+        assert res2["new"] == [] and res2["reward"] == 0
+        assert fake_pb.record_for(UID)["balance"] == reward
+
+    def test_multiple_unlocked_at_once(self, fake_pb):
+        _fund(fake_pb, work_count=100, total_fish_caught=25, balance=0)
+        res = run(economy.do_check_achievements(UID))
+        # work_10, work_100 and fish_25 all cross at once
+        assert set(res["new"]) == {"work_10", "work_100", "fish_25"}
+        expected = sum(economy.ACHIEVEMENTS[a]["reward"] for a in res["new"])
+        assert res["reward"] == expected
+        assert fake_pb.record_for(UID)["balance"] == expected
+
+    def test_nothing_to_claim(self, fake_pb):
+        _fund(fake_pb, balance=500)
+        res = run(economy.do_check_achievements(UID))
+        assert res["ok"] and res["new"] == [] and res["reward"] == 0
+        assert fake_pb.record_for(UID)["balance"] == 500
+
+
+class TestView:
+    def test_view_marks_earned_and_progress(self, fake_pb):
+        _fund(fake_pb, work_count=5, achievements_earned=["beg_50"])
+        rows = economy.achievements_view(run(economy.get_user(UID)))
+        by_id = {r["id"]: r for r in rows}
+        assert by_id["beg_50"]["earned"] is True
+        assert by_id["work_10"]["earned"] is False
+        assert by_id["work_10"]["progress"] == 5   # capped at goal
+        assert len(rows) == len(economy.ACHIEVEMENTS)
+
+    def test_progress_capped_at_goal(self, fake_pb):
+        _fund(fake_pb, work_count=9999)
+        rows = {r["id"]: r for r in economy.achievements_view(run(economy.get_user(UID)))}
+        assert rows["work_10"]["progress"] == rows["work_10"]["goal"]

tests/test_bank.py

@@ -0,0 +1,86 @@
+"""Tests for the bank vault: rob-proof storage and net-worth accounting."""
+
+from core import economy
+
+from conftest import run
+
+UID = 6161
+ROBBER = 6162
+
+
+def _fund(fake_pb, uid: int, balance: int, bank: int = 0) -> None:
+    run(economy.get_user(uid))
+    rec = fake_pb.record_for(uid)
+    rec["balance"] = balance
+    rec["bank_balance"] = bank
+
+
+class TestDepositWithdraw:
+    def test_deposit_moves_liquid_to_bank(self, fake_pb):
+        _fund(fake_pb, UID, 1000)
+        res = run(economy.do_deposit(UID, 400))
+        assert res["ok"] and res["balance"] == 600 and res["bank"] == 400
+        rec = fake_pb.record_for(UID)
+        assert rec["balance"] == 600 and rec["bank_balance"] == 400
+
+    def test_withdraw_moves_bank_to_liquid(self, fake_pb):
+        _fund(fake_pb, UID, 100, bank=500)
+        res = run(economy.do_withdraw(UID, 300))
+        assert res["ok"] and res["balance"] == 400 and res["bank"] == 200
+
+    def test_deposit_more_than_liquid_rejected(self, fake_pb):
+        _fund(fake_pb, UID, 100)
+        res = run(economy.do_deposit(UID, 500))
+        assert not res["ok"] and res["reason"] == "insufficient"
+        assert fake_pb.record_for(UID)["balance"] == 100  # unchanged
+
+    def test_withdraw_more_than_bank_rejected(self, fake_pb):
+        _fund(fake_pb, UID, 0, bank=100)
+        res = run(economy.do_withdraw(UID, 500))
+        assert not res["ok"] and res["reason"] == "insufficient"
+        assert fake_pb.record_for(UID)["bank_balance"] == 100
+
+    def test_nonpositive_rejected(self, fake_pb):
+        _fund(fake_pb, UID, 1000, bank=1000)
+        assert run(economy.do_deposit(UID, 0))["reason"] == "invalid"
+        assert run(economy.do_withdraw(UID, -5))["reason"] == "invalid"
+
+    def test_banned_rejected(self, fake_pb):
+        _fund(fake_pb, UID, 1000)
+        fake_pb.record_for(UID)["eco_banned"] = True
+        assert run(economy.do_deposit(UID, 100))["reason"] == "banned"
+
+    def test_round_trip_conserves_coins(self, fake_pb):
+        _fund(fake_pb, UID, 1000)
+        run(economy.do_deposit(UID, 700))
+        run(economy.do_withdraw(UID, 700))
+        rec = fake_pb.record_for(UID)
+        assert rec["balance"] == 1000 and rec["bank_balance"] == 0
+
+
+class TestRobProof:
+    def test_rob_cannot_touch_banked_coins(self, fake_pb, monkeypatch):
+        # Target keeps everything banked, only a little liquid (< rob threshold).
+        _fund(fake_pb, UID, 50, bank=100_000)
+        _fund(fake_pb, ROBBER, 1000)
+        # Target has < 100 liquid, so a rob is rejected as "broke" - the vault is
+        # invisible to /rob (which only reads balance).
+        res = run(economy.do_rob(ROBBER, UID))
+        assert not res["ok"] and res["reason"] == "broke"
+        assert fake_pb.record_for(UID)["bank_balance"] == 100_000  # untouched
+
+
+class TestNetWorth:
+    def test_leaderboard_counts_bank(self, fake_pb):
+        _fund(fake_pb, UID, 100, bank=900)       # net worth 1000
+        _fund(fake_pb, ROBBER, 500, bank=0)      # net worth 500
+        board = dict((uid, worth) for uid, worth in run(economy.get_leaderboard(top_n=None)))
+        assert board[str(UID)] == 1000
+        assert board[str(ROBBER)] == 500
+
+    def test_economy_stats_counts_bank(self, fake_pb, monkeypatch):
+        monkeypatch.setattr(economy.house, "HOUSE_ID", None)
+        _fund(fake_pb, UID, 100, bank=900)
+        stats = run(economy.get_economy_stats())
+        assert stats["total_coins"] == 1000
+        assert stats["player_coins"] == 1000

tests/test_consumables.py

@@ -100,3 +100,10 @@ class TestEffects:
         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
+
+    def test_instant_reset_commands_match_cleared_cooldowns(self):
+        # The Discord layer cancels reminder DMs for exactly these commands after a
+        # kohv, so the list must stay in lockstep with the cooldown fields it wipes.
+        expected = tuple(f.removeprefix("last_") for f in economy.consumables._COOLDOWN_FIELDS)
+        assert economy.INSTANT_RESET_COMMANDS == expected
+        assert economy.INSTANT_RESET_COMMANDS == ("work", "beg", "crime", "rob", "fish")

tests/test_economy_pure.py

@@ -35,6 +35,29 @@ class TestLevels:
         assert economy.level_role_name(99) == "TipiLEGEND"
 
 
+class TestEffectiveCooldown:
+    def test_default_when_no_item(self):
+        assert economy.effective_cooldown("work", []) == economy.COOLDOWNS["work"]
+        assert economy.effective_cooldown("daily", []) == economy.COOLDOWNS["daily"]
+
+    def test_item_reduces_cooldown(self):
+        assert economy.effective_cooldown("work", ["monitor"]) == timedelta(minutes=40)
+        assert economy.effective_cooldown("beg", ["hiirematt"]) == timedelta(minutes=3)
+        assert economy.effective_cooldown("daily", ["korvaklapid"]) == timedelta(hours=18)
+        assert economy.effective_cooldown("fish", ["ussipurk"]) == timedelta(seconds=90)
+
+    def test_unrelated_item_does_not_reduce(self):
+        assert economy.effective_cooldown("work", ["hiirematt"]) == economy.COOLDOWNS["work"]
+
+    def test_command_without_cooldown_returns_none(self):
+        assert economy.effective_cooldown("unknown", []) is None
+
+    def test_every_item_cooldown_beats_its_base(self):
+        # An item-reduced cooldown must always be shorter than the base.
+        for cmd, (item, reduced) in economy.store.ITEM_COOLDOWNS.items():
+            assert reduced < economy.COOLDOWNS[cmd]
+
+
 class TestGambleExp:
     def test_tiers(self):
         assert economy.gamble_exp(0) == 0

tests/test_leaderboards.py

@@ -0,0 +1,77 @@
+"""Tests for leaderboard queries, incl. the single-scan combined builder."""
+
+from core import economy, pb_client
+
+from conftest import run
+
+
+def _seed(fake_pb, n: int) -> None:
+    for i in range(1, n + 1):
+        run(economy.get_user(1000 + i))
+        rec = fake_pb.record_for(1000 + i)
+        rec["balance"] = i * 100
+        rec["exp"] = i * 50
+        rec["season_total_exp"] = i * 10
+        rec["prestige_level"] = i % 3
+        rec["prestige_points"] = i
+        rec["total_wagered"] = i * 7
+        rec["total_fish_caught"] = n - i  # inverse order, to catch sort mistakes
+
+
+class TestGetAllLeaderboards:
+    def test_matches_individual_queries(self, fake_pb):
+        _seed(fake_pb, 5)
+        combined = run(economy.get_all_leaderboards())
+        assert combined["coins"] == run(economy.get_leaderboard(top_n=None))
+        assert combined["exp"] == run(economy.get_leaderboard_exp(top_n=None))
+        assert combined["season"] == run(economy.get_leaderboard_season_exp(top_n=None))
+        assert combined["prestige"] == run(economy.get_leaderboard_prestige(top_n=None))
+        assert combined["wagered"] == run(economy.get_leaderboard_wagered(top_n=None))
+        assert combined["fish"] == run(economy.get_leaderboard_fish(top_n=None))
+
+    def test_scans_collection_once(self, fake_pb, monkeypatch):
+        _seed(fake_pb, 3)
+        calls = {"n": 0}
+        real = pb_client.list_all_records
+
+        async def counting():
+            calls["n"] += 1
+            return await real()
+
+        monkeypatch.setattr(pb_client, "list_all_records", counting)
+        run(economy.get_all_leaderboards())
+        assert calls["n"] == 1  # not six
+
+    def test_fish_sorted_descending(self, fake_pb):
+        _seed(fake_pb, 4)
+        fish = run(economy.get_all_leaderboards())["fish"]
+        counts = [c for _, c in fish]
+        assert counts == sorted(counts, reverse=True)
+
+
+class TestEconomyStats:
+    def test_totals_split_house_from_players(self, fake_pb, monkeypatch):
+        monkeypatch.setattr(economy.house, "HOUSE_ID", 999)
+        monkeypatch.setattr(economy.house, "_house_pb_id", None)
+        # three players + the house
+        for uid, bal in [(1, 100), (2, 250), (3, 0)]:
+            run(economy.get_user(uid))
+            fake_pb.record_for(uid)["balance"] = bal
+        run(economy.get_user(999))
+        fake_pb.record_for(999)["balance"] = 5000
+
+        stats = run(economy.get_economy_stats())
+        assert stats["total_coins"] == 100 + 250 + 0 + 5000
+        assert stats["house_balance"] == 5000
+        assert stats["player_coins"] == 350
+        assert stats["player_count"] == 3   # house excluded
+
+    def test_no_house_configured(self, fake_pb, monkeypatch):
+        monkeypatch.setattr(economy.house, "HOUSE_ID", None)
+        run(economy.get_user(1))
+        fake_pb.record_for(1)["balance"] = 42
+        stats = run(economy.get_economy_stats())
+        assert stats["total_coins"] == 42
+        assert stats["house_balance"] == 0
+        assert stats["player_coins"] == 42
+        assert stats["player_count"] == 1

tests/test_lootbox.py

@@ -0,0 +1,78 @@
+"""Tests for the /lootbox mystery box (pay-to-open coin sink)."""
+
+import random
+
+from core import economy
+
+from conftest import run
+
+UID = 8080
+
+
+def _fund(fake_pb, amount: int) -> None:
+    run(economy.get_user(UID))
+    fake_pb.record_for(UID)["balance"] = amount
+
+
+def _open_until(fake_pb, predicate):
+    """Open boxes with varied seeds until `predicate(res)` holds; returns that res."""
+    for seed in range(1000):
+        random.seed(seed)
+        _fund(fake_pb, 100_000)
+        res = run(economy.do_open_lootbox(UID))
+        if predicate(res):
+            return res
+    raise AssertionError("outcome never occurred")
+
+
+class TestOpen:
+    def test_costs_the_fee_and_charges_up_front(self, fake_pb):
+        _fund(fake_pb, 1_000)
+        random.seed(1)
+        res = run(economy.do_open_lootbox(UID))
+        assert res["ok"]
+        # balance == 1000 - cost + reward_coins
+        assert res["balance"] == 1_000 - economy.LOOTBOX_COST + res["reward_coins"]
+
+    def test_insufficient_rejected(self, fake_pb):
+        _fund(fake_pb, economy.LOOTBOX_COST - 1)
+        res = run(economy.do_open_lootbox(UID))
+        assert not res["ok"] and res["reason"] == "insufficient"
+        assert res["need"] == 1
+        assert fake_pb.record_for(UID)["balance"] == economy.LOOTBOX_COST - 1  # not charged
+
+    def test_banned_rejected(self, fake_pb):
+        _fund(fake_pb, 5_000)
+        fake_pb.record_for(UID)["eco_banned"] = True
+        res = run(economy.do_open_lootbox(UID))
+        assert not res["ok"] and res["reason"] == "banned"
+
+    def test_increments_counter(self, fake_pb):
+        _fund(fake_pb, 5_000)
+        random.seed(3)
+        run(economy.do_open_lootbox(UID))
+        run(economy.do_open_lootbox(UID))
+        assert run(economy.get_user(UID))["lootboxes_opened"] == 2
+
+
+class TestOutcomes:
+    def test_coin_outcome_credits_and_net_matches(self, fake_pb):
+        res = _open_until(fake_pb, lambda r: r["reward_coins"] > 0)
+        assert res["net"] == res["reward_coins"] - economy.LOOTBOX_COST
+        assert res["buff_kind"] is None
+
+    def test_buff_outcome_grants_active_buff(self, fake_pb):
+        res = _open_until(fake_pb, lambda r: r["buff_kind"] is not None)
+        assert res["reward_coins"] == 0
+        assert res["net"] == -economy.LOOTBOX_COST
+        user = run(economy.get_user(UID))
+        # the granted buff is live
+        assert res["buff_kind"] in economy.active_buffs(user)
+
+    def test_never_negative_balance(self, fake_pb):
+        # Open exactly at the cost floor repeatedly; balance must stay >= 0.
+        for seed in range(30):
+            random.seed(seed)
+            _fund(fake_pb, economy.LOOTBOX_COST)
+            res = run(economy.do_open_lootbox(UID))
+            assert res["balance"] >= 0

tests/test_lottery.py

@@ -0,0 +1,131 @@
+"""Tests for the daily lottery (buy tickets, weighted winner takes the pot)."""
+
+import datetime
+import random
+from zoneinfo import ZoneInfo
+
+from core import economy
+
+from conftest import run
+
+TZ = ZoneInfo("Europe/Tallinn")
+P = "2026-09-04"          # a fixed draw period
+UID = 3131
+UID2 = 3132
+UID3 = 3133
+
+
+def _fund(fake_pb, uid: int, balance: int) -> None:
+    run(economy.get_user(uid))
+    fake_pb.record_for(uid)["balance"] = balance
+
+
+class TestPeriod:
+    def test_before_draw_hour_is_today(self):
+        dt = datetime.datetime(2026, 9, 4, 20, 0, tzinfo=TZ)
+        assert economy.period_for(dt) == "2026-09-04"
+
+    def test_at_or_after_draw_hour_is_tomorrow(self):
+        dt = datetime.datetime(2026, 9, 4, economy.DRAW_HOUR, 0, tzinfo=TZ)
+        assert economy.period_for(dt) == "2026-09-05"
+
+
+class TestBuy:
+    def test_buy_deducts_and_records_tickets(self, fake_pb):
+        _fund(fake_pb, UID, 10_000)
+        res = run(economy.do_buy_ticket(UID, 3, P))
+        assert res["ok"] and res["tickets"] == 3
+        assert res["cost"] == 3 * economy.TICKET_COST
+        assert res["balance"] == 10_000 - 3 * economy.TICKET_COST
+        rec = fake_pb.record_for(UID)
+        assert rec["lottery_tickets"] == 3 and rec["lottery_period"] == P
+
+    def test_buy_accumulates_same_period(self, fake_pb):
+        _fund(fake_pb, UID, 10_000)
+        run(economy.do_buy_ticket(UID, 2, P))
+        res = run(economy.do_buy_ticket(UID, 3, P))
+        assert res["tickets"] == 5
+
+    def test_new_period_resets_tickets(self, fake_pb):
+        _fund(fake_pb, UID, 10_000)
+        run(economy.do_buy_ticket(UID, 5, P))
+        res = run(economy.do_buy_ticket(UID, 1, "2026-09-05"))
+        assert res["tickets"] == 1   # old period's tickets dropped
+
+    def test_insufficient_rejected(self, fake_pb):
+        _fund(fake_pb, UID, 100)
+        res = run(economy.do_buy_ticket(UID, 1, P))
+        assert not res["ok"] and res["reason"] == "insufficient"
+        assert fake_pb.record_for(UID)["balance"] == 100
+
+    def test_max_tickets_enforced(self, fake_pb):
+        _fund(fake_pb, UID, 10_000_000)
+        res = run(economy.do_buy_ticket(UID, economy.MAX_TICKETS_PER_DRAW + 1, P))
+        assert not res["ok"] and res["reason"] == "max_tickets"
+
+    def test_nonpositive_rejected(self, fake_pb):
+        _fund(fake_pb, UID, 10_000)
+        assert run(economy.do_buy_ticket(UID, 0, P))["reason"] == "invalid"
+
+    def test_banned_rejected(self, fake_pb):
+        _fund(fake_pb, UID, 10_000)
+        fake_pb.record_for(UID)["eco_banned"] = True
+        assert run(economy.do_buy_ticket(UID, 1, P))["reason"] == "banned"
+
+
+class TestState:
+    def test_pot_and_your_tickets(self, fake_pb):
+        _fund(fake_pb, UID, 10_000)
+        _fund(fake_pb, UID2, 10_000)
+        run(economy.do_buy_ticket(UID, 3, P))
+        run(economy.do_buy_ticket(UID2, 2, P))
+        state = run(economy.get_lottery_state(P, UID))
+        assert state["total_tickets"] == 5
+        assert state["pot"] == 5 * economy.TICKET_COST
+        assert state["participants"] == 2
+        assert state["your_tickets"] == 3
+
+    def test_other_period_not_counted(self, fake_pb):
+        _fund(fake_pb, UID, 10_000)
+        run(economy.do_buy_ticket(UID, 3, "2026-01-01"))
+        state = run(economy.get_lottery_state(P))
+        assert state["total_tickets"] == 0 and state["pot"] == 0
+
+
+class TestDraw:
+    def test_no_participants_returns_none(self, fake_pb):
+        assert run(economy.do_lottery_draw(P)) is None
+
+    def test_winner_gets_whole_pot_and_coins_conserved(self, fake_pb):
+        _fund(fake_pb, UID, 10_000)
+        _fund(fake_pb, UID2, 10_000)
+        run(economy.do_buy_ticket(UID, 3, P))    # -600
+        run(economy.do_buy_ticket(UID2, 2, P))   # -400
+        pot = 5 * economy.TICKET_COST
+        total_before = sum(fake_pb.record_for(u)["balance"] for u in (UID, UID2))
+
+        random.seed(1)
+        res = run(economy.do_lottery_draw(P))
+        assert res["ok"] and res["pot"] == pot
+        winner, loser = (UID, UID2) if res["winner_id"] == UID else (UID2, UID)
+        assert fake_pb.record_for(winner)["balance"] == (
+            (10_000 - (3 if winner == UID else 2) * economy.TICKET_COST) + pot
+        )
+        # Coins conserved: the pot minted to the winner equals total ticket spend.
+        total_after = sum(fake_pb.record_for(u)["balance"] for u in (UID, UID2))
+        assert total_after == total_before + pot
+        assert fake_pb.record_for(res["winner_id"])["lottery_tickets"] == 0  # consumed
+
+    def test_more_tickets_wins_more_often(self, fake_pb):
+        _fund(fake_pb, UID, 10_000_000)
+        _fund(fake_pb, UID2, 10_000_000)
+        wins = {UID: 0, UID2: 0}
+        for seed in range(200):
+            # reset tickets each round to the same split
+            fake_pb.record_for(UID).update(lottery_tickets=9, lottery_period=P)
+            fake_pb.record_for(UID2).update(lottery_tickets=1, lottery_period=P)
+            random.seed(seed)
+            res = run(economy.do_lottery_draw(P))
+            wins[res["winner_id"]] += 1
+        # UID holds 90% of tickets -> should win far more often.
+        assert wins[UID] > wins[UID2] * 3

tests/test_money_safety_fixes.py

@@ -10,6 +10,7 @@ Covers the two pure-logic fixes:
 from datetime import datetime, timedelta, timezone
 
 from core import economy
+from core.pb_client import DatabaseError
 
 from conftest import run
 
@@ -89,3 +90,26 @@ class TestBailIdempotency:
         self._jail(fake_pb, now, balance=1000)
         res = run(economy.do_bail(UID))
         assert res["ok"] and res["fine"] >= economy.MIN_BAIL
+
+
+class TestBlackjackPayoutSafety:
+    """do_blackjack_payout must not raise on a DB failure - the stake was already
+    deducted in do_blackjack_bet, so a raised exception would blow up the
+    interaction handler and swallow the outcome. It reports db_error instead."""
+
+    async def _boom(self, *args, **kwargs):
+        raise DatabaseError("simulated PocketBase outage")
+
+    def test_payout_returns_db_error_when_read_fails(self, fake_pb, monkeypatch):
+        monkeypatch.setattr(economy.gambling, "get_user", self._boom)
+        res = run(economy.do_blackjack_payout(UID, payout=200, total_invested=100))
+        assert res == {"ok": False, "reason": "db_error"}
+
+    def test_payout_returns_db_error_when_commit_fails(self, fake_pb, monkeypatch):
+        run(economy.get_user(UID))
+        fake_pb.record_for(UID)["balance"] = 500
+        monkeypatch.setattr(economy.gambling, "_commit", self._boom)
+        res = run(economy.do_blackjack_payout(UID, payout=200, total_invested=100))
+        assert res == {"ok": False, "reason": "db_error"}
+        # The failed credit did not persist; balance is untouched (no partial win).
+        assert fake_pb.record_for(UID)["balance"] == 500

tests/test_pending_wager.py

@@ -0,0 +1,102 @@
+"""Tests for pending-wager escrow persistence.
+
+Interactive games (blackjack, RPS PvP) deduct a stake up front and hold it in an
+in-memory View. These tests verify the stake is recorded on the user record in
+the same commit, cleared on settlement, and refunded by reconcile on restart.
+"""
+
+from core import economy
+
+from conftest import run
+
+UID = 555
+OPP = 556
+
+
+def _fund(fake_pb, uid: int, amount: int) -> None:
+    run(economy.get_user(uid))
+    fake_pb.record_for(uid)["balance"] = amount
+
+
+def _pending(fake_pb, uid: int) -> dict:
+    return fake_pb.record_for(uid).get("pending_wager") or {}
+
+
+class TestBlackjackEscrow:
+    def test_bet_records_pending_and_payout_clears(self, fake_pb):
+        _fund(fake_pb, UID, 1000)
+        run(economy.do_blackjack_bet(UID, 100))
+        pw = _pending(fake_pb, UID)
+        assert pw["kind"] == "blackjack" and pw["amount"] == 100
+
+        run(economy.do_blackjack_payout(UID, payout=200, total_invested=100))
+        assert _pending(fake_pb, UID) == {}          # settled
+        assert fake_pb.record_for(UID)["balance"] == 1000 - 100 + 200
+
+    def test_double_split_accumulates_escrow(self, fake_pb):
+        _fund(fake_pb, UID, 1000)
+        run(economy.do_blackjack_bet(UID, 100))      # initial
+        run(economy.do_blackjack_bet(UID, 100))      # double / split adds a hand
+        assert _pending(fake_pb, UID)["amount"] == 200
+
+    def test_losing_hand_clears_escrow(self, fake_pb):
+        _fund(fake_pb, UID, 1000)
+        run(economy.do_blackjack_bet(UID, 100))
+        run(economy.do_blackjack_payout(UID, payout=0, total_invested=100))  # bust/loss
+        assert _pending(fake_pb, UID) == {}
+
+
+class TestRpsEscrow:
+    def test_deposit_records_and_payout_forfeit_clear(self, fake_pb):
+        _fund(fake_pb, UID, 500)
+        _fund(fake_pb, OPP, 500)
+        run(economy.do_rps_pvp_deposit(UID, 100))
+        run(economy.do_rps_pvp_deposit(OPP, 100))
+        assert _pending(fake_pb, UID)["kind"] == "rps"
+        assert _pending(fake_pb, OPP)["amount"] == 100
+
+        run(economy.do_rps_pvp_payout(UID, 100))   # UID wins
+        run(economy.do_rps_pvp_forfeit(OPP))       # OPP loses
+        assert _pending(fake_pb, UID) == {}
+        assert _pending(fake_pb, OPP) == {}
+        assert fake_pb.record_for(UID)["balance"] == 500 - 100 + 200
+        assert fake_pb.record_for(OPP)["balance"] == 500 - 100
+
+    def test_refund_clears_escrow(self, fake_pb):
+        _fund(fake_pb, UID, 500)
+        run(economy.do_rps_pvp_deposit(UID, 100))
+        run(economy.do_rps_pvp_refund(UID, 100))
+        assert _pending(fake_pb, UID) == {}
+        assert fake_pb.record_for(UID)["balance"] == 500
+
+
+class TestReconcile:
+    def test_refunds_interrupted_stakes(self, fake_pb):
+        # Simulate a restart: two players left mid-game with escrowed stakes.
+        _fund(fake_pb, UID, 400)
+        run(economy.do_blackjack_bet(UID, 100))    # 300 left, 100 escrowed
+        _fund(fake_pb, OPP, 500)
+        fake_pb.record_for(OPP)["balance"] = 500
+        run(economy.do_rps_pvp_deposit(OPP, 250))  # 250 left, 250 escrowed
+
+        refunded = run(economy.reconcile_pending_wagers())
+        by_uid = {uid: (amt, kind) for uid, amt, kind in refunded}
+        assert by_uid[UID] == (100, "blackjack")
+        assert by_uid[OPP] == (250, "rps")
+        assert fake_pb.record_for(UID)["balance"] == 400   # stake restored
+        assert fake_pb.record_for(OPP)["balance"] == 500
+        assert _pending(fake_pb, UID) == {}
+        assert _pending(fake_pb, OPP) == {}
+
+    def test_noop_when_nothing_pending(self, fake_pb):
+        _fund(fake_pb, UID, 100)
+        assert run(economy.reconcile_pending_wagers()) == []
+        assert fake_pb.record_for(UID)["balance"] == 100
+
+    def test_reconcile_is_idempotent(self, fake_pb):
+        _fund(fake_pb, UID, 400)
+        run(economy.do_blackjack_bet(UID, 100))
+        run(economy.reconcile_pending_wagers())
+        # A second run (e.g. another restart) must not double-refund.
+        assert run(economy.reconcile_pending_wagers()) == []
+        assert fake_pb.record_for(UID)["balance"] == 400

tests/test_team_sync.py

@@ -1,342 +0,0 @@
-"""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))
-
-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 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_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"]

tests/test_vanity.py

@@ -0,0 +1,78 @@
+"""Tests for the vanity shop (cosmetic status sink, no gameplay effect)."""
+
+from core import economy
+
+from conftest import run
+
+UID = 7777
+
+
+def _fund(fake_pb, amount: int) -> None:
+    run(economy.get_user(UID))
+    fake_pb.record_for(UID)["balance"] = amount
+
+
+class TestBuy:
+    def test_buy_burns_coins_owns_and_equips(self, fake_pb):
+        _fund(fake_pb, 10_000)
+        cost = economy.VANITY["couch"]["cost"]
+        res = run(economy.do_vanity_select(UID, "couch"))
+        assert res["ok"] and res["action"] == "bought"
+        assert res["balance"] == 10_000 - cost
+        user = run(economy.get_user(UID))
+        assert "couch" in user["vanity_owned"]
+        assert user["vanity_active"] == "couch"
+        assert economy.vanity_badge(user) == ("🎮", "Sohvasõdur")
+
+    def test_coins_are_destroyed_not_sent_to_house(self, fake_pb, monkeypatch):
+        _fund(fake_pb, 10_000)
+        credited = []
+        monkeypatch.setattr(economy.house, "_credit_house", lambda amt: credited.append(amt))
+        run(economy.do_vanity_select(UID, "couch"))
+        assert credited == []          # nothing recirculated to the house
+
+    def test_insufficient_funds_rejected(self, fake_pb):
+        _fund(fake_pb, 100)
+        res = run(economy.do_vanity_select(UID, "legend"))
+        assert not res["ok"] and res["reason"] == "insufficient"
+        assert res["need"] == economy.VANITY["legend"]["cost"] - 100
+        assert run(economy.get_user(UID))["balance"] == 100   # unchanged
+
+    def test_banned_rejected(self, fake_pb):
+        _fund(fake_pb, 10_000)
+        fake_pb.record_for(UID)["eco_banned"] = True
+        res = run(economy.do_vanity_select(UID, "couch"))
+        assert not res["ok"] and res["reason"] == "banned"
+
+    def test_unknown_badge(self, fake_pb):
+        _fund(fake_pb, 10_000)
+        res = run(economy.do_vanity_select(UID, "nope"))
+        assert not res["ok"] and res["reason"] == "not_found"
+
+
+class TestEquip:
+    def test_equip_owned_is_free(self, fake_pb):
+        _fund(fake_pb, 20_000)
+        run(economy.do_vanity_select(UID, "couch"))     # buy + equip couch
+        run(economy.do_vanity_select(UID, "cables"))    # buy + equip cables
+        bal_before = run(economy.get_user(UID))["balance"]
+        res = run(economy.do_vanity_select(UID, "couch"))   # re-equip owned couch
+        assert res["ok"] and res["action"] == "equipped"
+        user = run(economy.get_user(UID))
+        assert user["vanity_active"] == "couch"
+        assert user["balance"] == bal_before            # no re-charge
+
+    def test_unequip_clears_badge(self, fake_pb):
+        _fund(fake_pb, 10_000)
+        run(economy.do_vanity_select(UID, "couch"))
+        res = run(economy.do_vanity_select(UID, economy.vanity.NONE_ID))
+        assert res["ok"] and res["action"] == "unequipped"
+        user = run(economy.get_user(UID))
+        assert user["vanity_active"] is None
+        assert economy.vanity_badge(user) is None
+        assert "couch" in user["vanity_owned"]          # still owned, just not worn
+
+
+def test_no_badge_by_default(fake_pb):
+    user = run(economy.get_user(UID))
+    assert economy.vanity_badge(user) is None