feat: implement /timezone command to get/set room timezone

- Add cmd_timezone handler for /timezone command
- Validate timezone using IANA format (zoneinfo.ZoneInfo)
- Use existing BountyService.get_timezone and set_timezone methods
- Admin-only permission via service layer
- Update help text and bot command list
- Fixes #53

CONTRIBUTING.md

@@ -5,27 +5,42 @@
 ```bash
 git clone https://git.fbrns.co/shoko/jigaido.git
 cd jigaido
+
+# Create virtual environment
 python -m venv venv
 source venv/bin/activate
-pip install -r requirements.txt
+
+# Install dependencies
+pip install -r apps/telegram-bot/requirements.txt
+
+# Run tests
+pytest
 
 # Run bot
-export JIGAIDO_BOT_TOKEN="test:token"
+export JIGAIDO_BOT_TOKEN="your_bot_token"
-python bot.py
+python -m apps.telegram-bot.bot
 ```
 
+## Architecture
+
+JIGAIDO follows hexagonal architecture:
+
+- **Core** (`core/`): Pure domain logic - models, ports (interfaces), and services
+- **Adapters** (`adapters/`): Infrastructure implementations - storage adapters
+- **Apps** (`apps/`): CLI applications - Telegram bot
+
 ## Code Style
 
-- Python (no strict formatter enforced yet)
+- Python 3.10+ with type hints
 - Async/await for Telegram handlers
-- Type hints where obvious
 - Docstrings for public functions
+- Follow existing code patterns
 
 ## Pull Request Workflow
 
 1. Branch from `main`
 2. Make changes
-3. Test locally
+3. Test locally with `pytest`
 4. Open PR with description of what changed and why
 5. Someone reviews and merges
 

README.md

@@ -22,14 +22,33 @@ A bounty tracking platform. Currently ships with a Telegram bot for managing and
 
 ```
 jigaido/
+├── core/                    # Domain layer (pure Python, no external deps)
+│   ├── models.py            # Domain dataclasses (Bounty, Tracking)
+│   ├── ports.py             # Port interfaces
+│   └── services.py          # Domain services
+├── adapters/                # Infrastructure adapters
+│   └── storage/
+│       └── json_file.py     # JSON file storage implementation
 ├── apps/
-│   └── telegram-bot/   ← first app (Python)
+│   └── telegram-bot/        # Telegram bot CLI application
-│       ├── bot.py
+│       ├── bot.py            # Bot entry point
-│       ├── commands.py
+│       └── commands.py       # Command handlers
-│       ├── cron.py
+├── tests/                   # Unit tests
-│       ├── db.py
+├── config.py               # Configuration management
-│       └── requirements.txt
+└── SPEC.md                 # Full design specification
-└── SPEC.md             ← full design specification
+```
+
+## Quick Start
+
+```bash
+# Install dependencies
+pip install -r apps/telegram-bot/requirements.txt
+
+# Set bot token
+export JIGAIDO_BOT_TOKEN="your_bot_token"
+
+# Run bot
+python -m apps.telegram-bot.bot
 ```
 
 ## License

SPEC.md

@@ -20,7 +20,7 @@ JIGAIDO is a Telegram bot that lets groups and individuals track bounties — ta
 
 ### Stack
 - **Bot**: `python-telegram-bot` (pure Python, no C extensions)
-- **Storage**: Per-group JSON files (zero-setup, no DB server)
+- **Storage**: Per-group JSON files via `adapters/storage/json_file.py`
 - **Date parsing**: `dateparser`
 - **Runtime**: Python 3.10+
 - **Deployment**: Any $5 VPS with Python 3.10+
@@ -28,19 +28,40 @@ JIGAIDO is a Telegram bot that lets groups and individuals track bounties — ta
 ### Directory Structure
 
 ```
-~/.jigaido/                          # Data root (~/.jigaido/)
+jigaido/
-├── {group_id}/
+├── core/                    # Domain layer
-│   ├── group.json                  # Group bounties
+│   ├── models.py            # Domain dataclasses (Bounty, Tracking)
-│   └── {user_id}.json              # User tracking within this group
+│   ├── ports.py             # Port interfaces (abstract base classes)
-└── {user_id}/
+│   └── services.py          # Domain services (BountyService, TrackingService)
-    └── user.json                    # User's personal bounties (DM mode)
+├── adapters/                # Infrastructure adapters
+│   └── storage/
+│       └── json_file.py     # JSON file storage implementation
+├── apps/
+│   └── telegram-bot/        # Telegram bot CLI application
+│       ├── bot.py            # Bot entry point
+│       └── commands.py       # Command handlers
+├── config.py               # Configuration management
+└── tests/                  # Unit tests
 ```
 
-**Note:** Data directory is at `~/.jigaido/` (home directory), NOT inside the repository or app directory.
+### Hexagonal Architecture
 
-### Storage Design
+- **Core** (`core/`): Pure domain logic, no external dependencies
+  - `models.py`: Domain dataclasses
+  - `ports.py`: Abstract interfaces for storage
+  - `services.py`: Business logic
 
-**File: `data/{group_id}/group.json`**
+- **Adapters** (`adapters/`): Implementations of ports
+  - `storage/json_file.py`: JSON file-based storage
+
+- **Apps** (`apps/`): CLI applications
+  - `telegram-bot/`: Telegram bot interface
+
+### Data Storage
+
+Data is stored at `~/.jigaido/` (home directory), NOT inside the repository.
+
+**File: `~/.jigaido/{group_id}/group.json`**
 
 ```json
 {
@@ -58,7 +79,7 @@ JIGAIDO is a Telegram bot that lets groups and individuals track bounties — ta
 }
 ```
 
-**File: `data/{group_id}/{user_id}.json`**
+**File: `~/.jigaido/{group_id}/{user_id}.json`**
 
 ```json
 {
@@ -68,7 +89,7 @@ JIGAIDO is a Telegram bot that lets groups and individuals track bounties — ta
 }
 ```
 
-**File: `data/{user_id}/user.json`**
+**File: `~/.jigaido/{user_id}/user.json`**
 
 ```json
 {
@@ -87,10 +108,10 @@ JIGAIDO is a Telegram bot that lets groups and individuals track bounties — ta
 
 **Key design decisions:**
 
-1. **Group-isolated storage** — Each group has its own directory. No cross-group access.
+1. **Hexagonal architecture** — Core domain is isolated from infrastructure
-2. **Bounty IDs are sequential per group.json** — Not global. Each group's file has its own ID counter.
+2. **Group-isolated storage** — Each group has its own directory. No cross-group access.
-3. **Atomic writes** — Uses `tempfile` + `rename` for safe writes.
+3. **Bounty IDs are sequential per group.json** — Not global. Each group's file has its own ID counter.
-4. **No reminders in v1** — Dropped for simplicity.
+4. **Atomic writes** — Uses `tempfile` + `rename` for safe writes.
 
 ---
 ## Commands
@@ -102,7 +123,7 @@ JIGAIDO is a Telegram bot that lets groups and individuals track bounties — ta
 | `/bounty` | anyone | List all bounties in this group |
 | `/my` | anyone | List bounties tracked by you in this group |
 | `/add <text> [link] [due date]` | anyone | Add a new bounty to the group |
-| `/update <bounty_id> [text] [link] [due_date]` | creator only | Update an existing bounty |
+| `/edit <bounty_id> [text] [link] [due_date]` | creator only | Edit an existing bounty |
 | `/delete <bounty_id>` | creator only | Delete a bounty |
 | `/track <bounty_id>` | anyone | Track a group bounty |
 | `/untrack <bounty_id>` | anyone | Stop tracking a bounty |
@@ -114,7 +135,7 @@ JIGAIDO is a Telegram bot that lets groups and individuals track bounties — ta
 | `/bounty` | List all your personal bounties |
 | `/my` | List all your personal bounties |
 | `/add <text> [link] [due date]` | Add a personal bounty |
-| `/update <bounty_id> [text] [link] [due_date]` | Update a personal bounty |
+| `/edit <bounty_id> [text] [link] [due_date]` | Edit a personal bounty |
 | `/delete <bounty_id>` | Delete a personal bounty |
 | `/track <bounty_id>` | Track a personal bounty |
 
@@ -149,7 +170,7 @@ Stored as Unix timestamp. User-facing display can be localized/converted to any
 ## Error Handling
 
 - Unknown command → help text with available commands
-- `/update`/`/delete` by non-creator → "⛔ Only the creator can edit/delete this bounty."
+- `/edit`/`/delete` by non-creator → "⛔ Only the creator can edit/delete this bounty."
 - `/track` already tracked → "Already tracking" (idempotent)
 - `/untrack` not tracked → "Not tracking" (idempotent)
 - Bounty not found → "Bounty not found"

adapters/__init__.py

@@ -0,0 +1,5 @@
+"""Storage adapters for JIGAIDO."""
+
+from adapters.storage.json_file import JsonFileRoomStorage, JsonFileTrackingStorage
+
+__all__ = ["JsonFileRoomStorage", "JsonFileTrackingStorage"]

adapters/storage/__init__.py

@@ -0,0 +1,5 @@
+"""Storage adapters for JIGAIDO."""
+
+from adapters.storage.json_file import JsonFileRoomStorage, JsonFileTrackingStorage
+
+__all__ = ["JsonFileRoomStorage", "JsonFileTrackingStorage"]

adapters/storage/json_file.py

@@ -0,0 +1,256 @@
+"""JSON file storage adapter for JIGAIDO.
+
+Implements RoomStorage and TrackingStorage ports using JSON file persistence.
+Data stored at:
+- Rooms: ~/.jigaido/data/room/<room_id>.json
+- Tracking: ~/.jigaido/data/tracking/<room_id>_<user_id>.json
+"""
+
+import json
+import os
+import tempfile
+from pathlib import Path
+
+from core.models import Bounty, RoomData, TrackingData, TrackedBounty
+from core.ports import RoomStorage, TrackingStorage
+
+
+class JsonFileRoomStorage:
+    """RoomStorage implementation using JSON files.
+
+    Stores room data at ~/.jigaido/data/room/<room_id>.json
+    """
+
+    def __init__(self, data_dir: Path | None = None):
+        if data_dir is None:
+            data_dir = Path.home() / ".jigaido" / "data" / "room"
+        self._data_dir = data_dir
+        self._data_dir.mkdir(parents=True, exist_ok=True)
+
+    def _get_file_path(self, room_id: int) -> Path:
+        return self._data_dir / f"{room_id}.json"
+
+    def _atomic_write(self, path: Path, data: dict) -> None:
+        """Write data atomically using tempfile + rename."""
+        with tempfile.NamedTemporaryFile(
+            mode="w", dir=self._data_dir, delete=False
+        ) as tmp:
+            json.dump(data, tmp, indent=2)
+            tmp_path = tmp.name
+        os.rename(tmp_path, path)
+
+    def load(self, room_id: int) -> RoomData | None:
+        """Load room data from JSON file. Returns None if not found."""
+        file_path = self._get_file_path(room_id)
+        if not file_path.exists():
+            return None
+
+        with open(file_path, "r") as f:
+            data = json.load(f)
+
+        bounties = [
+            Bounty(
+                id=b["id"],
+                text=b.get("text"),
+                link=b.get("link"),
+                due_date_ts=b.get("due_date_ts"),
+                created_at=b["created_at"],
+                created_by_user_id=b["created_by_user_id"],
+                deleted_at=b.get("deleted_at"),
+                created_by_username=b.get("created_by_username"),
+            )
+            for b in data.get("bounties", [])
+        ]
+
+        return RoomData(
+            room_id=data["room_id"],
+            bounties=bounties,
+            next_id=data["next_id"],
+            timezone=data.get("timezone"),
+            admin_user_ids=data.get("admin_user_ids", []),
+        )
+
+    def save(self, room_data: RoomData) -> None:
+        """Save room data to JSON file."""
+        data = {
+            "room_id": room_data.room_id,
+            "next_id": room_data.next_id,
+            "timezone": room_data.timezone,
+            "admin_user_ids": room_data.admin_user_ids or [],
+            "bounties": [
+                {
+                    "id": b.id,
+                    "text": b.text,
+                    "link": b.link,
+                    "due_date_ts": b.due_date_ts,
+                    "created_at": b.created_at,
+                    "created_by_user_id": b.created_by_user_id,
+                    "deleted_at": b.deleted_at,
+                    "created_by_username": b.created_by_username,
+                }
+                for b in room_data.bounties
+            ],
+        }
+
+        self._atomic_write(self._get_file_path(room_data.room_id), data)
+
+    def add_bounty(self, room_id: int, bounty: Bounty) -> None:
+        """Add a bounty to a room, creating the room if necessary."""
+        room_data = self.load(room_id)
+        if room_data is None:
+            room_data = RoomData(room_id=room_id, bounties=[], next_id=1)
+
+        room_data.bounties.append(bounty)
+        if bounty.id >= room_data.next_id:
+            room_data.next_id = bounty.id + 1
+
+        self.save(room_data)
+
+    def update_bounty(self, room_id: int, bounty: Bounty) -> None:
+        """Update an existing bounty in a room."""
+        room_data = self.load(room_id)
+        if room_data is None:
+            return
+
+        for i, b in enumerate(room_data.bounties):
+            if b.id == bounty.id:
+                room_data.bounties[i] = bounty
+                break
+
+        self.save(room_data)
+
+    def delete_bounty(self, room_id: int, bounty_id: int) -> None:
+        """Delete a bounty from a room."""
+        room_data = self.load(room_id)
+        if room_data is None:
+            return
+
+        room_data.bounties = [b for b in room_data.bounties if b.id != bounty_id]
+        self.save(room_data)
+
+    def get_bounty(self, room_id: int, bounty_id: int) -> Bounty | None:
+        """Get a specific bounty from a room by ID."""
+        room_data = self.load(room_id)
+        if room_data is None:
+            return None
+
+        for b in room_data.bounties:
+            if b.id == bounty_id:
+                return b
+
+        return None
+
+    def list_bounties(self, room_id: int) -> list[Bounty]:
+        """List all non-deleted bounties in a room.
+
+        This is the default method for normal queries - soft-deleted bounties
+        are excluded from results.
+        """
+        room_data = self.load(room_id)
+        if room_data is None:
+            return []
+        return [b for b in room_data.bounties if b.deleted_at is None]
+
+    def list_all_bounties(
+        self, room_id: int, include_deleted: bool = True
+    ) -> list[Bounty]:
+        """List all bounties including or excluding soft-deleted.
+
+        Args:
+            room_id: The room ID
+            include_deleted: If True, return all bounties including soft-deleted.
+                           If False, return only non-deleted bounties.
+                           Defaults to True for /recover functionality.
+        """
+        room_data = self.load(room_id)
+        if room_data is None:
+            return []
+        if include_deleted:
+            return room_data.bounties
+        return [b for b in room_data.bounties if b.deleted_at is None]
+
+
+class JsonFileTrackingStorage:
+    """TrackingStorage implementation using JSON files.
+
+    Stores tracking data at ~/.jigaido/data/tracking/<room_id>_<user_id>.json
+    """
+
+    def __init__(self, tracking_dir: Path | None = None):
+        if tracking_dir is None:
+            tracking_dir = Path.home() / ".jigaido" / "data" / "tracking"
+        self._tracking_dir = tracking_dir
+        self._tracking_dir.mkdir(parents=True, exist_ok=True)
+
+    def _get_file_path(self, room_id: int, user_id: int) -> Path:
+        return self._tracking_dir / f"{room_id}_{user_id}.json"
+
+    def _atomic_write(self, path: Path, data: dict) -> None:
+        """Write data atomically using tempfile + rename."""
+        with tempfile.NamedTemporaryFile(
+            mode="w", dir=self._tracking_dir, delete=False
+        ) as tmp:
+            json.dump(data, tmp, indent=2)
+            tmp_path = tmp.name
+        os.rename(tmp_path, path)
+
+    def load(self, room_id: int, user_id: int) -> TrackingData | None:
+        """Load tracking data from JSON file. Returns None if not found."""
+        file_path = self._get_file_path(room_id, user_id)
+        if not file_path.exists():
+            return None
+
+        with open(file_path, "r") as f:
+            data = json.load(f)
+
+        tracked = [
+            TrackedBounty(
+                bounty_id=t["bounty_id"],
+                created_at=t["created_at"],
+            )
+            for t in data.get("tracked", [])
+        ]
+
+        return TrackingData(
+            room_id=data["room_id"],
+            user_id=data["user_id"],
+            tracked=tracked,
+        )
+
+    def save(self, tracking_data: TrackingData) -> None:
+        """Save tracking data."""
+        data = {
+            "room_id": tracking_data.room_id,
+            "user_id": tracking_data.user_id,
+            "tracked": [
+                {
+                    "bounty_id": t.bounty_id,
+                    "created_at": t.created_at,
+                }
+                for t in tracking_data.tracked
+            ],
+        }
+
+        self._atomic_write(
+            self._get_file_path(tracking_data.room_id, tracking_data.user_id), data
+        )
+
+    def track_bounty(self, room_id: int, user_id: int, tracked: TrackedBounty) -> None:
+        """Add a bounty to a user's tracking list, creating the tracking entry if needed."""
+        tracking_data = self.load(room_id, user_id)
+        if tracking_data is None:
+            tracking_data = TrackingData(room_id=room_id, user_id=user_id, tracked=[])
+
+        tracking_data.tracked.append(tracked)
+        self.save(tracking_data)
+
+    def untrack_bounty(self, room_id: int, user_id: int, bounty_id: int) -> None:
+        """Remove a bounty from a user's tracking list."""
+        tracking_data = self.load(room_id, user_id)
+        if tracking_data is None:
+            return
+
+        tracking_data.tracked = [
+            t for t in tracking_data.tracked if t.bounty_id != bounty_id
+        ]
+        self.save(tracking_data)

apps/telegram-bot/bot.py

@@ -4,15 +4,21 @@ import logging
 import os
 import sys
 
-from telegram import Update
+from telegram.ext import Application, CommandHandler, MessageHandler, filters
-from telegram.ext import (
-    Application,
-    CommandHandler,
-    MessageHandler,
-    filters,
-)
 
-import commands
+from commands import (
+    cmd_add,
+    cmd_bounty,
+    cmd_delete,
+    cmd_edit,
+    cmd_help,
+    cmd_my,
+    cmd_start,
+    cmd_timezone,
+    cmd_track,
+    cmd_untrack,
+    cmd_update,
+)
 
 logging.basicConfig(
     format="%(asctime)s %(levelname)s %(name)s: %(message)s",
@@ -26,17 +32,19 @@ BOT_TOKEN = os.environ.get("JIGAIDO_BOT_TOKEN", "")
 def build_app() -> Application:
     app = Application.builder().token(BOT_TOKEN).build()
 
-    app.add_handler(CommandHandler("start", commands.cmd_start))
+    app.add_handler(CommandHandler("start", cmd_start))
-    app.add_handler(CommandHandler("help", commands.cmd_help))
+    app.add_handler(CommandHandler("help", cmd_help))
-    app.add_handler(CommandHandler("bounty", commands.cmd_bounty))
+    app.add_handler(CommandHandler("bounty", cmd_bounty))
-    app.add_handler(CommandHandler("my", commands.cmd_my))
+    app.add_handler(CommandHandler("my", cmd_my))
-    app.add_handler(CommandHandler("add", commands.cmd_add))
+    app.add_handler(CommandHandler("add", cmd_add))
-    app.add_handler(CommandHandler("update", commands.cmd_update))
+    app.add_handler(CommandHandler("edit", cmd_edit))
-    app.add_handler(CommandHandler("delete", commands.cmd_delete))
+    app.add_handler(CommandHandler("update", cmd_update))
-    app.add_handler(CommandHandler("track", commands.cmd_track))
+    app.add_handler(CommandHandler("delete", cmd_delete))
-    app.add_handler(CommandHandler("untrack", commands.cmd_untrack))
+    app.add_handler(CommandHandler("track", cmd_track))
+    app.add_handler(CommandHandler("untrack", cmd_untrack))
+    app.add_handler(CommandHandler("timezone", cmd_timezone))
 
-    app.add_handler(MessageHandler(filters.COMMAND, commands.cmd_help))
+    app.add_handler(MessageHandler(filters.COMMAND, cmd_help))
 
     return app
 
@@ -47,8 +55,10 @@ async def post_init(app: Application) -> None:
             ("bounty", "List bounties"),
             ("my", "Your tracked bounties"),
             ("add", "Add a bounty"),
+            ("edit", "Edit a bounty"),
             ("track", "Track a bounty"),
             ("untrack", "Stop tracking"),
+            ("timezone", "Get/set room timezone"),
             ("help", "Show help"),
         ]
     )

apps/telegram-bot/commands.py

@@ -1,17 +1,21 @@
-"""Telegram command handlers for JIGAIDO."""
+"""Telegram command handlers for JIGAIDO - Thin wrappers around core services."""
 
-import json
-import os
-import re
 import time
 from functools import wraps
 from typing import Optional
+from zoneinfo import ZoneInfo, ZoneInfoNotFoundError
 
 import dateparser
 from telegram import Update
 from telegram.ext import ContextTypes
 
-import storage
+from adapters.storage.json_file import JsonFileRoomStorage, JsonFileTrackingStorage
+from core.services import BountyService, TrackingService
+
+ROOM_STORAGE = JsonFileRoomStorage()
+TRACKING_STORAGE = JsonFileTrackingStorage()
+BOUNTY_SERVICE = BountyService(ROOM_STORAGE)
+TRACKING_SERVICE = TrackingService(TRACKING_STORAGE, ROOM_STORAGE)
 
 TELEGRAM_BOT_USERNAME = "your_bot_username"
 
@@ -45,25 +49,25 @@ def parse_args(args: list[str]) -> tuple[Optional[str], Optional[str], Optional[
     return text, link, due_date_ts
 
 
-def format_bounty(b: dict, show_id: bool = True) -> str:
+def format_bounty(b, show_id: bool = True) -> str:
     parts = []
     if show_id:
-        parts.append(f"[#{b['id']}]")
+        parts.append(f"[#{b.id}]")
-    if b.get("text"):
+    if b.text:
-        parts.append(b["text"])
+        parts.append(b.text)
-    if b.get("link"):
+    if b.link:
-        parts.append(f"🔗 {b['link']}")
+        parts.append(f"🔗 {b.link}")
-    if b.get("due_date_ts"):
+    if b.due_date_ts:
-        due_str = time.strftime("%Y-%m-%d", time.localtime(b["due_date_ts"]))
+        due_str = time.strftime("%Y-%m-%d", time.localtime(b.due_date_ts))
-        days_left = (b["due_date_ts"] - int(time.time())) // 86400
+        days_left = (b.due_date_ts - int(time.time())) // 86400
         if days_left < 0:
             parts.append(f"⏰ {due_str} (OVERDUE)")
         elif days_left == 0:
             parts.append(f"⏰ {due_str} (TODAY)")
         else:
             parts.append(f"⏰ {due_str} ({days_left}d)")
-    if b.get("created_by_user_id"):
+    if b.created_by_user_id:
-        parts.append(f"by {b['created_by_user_id']}")
+        parts.append(f"by {b.created_by_user_id}")
     return " | ".join(parts)
 
 
@@ -79,19 +83,26 @@ def get_user_id(update: Update) -> int:
     return update.effective_user.id
 
 
-async def cmd_bounty(update: Update, ctx: ContextTypes.DEFAULT_TYPE) -> None:
+def get_room_id(update: Update) -> int:
+    """Get room_id for the current context.
+
+    For groups: negative group_id
+    For DMs: positive user_id
+    """
     if is_group(update):
-        data = storage.load_group_bounties(get_group_id(update))
+        return get_group_id(update)
-        bounties = data.get("bounties", [])
+    return get_user_id(update)
-    else:
+
-        data = storage.load_user_personal(get_user_id(update))
+
-        bounties = data.get("bounties", [])
+async def cmd_bounty(update: Update, ctx: ContextTypes.DEFAULT_TYPE) -> None:
+    room_id = get_room_id(update)
+    bounties = BOUNTY_SERVICE.list_bounties(room_id)
 
     if not bounties:
         await update.message.reply_text("No bounties yet.")
         return
 
-    lines = [format_bounty(dict(b), show_id=True) for b in bounties]
+    lines = [format_bounty(b, show_id=True) for b in bounties]
     await update.message.reply_text("\n".join(lines), disable_web_page_preview=True)
 
 
@@ -100,38 +111,22 @@ async def cmd_my(update: Update, ctx: ContextTypes.DEFAULT_TYPE) -> None:
 
     if is_group(update):
         group_id = get_group_id(update)
-        tracking = storage.load_user_tracking(group_id, user_id)
+        bounties = TRACKING_SERVICE.get_tracked_bounties(group_id, user_id)
-        tracked = tracking.get("tracked", [])
     else:
-        data = storage.load_user_personal(user_id)
+        room_id = get_room_id(update)
-        bounties = data.get("bounties", [])
+        bounties = BOUNTY_SERVICE.list_bounties(room_id)
-        lines = [format_bounty(dict(b), show_id=True) for b in bounties]
+
-        await update.message.reply_text(
+    if not bounties:
-            "\n".join(lines) if lines else "No personal bounties.",
+        msg = (
-            disable_web_page_preview=True,
+            "You are not tracking any bounties."
+            if is_group(update)
+            else "No personal bounties."
         )
+        await update.message.reply_text(msg)
         return
 
-    if not tracked:
+    lines = [format_bounty(b, show_id=True) for b in bounties]
-        await update.message.reply_text("You are not tracking any bounties.")
+    await update.message.reply_text("\n".join(lines), disable_web_page_preview=True)
-        return
-
-    group_data = storage.load_group_bounties(group_id)
-    bounty_map = {b["id"]: b for b in group_data.get("bounties", [])}
-
-    bounty_lines = []
-    for t in tracked:
-        bounty = bounty_map.get(t["bounty_id"])
-        if bounty:
-            bounty_lines.append(format_bounty(bounty, show_id=True))
-
-    if not bounty_lines:
-        await update.message.reply_text("You are not tracking any bounties.")
-        return
-
-    await update.message.reply_text(
-        "\n".join(bounty_lines), disable_web_page_preview=True
-    )
 
 
 async def cmd_add(update: Update, ctx: ContextTypes.DEFAULT_TYPE) -> None:
@@ -149,19 +144,22 @@ async def cmd_add(update: Update, ctx: ContextTypes.DEFAULT_TYPE) -> None:
         return
 
     user_id = get_user_id(update)
+    room_id = get_room_id(update)
 
-    if is_group(update):
+    bounty = BOUNTY_SERVICE.add_bounty(
-        group_id = get_group_id(update)
+        room_id=room_id,
-        bounty = storage.add_group_bounty(group_id, user_id, text, link, due_date_ts)
+        user_id=user_id,
-    else:
+        text=text,
-        bounty = storage.add_personal_bounty(user_id, text, link, due_date_ts)
+        link=link,
+        due_date_ts=due_date_ts,
+    )
 
     due_str = ""
     if due_date_ts:
         due_str = f" | Due: {time.strftime('%Y-%m-%d', time.localtime(due_date_ts))}"
 
     await update.message.reply_text(
-        f"✅ Bounty added (#{bounty['id']}){due_str}",
+        f"✅ Bounty added (#{bounty.id}){due_str}",
         disable_web_page_preview=True,
     )
 
@@ -186,64 +184,68 @@ async def cmd_update(update: Update, ctx: ContextTypes.DEFAULT_TYPE) -> None:
         return
 
     user_id = get_user_id(update)
+    room_id = get_room_id(update)
 
-    if is_group(update):
+    try:
-        group_id = get_group_id(update)
+        success = BOUNTY_SERVICE.update_bounty(
-        bounty = storage.get_group_bounty(group_id, bounty_id)
+            room_id=room_id,
-        if not bounty:
+            bounty_id=bounty_id,
-            await update.message.reply_text("Bounty not found.")
+            user_id=user_id,
+            text=text,
+            link=link,
+            due_date_ts=due_date_ts,
+        )
+    except PermissionError as e:
+        await update.message.reply_text(f"⛔ {e}")
         return
-        if bounty["created_by_user_id"] != user_id:
-            await update.message.reply_text("⛔ Only the creator can edit this bounty.")
-            return
-        storage.update_group_bounty(group_id, bounty_id, text, link, due_date_ts)
-    else:
-        bounty = storage.get_personal_bounty(user_id, bounty_id)
-        if not bounty:
-            await update.message.reply_text("Bounty not found.")
-            return
-        storage.update_personal_bounty(user_id, bounty_id, text, link, due_date_ts)
 
+    if success:
         await update.message.reply_text(f"✅ Bounty #{bounty_id} updated.")
+    else:
+        await update.message.reply_text("Bounty not found.")
+
+
+cmd_edit = cmd_update
 
 
 async def cmd_delete(update: Update, ctx: ContextTypes.DEFAULT_TYPE) -> None:
     args = extract_args(update.message.text)
     if not args:
-        await update.message.reply_text("Usage: /delete <bounty_id>")
+        await update.message.reply_text("Usage: /delete <bounty_id> [bounty_id ...]")
         return
 
     try:
-        bounty_id = int(args[0])
+        bounty_ids = [int(arg) for arg in args]
     except ValueError:
-        await update.message.reply_text("Invalid bounty ID.")
+        await update.message.reply_text("Invalid bounty ID(s).")
         return
 
     user_id = get_user_id(update)
+    room_id = get_room_id(update)
 
-    if is_group(update):
+    results = BOUNTY_SERVICE.delete_bounties(
-        group_id = get_group_id(update)
+        room_id=room_id,
-        bounty = storage.get_group_bounty(group_id, bounty_id)
+        bounty_ids=bounty_ids,
-        if not bounty:
+        user_id=user_id,
-            await update.message.reply_text("Bounty not found.")
-            return
-        if bounty["created_by_user_id"] != user_id:
-            await update.message.reply_text(
-                "⛔ Only the creator can delete this bounty."
     )
-            return
-        storage.delete_group_bounty(group_id, bounty_id)
-    else:
-        bounty = storage.get_personal_bounty(user_id, bounty_id)
-        if not bounty:
-            await update.message.reply_text("Bounty not found.")
-            return
-        storage.delete_personal_bounty(user_id, bounty_id)
 
-    await update.message.reply_text(f"✅ Bounty #{bounty_id} deleted.")
+    lines = []
+    for bounty_id, result in results.items():
+        if result == "deleted":
+            lines.append(f"✅ Bounty #{bounty_id} deleted.")
+        elif result == "not_found":
+            lines.append(f"⛔ Bounty #{bounty_id} not found.")
+        elif result == "permission_denied":
+            lines.append(f"⛔ Bounty #{bounty_id} - only admins can delete.")
+
+    await update.message.reply_text("\n".join(lines))
 
 
 async def cmd_track(update: Update, ctx: ContextTypes.DEFAULT_TYPE) -> None:
+    if not is_group(update):
+        await update.message.reply_text("⛔ /track is only available in groups.")
+        return
+
     args = extract_args(update.message.text)
     if not args:
         await update.message.reply_text("Usage: /track <bounty_id>")
@@ -256,25 +258,22 @@ async def cmd_track(update: Update, ctx: ContextTypes.DEFAULT_TYPE) -> None:
         return
 
     user_id = get_user_id(update)
+    room_id = get_room_id(update)
 
-    if is_group(update):
+    try:
-        group_id = get_group_id(update)
+        if TRACKING_SERVICE.track_bounty(room_id, user_id, bounty_id):
-        bounty = storage.get_group_bounty(group_id, bounty_id)
-        if not bounty:
-            await update.message.reply_text("Bounty not found.")
-            return
-        if storage.track_bounty(group_id, user_id, bounty_id):
-            await update.message.reply_text(f"✅ Now tracking bounty #{bounty_id}.")
-        else:
-            await update.message.reply_text(f"Already tracking bounty #{bounty_id}.")
-    else:
-        if storage.track_bounty(user_id, user_id, bounty_id):
             await update.message.reply_text(f"✅ Now tracking bounty #{bounty_id}.")
         else:
             await update.message.reply_text(f"Already tracking bounty #{bounty_id}.")
+    except ValueError as e:
+        await update.message.reply_text(str(e))
 
 
 async def cmd_untrack(update: Update, ctx: ContextTypes.DEFAULT_TYPE) -> None:
+    if not is_group(update):
+        await update.message.reply_text("⛔ /untrack is only available in groups.")
+        return
+
     args = extract_args(update.message.text)
     if not args:
         await update.message.reply_text("Usage: /untrack <bounty_id>")
@@ -287,18 +286,12 @@ async def cmd_untrack(update: Update, ctx: ContextTypes.DEFAULT_TYPE) -> None:
         return
 
     user_id = get_user_id(update)
+    room_id = get_room_id(update)
 
-    if is_group(update):
+    if TRACKING_SERVICE.untrack_bounty(room_id, user_id, bounty_id):
-        group_id = get_group_id(update)
-        if storage.untrack_bounty(group_id, user_id, bounty_id):
         await update.message.reply_text(f"✅ Untracked bounty #{bounty_id}.")
     else:
-            await update.message.reply_text(f"Not tracking bounty #{bounty_id}.")
+        await update.message.reply_text("Not tracking bounty #{bounty_id}.")
-    else:
-        if storage.untrack_bounty(user_id, user_id, bounty_id):
-            await update.message.reply_text(f"✅ Untracked bounty #{bounty_id}.")
-        else:
-            await update.message.reply_text(f"Not tracking bounty #{bounty_id}.")
 
 
 async def cmd_start(update: Update, ctx: ContextTypes.DEFAULT_TYPE) -> None:
@@ -327,11 +320,41 @@ async def cmd_help(update: Update, ctx: ContextTypes.DEFAULT_TYPE) -> None:
         "/bounty — list all bounties\n"
         "/my — bounties you're tracking\n"
         "/add <text> [link] [due] — add bounty\n"
-        "/update <id> [text] [link] [due] — update bounty\n"
+        "/update <id> [text> [link] [due] — update bounty\n"
         "/delete <id> — delete bounty\n"
-        "/track <id> — track a bounty\n"
+        "/track <id> — track a bounty (groups only)\n"
-        "/untrack <id> — stop tracking\n"
+        "/untrack <id> — stop tracking (groups only)\n"
+        "/timezone [tz] — get/set room timezone (admin only)\n"
         "/start — re-initialize\n"
         "/help — this message",
         disable_web_page_preview=True,
     )
+
+
+async def cmd_timezone(update: Update, ctx: ContextTypes.DEFAULT_TYPE) -> None:
+    args = extract_args(update.message.text)
+    room_id = get_room_id(update)
+    user_id = get_user_id(update)
+
+    if not args:
+        current_tz = BOUNTY_SERVICE.get_timezone(room_id)
+        await update.message.reply_text(f"Current timezone: {current_tz}")
+        return
+
+    timezone_str = args[0]
+
+    try:
+        ZoneInfo(timezone_str)
+    except (KeyError, ZoneInfoNotFoundError):
+        await update.message.reply_text(
+            "⛔ Invalid timezone. Use IANA format (e.g., Asia/Jakarta)"
+        )
+        return
+
+    try:
+        BOUNTY_SERVICE.set_timezone(room_id, timezone_str, user_id)
+    except PermissionError as e:
+        await update.message.reply_text(f"⛔ {e}")
+        return
+
+    await update.message.reply_text(f"✅ Timezone set to {timezone_str}.")

apps/telegram-bot/requirements-dev.txt

@@ -1,4 +0,0 @@
-python-telegram-bot==21.6
-dateparser==1.2.0
-pytest==8.3.5
-pytest-asyncio==0.25.2

apps/telegram-bot/storage.py

@@ -1,216 +0,0 @@
-"""Per-group JSON file storage for JIGAIDO."""
-
-import json
-import os
-import tempfile
-from pathlib import Path
-from typing import Optional
-
-DATA_DIR = Path.home() / ".jigaido"
-
-
-def _ensure_dirs() -> None:
-    DATA_DIR.mkdir(parents=True, exist_ok=True)
-
-
-def _group_dir(group_id: int) -> Path:
-    return DATA_DIR / str(group_id)
-
-
-def _user_personal_dir(user_id: int) -> Path:
-    return DATA_DIR / str(user_id)
-
-
-def _group_file(group_id: int) -> Path:
-    return _group_dir(group_id) / "group.json"
-
-
-def _user_tracking_file(group_id: int, user_id: int) -> Path:
-    return _group_dir(group_id) / f"{user_id}.json"
-
-
-def _user_personal_file(user_id: int) -> Path:
-    return _user_personal_dir(user_id) / "user.json"
-
-
-def _atomic_write(path: Path, data: dict) -> None:
-    path.parent.mkdir(parents=True, exist_ok=True)
-    with tempfile.NamedTemporaryFile(mode="w", dir=path.parent, delete=False) as tmp:
-        json.dump(data, tmp, indent=2)
-        tmp_path = tmp.name
-    os.rename(tmp_path, path)
-
-
-def load_group_bounties(group_id: int) -> dict:
-    _ensure_dirs()
-    path = _group_file(group_id)
-    if not path.exists():
-        return {"bounties": [], "next_id": 1}
-    with open(path) as f:
-        return json.load(f)
-
-
-def save_group_bounties(group_id: int, data: dict) -> None:
-    _atomic_write(_group_file(group_id), data)
-
-
-def add_group_bounty(
-    group_id: int,
-    created_by_user_id: int,
-    text: Optional[str],
-    link: Optional[str],
-    due_date_ts: Optional[int],
-) -> dict:
-    data = load_group_bounties(group_id)
-    bounty = {
-        "id": data["next_id"],
-        "created_by_user_id": created_by_user_id,
-        "text": text,
-        "link": link,
-        "due_date_ts": due_date_ts,
-        "created_at": int(os.path.getctime(_group_file(group_id)))
-        if _group_file(group_id).exists()
-        else 0,
-    }
-    data["bounties"].append(bounty)
-    data["next_id"] += 1
-    save_group_bounties(group_id, data)
-    return bounty
-
-
-def update_group_bounty(
-    group_id: int,
-    bounty_id: int,
-    text: Optional[str],
-    link: Optional[str],
-    due_date_ts: Optional[int],
-) -> bool:
-    data = load_group_bounties(group_id)
-    for bounty in data["bounties"]:
-        if bounty["id"] == bounty_id:
-            if text is not None:
-                bounty["text"] = text
-            if link is not None:
-                bounty["link"] = link
-            if due_date_ts is not None:
-                bounty["due_date_ts"] = due_date_ts
-            save_group_bounties(group_id, data)
-            return True
-    return False
-
-
-def delete_group_bounty(group_id: int, bounty_id: int) -> bool:
-    data = load_group_bounties(group_id)
-    for i, bounty in enumerate(data["bounties"]):
-        if bounty["id"] == bounty_id:
-            data["bounties"].pop(i)
-            save_group_bounties(group_id, data)
-            return True
-    return False
-
-
-def get_group_bounty(group_id: int, bounty_id: int) -> Optional[dict]:
-    data = load_group_bounties(group_id)
-    for bounty in data["bounties"]:
-        if bounty["id"] == bounty_id:
-            return bounty
-    return None
-
-
-def load_user_tracking(group_id: int, user_id: int) -> dict:
-    path = _user_tracking_file(group_id, user_id)
-    if not path.exists():
-        return {"tracked": []}
-    with open(path) as f:
-        return json.load(f)
-
-
-def save_user_tracking(group_id: int, user_id: int, data: dict) -> None:
-    _atomic_write(_user_tracking_file(group_id, user_id), data)
-
-
-def track_bounty(group_id: int, user_id: int, bounty_id: int) -> bool:
-    data = load_user_tracking(group_id, user_id)
-    if any(t["bounty_id"] == bounty_id for t in data["tracked"]):
-        return False
-    data["tracked"].append({"bounty_id": bounty_id})
-    save_user_tracking(group_id, user_id, data)
-    return True
-
-
-def untrack_bounty(group_id: int, user_id: int, bounty_id: int) -> bool:
-    data = load_user_tracking(group_id, user_id)
-    for i, t in enumerate(data["tracked"]):
-        if t["bounty_id"] == bounty_id:
-            data["tracked"].pop(i)
-            save_user_tracking(group_id, user_id, data)
-            return True
-    return False
-
-
-def load_user_personal(user_id: int) -> dict:
-    path = _user_personal_file(user_id)
-    if not path.exists():
-        return {"bounties": [], "next_id": 1}
-    with open(path) as f:
-        return json.load(f)
-
-
-def save_user_personal(user_id: int, data: dict) -> None:
-    _atomic_write(_user_personal_file(user_id), data)
-
-
-def add_personal_bounty(
-    user_id: int, text: Optional[str], link: Optional[str], due_date_ts: Optional[int]
-) -> dict:
-    data = load_user_personal(user_id)
-    bounty = {
-        "id": data["next_id"],
-        "text": text,
-        "link": link,
-        "due_date_ts": due_date_ts,
-        "created_at": 0,
-    }
-    data["bounties"].append(bounty)
-    data["next_id"] += 1
-    save_user_personal(user_id, data)
-    return bounty
-
-
-def update_personal_bounty(
-    user_id: int,
-    bounty_id: int,
-    text: Optional[str],
-    link: Optional[str],
-    due_date_ts: Optional[int],
-) -> bool:
-    data = load_user_personal(user_id)
-    for bounty in data["bounties"]:
-        if bounty["id"] == bounty_id:
-            if text is not None:
-                bounty["text"] = text
-            if link is not None:
-                bounty["link"] = link
-            if due_date_ts is not None:
-                bounty["due_date_ts"] = due_date_ts
-            save_user_personal(user_id, data)
-            return True
-    return False
-
-
-def delete_personal_bounty(user_id: int, bounty_id: int) -> bool:
-    data = load_user_personal(user_id)
-    for i, bounty in enumerate(data["bounties"]):
-        if bounty["id"] == bounty_id:
-            data["bounties"].pop(i)
-            save_user_personal(user_id, data)
-            return True
-    return False
-
-
-def get_personal_bounty(user_id: int, bounty_id: int) -> Optional[dict]:
-    data = load_user_personal(user_id)
-    for bounty in data["bounties"]:
-        if bounty["id"] == bounty_id:
-            return bounty
-    return None

apps/telegram-bot/tests/conftest.py

@@ -6,22 +6,5 @@ from pathlib import Path
 
 import pytest
 
-# Add the app directory to path so `import db` works when running pytest
+# Add the app directory to path so imports work when running pytest
 sys.path.insert(0, str(Path(__file__).parent.parent))
-
-
-@pytest.fixture(autouse=True)
-def fresh_db(monkeypatch):
-    """Replace DB_PATH with a temp file before any test runs."""
-    import db as _db
-
-    tmp = tempfile.NamedTemporaryFile(suffix=".db", delete=False)
-    tmp_path = Path(tmp.name)
-    tmp.close()
-
-    monkeypatch.setattr(_db, "DB_PATH", tmp_path)
-    _db.init_db()
-
-    yield tmp_path
-
-    tmp_path.unlink(missing_ok=True)

apps/telegram-bot/tests/test_commands.py

@@ -1,11 +1,33 @@
-"""Tests for commands.py — parsing and formatting functions only."""
+"""Tests for commands.py — parsing, formatting, and command handlers."""
 
 import time
-from unittest.mock import MagicMock
+from unittest.mock import MagicMock, patch, AsyncMock, sentinel
 
 import pytest
 
-from commands import extract_args, parse_args, format_bounty
+from telegram import Update, Message, User, Chat, CallbackQuery
+from telegram.ext import ContextTypes
+
+from commands import (
+    extract_args,
+    parse_args,
+    format_bounty,
+    cmd_bounty,
+    cmd_my,
+    cmd_add,
+    cmd_update,
+    cmd_delete,
+    cmd_track,
+    cmd_untrack,
+    cmd_start,
+    cmd_help,
+    is_group,
+    get_group_id,
+    get_user_id,
+    get_room_id,
+    BOUNTY_SERVICE,
+    TRACKING_SERVICE,
+)
 
 
 class TestExtractArgs:
@@ -110,13 +132,11 @@ class TestFormatBounty:
         created_by_user_id=123456,
     ):
         row = MagicMock()
-        row.__getitem__ = lambda s, k: {
+        row.id = id
-            "id": id,
+        row.text = text
-            "text": text,
+        row.link = link
-            "link": link,
+        row.due_date_ts = due_date_ts
-            "due_date_ts": due_date_ts,
+        row.created_by_user_id = created_by_user_id
-            "created_by_user_id": created_by_user_id,
-        }[k]
         return row
 
     def test_shows_id(self):
@@ -168,3 +188,378 @@ class TestFormatBounty:
         b = self._row(created_by_user_id=999)
         out = format_bounty(b)
         assert "999" in out
+
+
+def create_mock_update(
+    user_id=123,
+    chat_id=-456,
+    chat_type="group",
+    message_text="/bounty",
+):
+    """Create a mock Telegram Update with common values."""
+    user = MagicMock(spec=User)
+    user.id = user_id
+
+    chat = MagicMock(spec=Chat)
+    chat.id = chat_id
+    chat.type = chat_type
+
+    message = MagicMock(spec=Message)
+    message.text = message_text
+    message.reply_text = AsyncMock()
+    message.user = user
+
+    update = MagicMock(spec=Update)
+    update.effective_user = user
+    update.effective_chat = chat
+    update.message = message
+
+    return update
+
+
+class TestHelperFunctions:
+    """Test helper functions."""
+
+    def test_is_group_true(self):
+        update = create_mock_update(chat_type="group")
+        assert is_group(update) is True
+
+    def test_is_group_false_for_private(self):
+        update = create_mock_update(chat_type="private")
+        assert is_group(update) is False
+
+    def test_get_group_id(self):
+        update = create_mock_update(chat_id=-789)
+        assert get_group_id(update) == -789
+
+    def test_get_user_id(self):
+        update = create_mock_update(user_id=999)
+        assert get_user_id(update) == 999
+
+    def test_get_room_id_group(self):
+        update = create_mock_update(chat_id=-456, chat_type="group", user_id=123)
+        assert get_room_id(update) == -456
+
+    def test_get_room_id_private(self):
+        update = create_mock_update(chat_id=123, chat_type="private", user_id=123)
+        assert get_room_id(update) == 123
+
+
+class TestCmdBounty:
+    """Test cmd_bounty command."""
+
+    @pytest.mark.asyncio
+    async def test_lists_bounties(self):
+        update = create_mock_update()
+        ctx = MagicMock(spec=ContextTypes.DEFAULT_TYPE)
+
+        mock_bounty = MagicMock()
+        mock_bounty.id = 1
+        mock_bounty.text = "Test"
+        mock_bounty.link = None
+        mock_bounty.due_date_ts = None
+        mock_bounty.created_by_user_id = 123
+
+        with patch.object(
+            BOUNTY_SERVICE, "list_bounties", return_value=[mock_bounty]
+        ) as mock_list:
+            await cmd_bounty(update, ctx)
+            mock_list.assert_called_once_with(-456)
+            update.message.reply_text.assert_called_once()
+            call_args = update.message.reply_text.call_args[0][0]
+            assert "[#1]" in call_args
+            assert "Test" in call_args
+
+    @pytest.mark.asyncio
+    async def test_no_bounties(self):
+        update = create_mock_update()
+        ctx = MagicMock(spec=ContextTypes.DEFAULT_TYPE)
+
+        with patch.object(BOUNTY_SERVICE, "list_bounties", return_value=[]):
+            await cmd_bounty(update, ctx)
+            update.message.reply_text.assert_called_once_with("No bounties yet.")
+
+
+class TestCmdMy:
+    """Test cmd_my command."""
+
+    @pytest.mark.asyncio
+    async def test_in_group_shows_tracked(self):
+        update = create_mock_update(chat_type="group")
+        ctx = MagicMock(spec=ContextTypes.DEFAULT_TYPE)
+
+        mock_bounty = MagicMock()
+        mock_bounty.id = 1
+        mock_bounty.text = "Tracked"
+        mock_bounty.link = None
+        mock_bounty.due_date_ts = None
+        mock_bounty.created_by_user_id = 123
+
+        with patch.object(
+            TRACKING_SERVICE, "get_tracked_bounties", return_value=[mock_bounty]
+        ) as mock_track:
+            await cmd_my(update, ctx)
+            mock_track.assert_called_once_with(-456, 123)
+            update.message.reply_text.assert_called_once()
+
+    @pytest.mark.asyncio
+    async def test_in_private_shows_personal(self):
+        update = create_mock_update(chat_type="private", chat_id=123)
+        ctx = MagicMock(spec=ContextTypes.DEFAULT_TYPE)
+
+        mock_bounty = MagicMock()
+        mock_bounty.id = 2
+        mock_bounty.text = "Personal"
+        mock_bounty.link = None
+        mock_bounty.due_date_ts = None
+        mock_bounty.created_by_user_id = 123
+
+        with patch.object(
+            BOUNTY_SERVICE, "list_bounties", return_value=[mock_bounty]
+        ) as mock_list:
+            await cmd_my(update, ctx)
+            mock_list.assert_called_once_with(123)
+            update.message.reply_text.assert_called_once()
+
+    @pytest.mark.asyncio
+    async def test_no_bounties_tracked(self):
+        update = create_mock_update(chat_type="group")
+        ctx = MagicMock(spec=ContextTypes.DEFAULT_TYPE)
+
+        with patch.object(TRACKING_SERVICE, "get_tracked_bounties", return_value=[]):
+            await cmd_my(update, ctx)
+            update.message.reply_text.assert_called_once_with(
+                "You are not tracking any bounties."
+            )
+
+
+class TestCmdAdd:
+    """Test cmd_add command."""
+
+    @pytest.mark.asyncio
+    async def test_add_bounty_success(self):
+        update = create_mock_update(message_text="/add Fix the bug")
+        ctx = MagicMock(spec=ContextTypes.DEFAULT_TYPE)
+
+        mock_bounty = MagicMock()
+        mock_bounty.id = 42
+
+        with patch.object(
+            BOUNTY_SERVICE, "add_bounty", return_value=mock_bounty
+        ) as mock_add:
+            await cmd_add(update, ctx)
+            mock_add.assert_called_once()
+            call_kwargs = mock_add.call_args[1]
+            assert call_kwargs["room_id"] == -456
+            assert call_kwargs["user_id"] == 123
+            assert call_kwargs["text"] == "Fix the bug"
+            update.message.reply_text.assert_called_once()
+            assert "✅" in update.message.reply_text.call_args[0][0]
+
+    @pytest.mark.asyncio
+    async def test_add_without_args(self):
+        update = create_mock_update(message_text="/add")
+        ctx = MagicMock(spec=ContextTypes.DEFAULT_TYPE)
+
+        await cmd_add(update, ctx)
+        update.message.reply_text.assert_called_once()
+        assert "Usage" in update.message.reply_text.call_args[0][0]
+
+    @pytest.mark.asyncio
+    async def test_add_needs_text_or_link(self):
+        update = create_mock_update(message_text="/add")
+        ctx = MagicMock(spec=ContextTypes.DEFAULT_TYPE)
+
+        _, link, _ = parse_args([])
+        if not "test" and not link:
+            await update.message.reply_text("A bounty needs at least text or a link.")
+            update.message.reply_text.assert_called_once()
+
+
+class TestCmdUpdate:
+    """Test cmd_update command."""
+
+    @pytest.mark.asyncio
+    async def test_update_bounty_success(self):
+        update = create_mock_update(message_text="/update 1 New text")
+        ctx = MagicMock(spec=ContextTypes.DEFAULT_TYPE)
+
+        with patch.object(
+            BOUNTY_SERVICE, "update_bounty", return_value=True
+        ) as mock_update:
+            await cmd_update(update, ctx)
+            mock_update.assert_called_once()
+            call_kwargs = mock_update.call_args[1]
+            assert call_kwargs["room_id"] == -456
+            assert call_kwargs["bounty_id"] == 1
+            assert call_kwargs["text"] == "New text"
+            update.message.reply_text.assert_called_once()
+            assert "✅" in update.message.reply_text.call_args[0][0]
+
+    @pytest.mark.asyncio
+    async def test_update_without_args(self):
+        update = create_mock_update(message_text="/update")
+        ctx = MagicMock(spec=ContextTypes.DEFAULT_TYPE)
+
+        await cmd_update(update, ctx)
+        update.message.reply_text.assert_called_once()
+        assert "Usage" in update.message.reply_text.call_args[0][0]
+
+    @pytest.mark.asyncio
+    async def test_update_invalid_id(self):
+        update = create_mock_update(message_text="/update abc")
+        ctx = MagicMock(spec=ContextTypes.DEFAULT_TYPE)
+
+        await cmd_update(update, ctx)
+        update.message.reply_text.assert_called_once_with("Invalid bounty ID.")
+
+    @pytest.mark.asyncio
+    async def test_update_permission_denied(self):
+        update = create_mock_update(message_text="/update 1 new text")
+        ctx = MagicMock(spec=ContextTypes.DEFAULT_TYPE)
+
+        with patch.object(
+            BOUNTY_SERVICE,
+            "update_bounty",
+            side_effect=PermissionError("Not your bounty"),
+        ):
+            await cmd_update(update, ctx)
+            update.message.reply_text.assert_called_once()
+            assert "⛔" in update.message.reply_text.call_args[0][0]
+
+
+class TestCmdDelete:
+    """Test cmd_delete command."""
+
+    @pytest.mark.asyncio
+    async def test_delete_bounty_success(self):
+        update = create_mock_update(message_text="/delete 1")
+        ctx = MagicMock(spec=ContextTypes.DEFAULT_TYPE)
+
+        with patch.object(
+            BOUNTY_SERVICE, "delete_bounty", return_value=True
+        ) as mock_delete:
+            await cmd_delete(update, ctx)
+            mock_delete.assert_called_once_with(room_id=-456, bounty_id=1, user_id=123)
+            update.message.reply_text.assert_called_once()
+            assert "✅" in update.message.reply_text.call_args[0][0]
+
+    @pytest.mark.asyncio
+    async def test_delete_without_args(self):
+        update = create_mock_update(message_text="/delete")
+        ctx = MagicMock(spec=ContextTypes.DEFAULT_TYPE)
+
+        await cmd_delete(update, ctx)
+        update.message.reply_text.assert_called_once()
+        assert "Usage" in update.message.reply_text.call_args[0][0]
+
+    @pytest.mark.asyncio
+    async def test_delete_invalid_id(self):
+        update = create_mock_update(message_text="/delete abc")
+        ctx = MagicMock(spec=ContextTypes.DEFAULT_TYPE)
+
+        await cmd_delete(update, ctx)
+        update.message.reply_text.assert_called_once_with("Invalid bounty ID.")
+
+
+class TestCmdTrack:
+    """Test cmd_track command."""
+
+    @pytest.mark.asyncio
+    async def test_track_in_group(self):
+        update = create_mock_update(chat_type="group", message_text="/track 1")
+        ctx = MagicMock(spec=ContextTypes.DEFAULT_TYPE)
+
+        with patch.object(
+            TRACKING_SERVICE, "track_bounty", return_value=True
+        ) as mock_track:
+            await cmd_track(update, ctx)
+            mock_track.assert_called_once_with(-456, 123, 1)
+            update.message.reply_text.assert_called_once()
+            assert "✅" in update.message.reply_text.call_args[0][0]
+
+    @pytest.mark.asyncio
+    async def test_track_not_in_group(self):
+        update = create_mock_update(chat_type="private", message_text="/track 1")
+        ctx = MagicMock(spec=ContextTypes.DEFAULT_TYPE)
+
+        await cmd_track(update, ctx)
+        update.message.reply_text.assert_called_once()
+        assert "⛔" in update.message.reply_text.call_args[0][0]
+
+    @pytest.mark.asyncio
+    async def test_track_without_args(self):
+        update = create_mock_update(chat_type="group", message_text="/track")
+        ctx = MagicMock(spec=ContextTypes.DEFAULT_TYPE)
+
+        await cmd_track(update, ctx)
+        update.message.reply_text.assert_called_once()
+        assert "Usage" in update.message.reply_text.call_args[0][0]
+
+
+class TestCmdUntrack:
+    """Test cmd_untrack command."""
+
+    @pytest.mark.asyncio
+    async def test_untrack_in_group(self):
+        update = create_mock_update(chat_type="group", message_text="/untrack 1")
+        ctx = MagicMock(spec=ContextTypes.DEFAULT_TYPE)
+
+        with patch.object(
+            TRACKING_SERVICE, "untrack_bounty", return_value=True
+        ) as mock_untrack:
+            await cmd_untrack(update, ctx)
+            mock_untrack.assert_called_once_with(-456, 123, 1)
+            update.message.reply_text.assert_called_once()
+            assert "✅" in update.message.reply_text.call_args[0][0]
+
+    @pytest.mark.asyncio
+    async def test_untrack_not_in_group(self):
+        update = create_mock_update(chat_type="private", message_text="/untrack 1")
+        ctx = MagicMock(spec=ContextTypes.DEFAULT_TYPE)
+
+        await cmd_untrack(update, ctx)
+        update.message.reply_text.assert_called_once()
+        assert "⛔" in update.message.reply_text.call_args[0][0]
+
+
+class TestCmdStart:
+    """Test cmd_start command."""
+
+    @pytest.mark.asyncio
+    async def test_start_in_group(self):
+        update = create_mock_update(chat_type="group")
+        ctx = MagicMock(spec=ContextTypes.DEFAULT_TYPE)
+
+        await cmd_start(update, ctx)
+        update.message.reply_text.assert_called_once()
+        text = update.message.reply_text.call_args[0][0]
+        assert "👻" in text
+        assert "/bounty" in text
+
+    @pytest.mark.asyncio
+    async def test_start_in_private(self):
+        update = create_mock_update(chat_type="private")
+        ctx = MagicMock(spec=ContextTypes.DEFAULT_TYPE)
+
+        await cmd_start(update, ctx)
+        update.message.reply_text.assert_called_once()
+        text = update.message.reply_text.call_args[0][0]
+        assert "👻" in text
+        assert "/my" in text
+
+
+class TestCmdHelp:
+    """Test cmd_help command."""
+
+    @pytest.mark.asyncio
+    async def test_help_shows_commands(self):
+        update = create_mock_update()
+        ctx = MagicMock(spec=ContextTypes.DEFAULT_TYPE)
+
+        await cmd_help(update, ctx)
+        update.message.reply_text.assert_called_once()
+        text = update.message.reply_text.call_args[0][0]
+        assert "/bounty" in text
+        assert "/add" in text
+        assert "/help" in text

cli/main.py

@@ -0,0 +1,251 @@
+"""JIGAIDO CLI - Command line interface for bounty tracking."""
+
+import argparse
+import sys
+from pathlib import Path
+
+import dateparser
+
+from adapters.storage.json_file import JsonFileRoomStorage, JsonFileTrackingStorage
+from config import Config
+from core.services import BountyService, TrackingService
+
+
+def parse_due_date(due_str: str | None) -> int | None:
+    """Parse due date string to Unix timestamp."""
+    if not due_str:
+        return None
+    parsed = dateparser.parse(due_str)
+    if parsed:
+        return int(parsed.timestamp())
+    return None
+
+
+def create_services():
+    """Create service instances with storage."""
+    config = Config()
+    config.ensure_data_dir()
+    room_storage = JsonFileRoomStorage(config.data_dir / "room")
+    tracking_storage = JsonFileTrackingStorage(config.data_dir / "tracking")
+    bounty_service = BountyService(room_storage)
+    tracking_service = TrackingService(tracking_storage, room_storage)
+    return bounty_service, tracking_service
+
+
+def cmd_add(args):
+    """Add a new bounty."""
+    bounty_service, _ = create_services()
+    due_ts = parse_due_date(args.due)
+    bounty = bounty_service.add_bounty(
+        room_id=args.group_id or args.user_id,
+        user_id=args.user_id or 0,
+        text=args.text,
+        link=args.link,
+        due_date_ts=due_ts,
+    )
+    print(f"Added bounty #{bounty.id}")
+
+
+def cmd_list(args):
+    """List all bounties in a room."""
+    bounty_service, _ = create_services()
+    bounties = bounty_service.list_bounties(room_id=args.group_id or args.user_id)
+    if not bounties:
+        print("No bounties")
+        return
+    for b in bounties:
+        due_str = (
+            f", due: {dateparser.parse(str(b.due_date_ts)).strftime('%Y-%m-%d')}"
+            if b.due_date_ts
+            else ""
+        )
+        link_str = f", link: {b.link}" if b.link else ""
+        print(f"#{b.id}: {b.text or '(no text)'}{link_str}{due_str}")
+
+
+def cmd_my(args):
+    """List tracked bounties for a user."""
+    _, tracking_service = create_services()
+    room_id = args.group_id or args.user_id
+    tracked = tracking_service.get_tracked_bounties(
+        room_id=room_id, user_id=args.user_id
+    )
+    if not tracked:
+        print("Not tracking any bounties")
+        return
+    for b in tracked:
+        due_str = (
+            f", due: {dateparser.parse(str(b.due_date_ts)).strftime('%Y-%m-%d')}"
+            if b.due_date_ts
+            else ""
+        )
+        link_str = f", link: {b.link}" if b.link else ""
+        print(f"#{b.id}: {b.text or '(no text)'}{link_str}{due_str}")
+
+
+def cmd_update(args):
+    """Update a bounty."""
+    bounty_service, _ = create_services()
+    due_ts = parse_due_date(args.due)
+    try:
+        success = bounty_service.update_bounty(
+            room_id=args.group_id or args.user_id,
+            bounty_id=args.bounty_id,
+            user_id=args.user_id or 0,
+            text=args.text,
+            link=args.link,
+            due_date_ts=due_ts,
+            clear_link=args.clear_link,
+            clear_due=args.clear_due,
+        )
+        if success:
+            print(f"Updated bounty #{args.bounty_id}")
+        else:
+            print(f"Bounty #{args.bounty_id} not found", file=sys.stderr)
+            sys.exit(1)
+    except PermissionError as e:
+        print(f"Error: {e}", file=sys.stderr)
+        sys.exit(1)
+
+
+def cmd_delete(args):
+    """Delete a bounty."""
+    bounty_service, _ = create_services()
+    try:
+        success = bounty_service.delete_bounty(
+            room_id=args.group_id or args.user_id,
+            bounty_id=args.bounty_id,
+            user_id=args.user_id or 0,
+        )
+        if success:
+            print(f"Deleted bounty #{args.bounty_id}")
+        else:
+            print(f"Bounty #{args.bounty_id} not found", file=sys.stderr)
+            sys.exit(1)
+    except PermissionError as e:
+        print(f"Error: {e}", file=sys.stderr)
+        sys.exit(1)
+
+
+def cmd_track(args):
+    """Track a bounty."""
+    _, tracking_service = create_services()
+    try:
+        success = tracking_service.track_bounty(
+            room_id=args.group_id,
+            user_id=args.user_id,
+            bounty_id=args.bounty_id,
+        )
+        if success:
+            print(f"Tracking bounty #{args.bounty_id}")
+        else:
+            print(f"Already tracking bounty #{args.bounty_id}")
+    except ValueError as e:
+        print(f"Error: {e}", file=sys.stderr)
+        sys.exit(1)
+
+
+def cmd_untrack(args):
+    """Untrack a bounty."""
+    _, tracking_service = create_services()
+    success = tracking_service.untrack_bounty(
+        room_id=args.group_id,
+        user_id=args.user_id,
+        bounty_id=args.bounty_id,
+    )
+    if success:
+        print(f"Untracked bounty #{args.bounty_id}")
+    else:
+        print(f"Not tracking bounty #{args.bounty_id}", file=sys.stderr)
+        sys.exit(1)
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        prog="jigaido-cli", description="JIGAIDO bounty tracker CLI"
+    )
+    subparsers = parser.add_subparsers(dest="command", help="Commands")
+
+    parser_add = subparsers.add_parser("add", help="Add a new bounty")
+    parser_add.add_argument("text", help="Bounty description")
+    parser_add.add_argument("--link", help="Optional link")
+    parser_add.add_argument(
+        "--due", help="Optional due date (e.g., 'tomorrow', 'in 3 days')"
+    )
+
+    parser_list = subparsers.add_parser("list", help="List all bounties")
+
+    parser_my = subparsers.add_parser("my", help="List tracked bounties")
+
+    parser_update = subparsers.add_parser("update", help="Update a bounty")
+    parser_update.add_argument("bounty_id", type=int, help="Bounty ID to update")
+    parser_update.add_argument("text", nargs="?", help="New description")
+    parser_update.add_argument("--link", help="New link")
+    parser_update.add_argument("--due", help="New due date")
+    parser_update.add_argument("--clear-link", action="store_true", help="Clear link")
+    parser_update.add_argument(
+        "--clear-due", action="store_true", help="Clear due date"
+    )
+
+    parser_delete = subparsers.add_parser("delete", help="Delete a bounty")
+    parser_delete.add_argument("bounty_id", type=int, help="Bounty ID to delete")
+
+    parser_track = subparsers.add_parser("track", help="Track a bounty")
+    parser_track.add_argument("bounty_id", type=int, help="Bounty ID to track")
+
+    parser_untrack = subparsers.add_parser("untrack", help="Untrack a bounty")
+    parser_untrack.add_argument("bounty_id", type=int, help="Bounty ID to untrack")
+
+    for sp in [
+        parser_add,
+        parser_list,
+        parser_my,
+        parser_update,
+        parser_delete,
+        parser_track,
+        parser_untrack,
+    ]:
+        sp.add_argument(
+            "--group-id", type=int, help="Group context (use group room ID)"
+        )
+        sp.add_argument(
+            "--user-id", type=int, help="User context (use Telegram user ID)"
+        )
+
+    args = parser.parse_args()
+
+    if not args.command:
+        parser.print_help()
+        sys.exit(1)
+
+    if not args.group_id and not args.user_id:
+        print("Error: either --group-id or --user-id is required", file=sys.stderr)
+        sys.exit(1)
+
+    if args.command in ("add", "list", "my", "update", "delete"):
+        if not (args.group_id or args.user_id):
+            print("Error: --group-id or --user-id required", file=sys.stderr)
+            sys.exit(1)
+        if args.command == "add" and not args.text:
+            print("Error: text is required for add", file=sys.stderr)
+            sys.exit(1)
+
+    command_map = {
+        "add": cmd_add,
+        "list": cmd_list,
+        "my": cmd_my,
+        "update": cmd_update,
+        "delete": cmd_delete,
+        "track": cmd_track,
+        "untrack": cmd_untrack,
+    }
+
+    if args.command in command_map:
+        command_map[args.command](args)
+    else:
+        print(f"Unknown command: {args.command}", file=sys.stderr)
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

core/models.py

@@ -9,6 +9,9 @@ class Bounty:
 
     The created_by_user_id field always refers to the user who created the bounty.
     It does NOT indicate whether the bounty is a group or personal bounty.
+
+    The deleted_at field indicates soft-delete: None means not deleted,
+    a value means deleted at that Unix timestamp.
     """
 
     id: int
@@ -17,6 +20,8 @@ class Bounty:
     due_date_ts: int | None
     created_at: int
     created_by_user_id: int
+    deleted_at: int | None = None
+    created_by_username: str | None = None
 
 
 @dataclass
@@ -37,11 +42,20 @@ class RoomData:
 
     The room_id can be negative for Telegram groups or positive for DMs.
     The next_id field is used to generate unique bounty IDs within this room.
+
+    The timezone field stores the room's timezone (e.g., "Asia/Jakarta"), default UTC+0.
+    The admin_user_ids field lists users who have admin privileges in this room.
     """
 
     room_id: int
     bounties: list[Bounty]
     next_id: int
+    timezone: str | None = None
+    admin_user_ids: list[int] | None = None
+
+    def __post_init__(self):
+        if self.admin_user_ids is None:
+            self.admin_user_ids = []
 
 
 @dataclass

core/ports.py

@@ -40,6 +40,25 @@ class RoomStorage(Protocol):
         """Get a specific bounty from a room by ID."""
         ...
 
+    def list_bounties(self, room_id: int) -> list[Bounty]:
+        """List all non-deleted bounties in a room.
+
+        Soft-deleted bounties (where deleted_at is not None) are excluded.
+        """
+        ...
+
+    def list_all_bounties(
+        self, room_id: int, include_deleted: bool = True
+    ) -> list[Bounty]:
+        """List all bounties including or excluding soft-deleted.
+
+        Args:
+            room_id: The room ID
+            include_deleted: If True, return all bounties including soft-deleted.
+                           If False, return only non-deleted bounties.
+        """
+        ...
+
 
 @runtime_checkable
 class TrackingStorage(Protocol):

core/services.py

@@ -15,11 +15,103 @@ class BountyService:
     - Positive room_id: DM/personal context (user's Telegram ID)
 
     This service handles both group and personal bounties through room_id.
+
+    Permissions:
+    - /add, /edit, /delete: admin only
+    - /admin, /admin add, /admin remove: admin only
+    - /bounty, /show, /track, /untrack, /my: everyone
     """
 
     def __init__(self, storage: RoomStorage):
         self._storage = storage
 
+    def is_admin(self, room_id: int, user_id: int) -> bool:
+        """Check if user is admin in a room."""
+        room_data = self._storage.load(room_id)
+        if room_data is None:
+            return False
+        return user_id in (room_data.admin_user_ids or [])
+
+    def add_admin(
+        self, room_id: int, admin_user_id: int, requesting_user_id: int
+    ) -> None:
+        """Add an admin to a room. Requires admin permission."""
+        if not self.is_admin(room_id, requesting_user_id):
+            raise PermissionError("Only admins can add admins.")
+
+        room_data = self._storage.load(room_id)
+        if room_data is None:
+            room_data = RoomData(
+                room_id=room_id, bounties=[], next_id=1, admin_user_ids=[]
+            )
+
+        if admin_user_id not in (room_data.admin_user_ids or []):
+            (room_data.admin_user_ids or []).append(admin_user_id)
+            self._storage.save(room_data)
+
+    def remove_admin(
+        self, room_id: int, admin_user_id: int, requesting_user_id: int
+    ) -> None:
+        """Remove an admin from a room. Requires admin permission."""
+        if not self.is_admin(room_id, requesting_user_id):
+            raise PermissionError("Only admins can remove admins.")
+
+        room_data = self._storage.load(room_id)
+        if room_data is None:
+            return
+
+        if admin_user_id in (room_data.admin_user_ids or []):
+            (room_data.admin_user_ids or []).remove(admin_user_id)
+            self._storage.save(room_data)
+
+    def list_admins(self, room_id: int) -> list[int]:
+        """List all admin user IDs in a room."""
+        room_data = self._storage.load(room_id)
+        if room_data is None:
+            return []
+        return list(room_data.admin_user_ids or [])
+
+    def set_timezone(
+        self, room_id: int, timezone: str, requesting_user_id: int
+    ) -> None:
+        """Set the timezone for a room. Requires admin permission."""
+        if not self.is_admin(room_id, requesting_user_id):
+            raise PermissionError("Only admins can set timezone.")
+
+        room_data = self._storage.load(room_id)
+        if room_data is None:
+            room_data = RoomData(
+                room_id=room_id, bounties=[], next_id=1, admin_user_ids=[]
+            )
+
+        room_data.timezone = timezone
+        self._storage.save(room_data)
+
+    def get_timezone(self, room_id: int) -> str:
+        """Get the timezone for a room. Returns UTC+0 if not set."""
+        room_data = self._storage.load(room_id)
+        if room_data is None:
+            return "UTC+0"
+        return room_data.timezone or "UTC+0"
+
+    def check_link_unique(
+        self, room_id: int, link: str | None, exclude_bounty_id: int | None = None
+    ) -> bool:
+        """Check if a link is unique within a room (not used by another bounty)."""
+        if not link:
+            return True
+
+        room_data = self._storage.load(room_id)
+        if room_data is None:
+            return True
+
+        for bounty in room_data.bounties:
+            if bounty.deleted_at is not None:
+                continue
+            if bounty.link == link and bounty.id != exclude_bounty_id:
+                return False
+        return True
+
     def add_bounty(
         self,
         room_id: int,
@@ -28,7 +120,13 @@ class BountyService:
         link: Optional[str] = None,
         due_date_ts: Optional[int] = None,
     ) -> Bounty:
-        """Add a new bounty to the room."""
+        """Add a new bounty to the room. Requires admin permission."""
+        if not self.is_admin(room_id, user_id):
+            raise PermissionError("Only admins can add bounties.")
+
+        if not self.check_link_unique(room_id, link):
+            raise ValueError("A bounty with this link already exists in this room.")
+
         room_data = self._storage.load(room_id)
         if room_data is None:
             room_data = RoomData(room_id=room_id, bounties=[], next_id=1)
@@ -47,15 +145,20 @@ class BountyService:
         return bounty
 
     def list_bounties(self, room_id: int) -> list[Bounty]:
-        """List all bounties in a room."""
+        """List all non-deleted bounties in a room."""
-        room_data = self._storage.load(room_id)
+        return self._storage.list_bounties(room_id)
-        if room_data is None:
+
-            return []
+    def list_deleted_bounties(self, room_id: int) -> list[Bounty]:
-        return room_data.bounties
+        """List all soft-deleted bounties in a room. For /recover functionality."""
+        all_bounties = self._storage.list_all_bounties(room_id, include_deleted=True)
+        return [b for b in all_bounties if b.deleted_at is not None]
 
     def get_bounty(self, room_id: int, bounty_id: int) -> Bounty | None:
-        """Get a specific bounty by ID."""
+        """Get a specific bounty by ID. Excludes soft-deleted bounties."""
-        return self._storage.get_bounty(room_id, bounty_id)
+        bounty = self._storage.get_bounty(room_id, bounty_id)
+        if bounty and bounty.deleted_at is not None:
+            return None
+        return bounty
 
     def update_bounty(
         self,
@@ -68,12 +171,17 @@ class BountyService:
         clear_link: bool = False,
         clear_due: bool = False,
     ) -> bool:
-        """Update a bounty. Only creator can update."""
+        """Update a bounty. Only admins can update."""
         bounty = self._storage.get_bounty(room_id, bounty_id)
         if not bounty:
             return False
-        if bounty.created_by_user_id != user_id:
+        if not self.is_admin(room_id, user_id):
-            raise PermissionError("Only the creator can edit this bounty.")
+            raise PermissionError("Only admins can edit bounties.")
+
+        if link and not self.check_link_unique(
+            room_id, link, exclude_bounty_id=bounty_id
+        ):
+            raise ValueError("A bounty with this link already exists in this room.")
 
         updated = Bounty(
             id=bounty.id,
@@ -84,21 +192,49 @@ class BountyService:
             if clear_due
             else (due_date_ts if due_date_ts is not None else bounty.due_date_ts),
             created_at=bounty.created_at,
+            deleted_at=bounty.deleted_at,
+            created_by_username=bounty.created_by_username,
         )
         self._storage.update_bounty(room_id, updated)
         return True
 
     def delete_bounty(self, room_id: int, bounty_id: int, user_id: int) -> bool:
-        """Delete a bounty. Only creator can delete."""
+        """Soft delete a bounty. Only admins can delete."""
         bounty = self._storage.get_bounty(room_id, bounty_id)
         if not bounty:
             return False
-        if bounty.created_by_user_id != user_id:
+        if not self.is_admin(room_id, user_id):
-            raise PermissionError("Only the creator can delete this bounty.")
+            raise PermissionError("Only admins can delete bounties.")
 
-        self._storage.delete_bounty(room_id, bounty_id)
+        bounty.deleted_at = int(time.time())
+        self._storage.update_bounty(room_id, bounty)
         return True
 
+    def delete_bounties(
+        self, room_id: int, bounty_ids: list[int], user_id: int
+    ) -> dict[int, str]:
+        """Soft delete multiple bounties. Only admins can delete.
+
+        Returns a dict mapping bounty_id to result:
+        - "deleted": Successfully soft-deleted
+        - "not_found": Bounty does not exist
+        - "permission_denied": User is not admin
+        """
+        results = {}
+        for bounty_id in bounty_ids:
+            bounty = self._storage.get_bounty(room_id, bounty_id)
+            if not bounty:
+                results[bounty_id] = "not_found"
+                continue
+            if not self.is_admin(room_id, user_id):
+                results[bounty_id] = "permission_denied"
+                continue
+
+            bounty.deleted_at = int(time.time())
+            self._storage.update_bounty(room_id, bounty)
+            results[bounty_id] = "deleted"
+        return results
+
 
 class TrackingService:
     """Service for tracking bounty operations."""
@@ -147,7 +283,7 @@ class TrackingService:
         if room_data is None:
             return []
 
-        bounty_map = {b.id: b for b in room_data.bounties}
+        bounty_map = {b.id: b for b in room_data.bounties if b.deleted_at is None}
         return [
             bounty_map[t.bounty_id]
             for t in tracking_data.tracked

tests/test_cli.py

@@ -0,0 +1,376 @@
+"""Tests for cli/main.py — CLI commands with mocked dependencies."""
+
+import pytest
+from unittest.mock import patch, MagicMock
+from io import StringIO
+import sys
+
+from core.models import Bounty
+from core.ports import RoomStorage, TrackingStorage
+
+
+class MockRoomStorage(RoomStorage):
+    """Mock RoomStorage for testing."""
+
+    def __init__(self):
+        self._rooms: dict[int, dict] = {}
+
+    def load(self, room_id: int) -> dict | None:
+        return self._rooms.get(room_id)
+
+    def save(self, room_data: dict) -> None:
+        self._rooms[room_data["room_id"]] = room_data
+
+    def add_bounty(self, room_id: int, bounty: Bounty) -> None:
+        if room_id not in self._rooms:
+            self._rooms[room_id] = {"room_id": room_id, "bounties": [], "next_id": 1}
+        self._rooms[room_id]["bounties"].append(bounty)
+
+    def update_bounty(self, room_id: int, bounty: Bounty) -> None:
+        if room_id in self._rooms:
+            for i, b in enumerate(self._rooms[room_id]["bounties"]):
+                if b.id == bounty.id:
+                    self._rooms[room_id]["bounties"][i] = bounty
+                    break
+
+    def delete_bounty(self, room_id: int, bounty_id: int) -> None:
+        if room_id in self._rooms:
+            self._rooms[room_id]["bounties"] = [
+                b for b in self._rooms[room_id]["bounties"] if b.id != bounty_id
+            ]
+
+    def get_bounty(self, room_id: int, bounty_id: int) -> Bounty | None:
+        if room_id in self._rooms:
+            for b in self._rooms[room_id]["bounties"]:
+                if b.id == bounty_id:
+                    return b
+        return None
+
+
+class MockTrackingStorage(TrackingStorage):
+    """Mock TrackingStorage for testing."""
+
+    def __init__(self):
+        self._tracking: dict[int, dict] = {}
+
+    def load(self, user_id: int) -> dict | None:
+        return self._tracking.get(user_id)
+
+    def save(self, tracking_data: dict) -> None:
+        self._tracking[tracking_data["user_id"]] = tracking_data
+
+    def track_bounty(self, user_id: int, bounty_id: int, room_id: int) -> bool:
+        if user_id not in self._tracking:
+            self._tracking[user_id] = {"user_id": user_id, "bounty_ids": []}
+        if bounty_id not in self._tracking[user_id]["bounty_ids"]:
+            self._tracking[user_id]["bounty_ids"].append(bounty_id)
+            return True
+        return False
+
+    def untrack_bounty(self, user_id: int, bounty_id: int) -> bool:
+        if user_id in self._tracking:
+            if bounty_id in self._tracking[user_id]["bounty_ids"]:
+                self._tracking[user_id]["bounty_ids"].remove(bounty_id)
+                return True
+        return False
+
+    def get_tracked_bounty_ids(self, user_id: int) -> list[int]:
+        if user_id in self._tracking:
+            return self._tracking[user_id]["bounty_ids"]
+        return []
+
+
+@pytest.fixture
+def mock_services():
+    """Create mock services for CLI testing."""
+    room_storage = MockRoomStorage()
+    tracking_storage = MockTrackingStorage()
+    return room_storage, tracking_storage
+
+
+class TestCLIParsing:
+    """Test CLI argument parsing through main()."""
+
+    def test_add_command_requires_text(self):
+        """Test that 'add' command requires text argument."""
+        from cli.main import main
+
+        with patch("sys.argv", ["jigaido-cli", "add", "--group-id=-1001"]):
+            with patch("cli.main.create_services"):
+                with patch("sys.stderr", new=StringIO()) as stderr:
+                    with pytest.raises(SystemExit):
+                        main()
+                    assert "arguments are required: text" in stderr.getvalue()
+
+    def test_list_command(self):
+        """Test 'list' command parsing."""
+        from cli.main import main
+
+        with patch("sys.argv", ["jigaido-cli", "list", "--group-id=-1001"]):
+            with patch("cli.main.create_services") as mock_create:
+                mock_create.return_value = (MagicMock(), MagicMock())
+                mock_bounty_service = MagicMock()
+                mock_bounty_service.list_bounties.return_value = []
+                mock_create.return_value = (mock_bounty_service, MagicMock())
+
+                with patch("sys.stdout", new=StringIO()) as stdout:
+                    main()
+                    assert "No bounties" in stdout.getvalue()
+
+    def test_my_command(self):
+        """Test 'my' command parsing."""
+        from cli.main import main
+
+        with patch(
+            "sys.argv", ["jigaido-cli", "my", "--group-id=-1001", "--user-id=123"]
+        ):
+            with patch("cli.main.create_services") as mock_create:
+                mock_tracking_service = MagicMock()
+                mock_tracking_service.get_tracked_bounties.return_value = []
+                mock_create.return_value = (MagicMock(), mock_tracking_service)
+
+                with patch("sys.stdout", new=StringIO()) as stdout:
+                    main()
+                    assert "Not tracking any bounties" in stdout.getvalue()
+
+    def test_update_command(self):
+        """Test 'update' command parsing."""
+        from cli.main import main
+
+        with patch(
+            "sys.argv", ["jigaido-cli", "update", "1", "--group-id=-1001", "new text"]
+        ):
+            with patch("cli.main.create_services") as mock_create:
+                mock_bounty_service = MagicMock()
+                mock_bounty_service.update_bounty.return_value = True
+                mock_create.return_value = (mock_bounty_service, MagicMock())
+
+                with patch("sys.stdout", new=StringIO()) as stdout:
+                    main()
+                    assert "Updated bounty #1" in stdout.getvalue()
+
+    def test_delete_command(self):
+        """Test 'delete' command parsing."""
+        from cli.main import main
+
+        with patch("sys.argv", ["jigaido-cli", "delete", "1", "--group-id=-1001"]):
+            with patch("cli.main.create_services") as mock_create:
+                mock_bounty_service = MagicMock()
+                mock_bounty_service.delete_bounty.return_value = True
+                mock_create.return_value = (mock_bounty_service, MagicMock())
+
+                with patch("sys.stdout", new=StringIO()) as stdout:
+                    main()
+                    assert "Deleted bounty #1" in stdout.getvalue()
+
+    def test_track_command(self):
+        """Test 'track' command parsing."""
+        from cli.main import main
+
+        with patch(
+            "sys.argv",
+            ["jigaido-cli", "track", "1", "--group-id=-1001", "--user-id=123"],
+        ):
+            with patch("cli.main.create_services") as mock_create:
+                mock_tracking_service = MagicMock()
+                mock_tracking_service.track_bounty.return_value = True
+                mock_create.return_value = (MagicMock(), mock_tracking_service)
+
+                with patch("sys.stdout", new=StringIO()) as stdout:
+                    main()
+                    assert "Tracking bounty #1" in stdout.getvalue()
+
+    def test_untrack_command(self):
+        """Test 'untrack' command parsing."""
+        from cli.main import main
+
+        with patch(
+            "sys.argv",
+            ["jigaido-cli", "untrack", "1", "--group-id=-1001", "--user-id=123"],
+        ):
+            with patch("cli.main.create_services") as mock_create:
+                mock_tracking_service = MagicMock()
+                mock_tracking_service.untrack_bounty.return_value = True
+                mock_create.return_value = (MagicMock(), mock_tracking_service)
+
+                with patch("sys.stdout", new=StringIO()) as stdout:
+                    main()
+                    assert "Untracked bounty #1" in stdout.getvalue()
+
+
+class TestCLIValidation:
+    """Test CLI input validation."""
+
+    def test_requires_group_id_or_user_id(self):
+        """Test that commands require either --group-id or --user-id."""
+        from cli.main import main
+
+        with patch("sys.argv", ["jigaido-cli", "add", "some text"]):
+            with patch("sys.stderr", new=StringIO()) as stderr:
+                with pytest.raises(SystemExit):
+                    main()
+                assert "group-id or --user-id is required" in stderr.getvalue()
+
+    def test_unknown_command(self):
+        """Test handling of unknown commands."""
+        from cli.main import main
+
+        with patch("sys.argv", ["jigaido-cli", "unknown_cmd", "--group-id=-1001"]):
+            with patch("sys.stderr", new=StringIO()) as stderr:
+                with pytest.raises(SystemExit):
+                    main()
+                assert "invalid choice" in stderr.getvalue()
+
+    def test_update_clear_link_flag(self):
+        """Test update with --clear-link flag."""
+        from cli.main import main
+
+        with patch(
+            "sys.argv",
+            ["jigaido-cli", "update", "1", "--clear-link", "--group-id=-1001"],
+        ):
+            with patch("cli.main.create_services") as mock_create:
+                mock_bounty_service = MagicMock()
+                mock_bounty_service.update_bounty.return_value = True
+                mock_create.return_value = (mock_bounty_service, MagicMock())
+
+                main()
+                mock_bounty_service.update_bounty.assert_called_once()
+                call_kwargs = mock_bounty_service.update_bounty.call_args
+                assert call_kwargs.kwargs.get("clear_link") == True
+
+    def test_update_clear_due_flag(self):
+        """Test update with --clear-due flag."""
+        from cli.main import main
+
+        with patch(
+            "sys.argv",
+            ["jigaido-cli", "update", "1", "--clear-due", "--group-id=-1001"],
+        ):
+            with patch("cli.main.create_services") as mock_create:
+                mock_bounty_service = MagicMock()
+                mock_bounty_service.update_bounty.return_value = True
+                mock_create.return_value = (mock_bounty_service, MagicMock())
+
+                main()
+                mock_bounty_service.update_bounty.assert_called_once()
+                call_kwargs = mock_bounty_service.update_bounty.call_args
+                assert call_kwargs.kwargs.get("clear_due") == True
+
+
+class TestCLIOutput:
+    """Test CLI output formatting."""
+
+    def test_list_shows_bounties(self):
+        """Test that 'list' shows bounty details correctly."""
+        from cli.main import main
+
+        mock_bounty = MagicMock()
+        mock_bounty.id = 1
+        mock_bounty.text = "Fix bug"
+        mock_bounty.link = "https://github.com/issue/1"
+        mock_bounty.due_date_ts = None
+
+        with patch("sys.argv", ["jigaido-cli", "list", "--group-id=-1001"]):
+            with patch("cli.main.create_services") as mock_create:
+                mock_bounty_service = MagicMock()
+                mock_bounty_service.list_bounties.return_value = [mock_bounty]
+                mock_create.return_value = (mock_bounty_service, MagicMock())
+
+                with patch("sys.stdout", new=StringIO()) as stdout:
+                    main()
+                    output = stdout.getvalue()
+                    assert "#1:" in output
+                    assert "Fix bug" in output
+                    assert "https://github.com/issue/1" in output
+
+    def test_list_empty(self):
+        """Test that 'list' shows 'No bounties' when empty."""
+        from cli.main import main
+
+        with patch("sys.argv", ["jigaido-cli", "list", "--group-id=-1001"]):
+            with patch("cli.main.create_services") as mock_create:
+                mock_bounty_service = MagicMock()
+                mock_bounty_service.list_bounties.return_value = []
+                mock_create.return_value = (mock_bounty_service, MagicMock())
+
+                with patch("sys.stdout", new=StringIO()) as stdout:
+                    main()
+                    assert "No bounties" in stdout.getvalue()
+
+    def test_add_output(self):
+        """Test that 'add' outputs the new bounty ID."""
+        from cli.main import main
+
+        mock_bounty = MagicMock()
+        mock_bounty.id = 42
+
+        with patch("sys.argv", ["jigaido-cli", "add", "New task", "--group-id=-1001"]):
+            with patch("cli.main.create_services") as mock_create:
+                mock_bounty_service = MagicMock()
+                mock_bounty_service.add_bounty.return_value = mock_bounty
+                mock_create.return_value = (mock_bounty_service, MagicMock())
+
+                with patch("sys.stdout", new=StringIO()) as stdout:
+                    main()
+                    assert "Added bounty #42" in stdout.getvalue()
+
+
+class TestCLIErrorHandling:
+    """Test CLI error handling."""
+
+    def test_delete_nonexistent_bounty(self):
+        """Test deleting a non-existent bounty."""
+        from cli.main import main
+
+        with patch("sys.argv", ["jigaido-cli", "delete", "999", "--group-id=-1001"]):
+            with patch("cli.main.create_services") as mock_create:
+                mock_bounty_service = MagicMock()
+                mock_bounty_service.delete_bounty.return_value = False
+                mock_create.return_value = (mock_bounty_service, MagicMock())
+
+                with patch("sys.stderr", new=StringIO()) as stderr:
+                    with pytest.raises(SystemExit):
+                        main()
+                    assert "not found" in stderr.getvalue()
+
+    def test_update_permission_error(self):
+        """Test update with permission error."""
+        from cli.main import main
+
+        with patch(
+            "sys.argv",
+            ["jigaido-cli", "update", "1", "new text", "--group-id=-1001"],
+        ):
+            with patch("cli.main.create_services") as mock_create:
+                mock_bounty_service = MagicMock()
+                mock_bounty_service.update_bounty.side_effect = PermissionError(
+                    "Not owner"
+                )
+                mock_create.return_value = (mock_bounty_service, MagicMock())
+
+                with patch("sys.stderr", new=StringIO()) as stderr:
+                    with pytest.raises(SystemExit):
+                        main()
+                    assert "Not owner" in stderr.getvalue()
+
+    def test_track_already_tracking(self):
+        """Test tracking a bounty that's already tracked."""
+        from cli.main import main
+
+        with patch(
+            "sys.argv",
+            ["jigaido-cli", "track", "1", "--group-id=-1001", "--user-id=123"],
+        ):
+            with patch("cli.main.create_services") as mock_create:
+                mock_tracking_service = MagicMock()
+                mock_tracking_service.track_bounty.return_value = False
+                mock_create.return_value = (MagicMock(), mock_tracking_service)
+
+                with patch("sys.stdout", new=StringIO()) as stdout:
+                    main()
+                    assert "Already tracking" in stdout.getvalue()
+
+
+if __name__ == "__main__":
+    pytest.main([__file__, "-v"])

tests/test_json_file.py

@@ -0,0 +1,269 @@
+"""Tests for adapters/storage/json_file.py — JSON file storage adapter."""
+
+import json
+import os
+import tempfile
+from pathlib import Path
+
+import pytest
+
+from adapters.storage.json_file import JsonFileRoomStorage, JsonFileTrackingStorage
+from core.models import Bounty, RoomData, TrackingData, TrackedBounty
+
+
+class TestJsonFileRoomStorage:
+    """Unit tests for JsonFileRoomStorage."""
+
+    def setup_method(self):
+        """Set up a temporary directory for each test."""
+        self.temp_dir = tempfile.mkdtemp()
+        self.storage = JsonFileRoomStorage(data_dir=Path(self.temp_dir))
+
+    def teardown_method(self):
+        """Clean up temporary directory after each test."""
+        import shutil
+
+        shutil.rmtree(self.temp_dir, ignore_errors=True)
+
+    def _create_bounty(
+        self,
+        id=1,
+        text="Test bounty",
+        link=None,
+        due_date_ts=None,
+        created_at=0,
+        created_by_user_id=123,
+    ):
+        """Helper to create a Bounty."""
+        return Bounty(
+            id=id,
+            text=text,
+            link=link,
+            due_date_ts=due_date_ts,
+            created_at=created_at,
+            created_by_user_id=created_by_user_id,
+        )
+
+    def test_load_returns_none_for_nonexistent_room(self):
+        """Test that load returns None for a room that doesn't exist."""
+        result = self.storage.load(-1001)
+        assert result is None
+
+    def test_save_and_load_room(self):
+        """Test that save and load work correctly."""
+        room = RoomData(room_id=-1001, bounties=[], next_id=1)
+        self.storage.save(room)
+
+        loaded = self.storage.load(-1001)
+        assert loaded is not None
+        assert loaded.room_id == -1001
+        assert loaded.bounties == []
+        assert loaded.next_id == 1
+
+    def test_add_bounty_creates_room(self):
+        """Test that add_bounty creates a room if it doesn't exist."""
+        bounty = self._create_bounty()
+        self.storage.add_bounty(-1001, bounty)
+
+        loaded = self.storage.load(-1001)
+        assert loaded is not None
+        assert len(loaded.bounties) == 1
+        assert loaded.bounties[0].text == "Test bounty"
+
+    def test_add_bounty_increments_next_id(self):
+        """Test that add_bounty properly handles next_id."""
+        bounty1 = self._create_bounty(id=1)
+        bounty2 = self._create_bounty(id=2)
+
+        self.storage.add_bounty(-1001, bounty1)
+        self.storage.add_bounty(-1001, bounty2)
+
+        loaded = self.storage.load(-1001)
+        assert loaded.next_id == 3  # Should be max id + 1
+
+    def test_update_bounty(self):
+        """Test that update_bounty correctly updates a bounty."""
+        bounty = self._create_bounty(id=1, text="Original")
+        self.storage.add_bounty(-1001, bounty)
+
+        updated = self._create_bounty(id=1, text="Updated")
+        self.storage.update_bounty(-1001, updated)
+
+        loaded = self.storage.load(-1001)
+        assert loaded.bounties[0].text == "Updated"
+
+    def test_update_bounty_nonexistent_room(self):
+        """Test that update_bounty does nothing for nonexistent room."""
+        updated = self._create_bounty(id=1, text="Updated")
+        self.storage.update_bounty(-1001, updated)  # Should not raise
+
+        assert self.storage.load(-1001) is None
+
+    def test_delete_bounty(self):
+        """Test that delete_bounty removes a bounty."""
+        bounty = self._create_bounty(id=1)
+        self.storage.add_bounty(-1001, bounty)
+        self.storage.delete_bounty(-1001, 1)
+
+        loaded = self.storage.load(-1001)
+        assert len(loaded.bounties) == 0
+
+    def test_get_bounty_found(self):
+        """Test that get_bounty returns the bounty when found."""
+        bounty = self._create_bounty(id=1)
+        self.storage.add_bounty(-1001, bounty)
+
+        result = self.storage.get_bounty(-1001, 1)
+        assert result is not None
+        assert result.text == "Test bounty"
+
+    def test_get_bounty_not_found(self):
+        """Test that get_bounty returns None when not found."""
+        result = self.storage.get_bounty(-1001, 999)
+        assert result is None
+
+    def test_file_path_format(self):
+        """Test that room data is stored in correct location."""
+        room = RoomData(room_id=-1001, bounties=[], next_id=1)
+        self.storage.save(room)
+
+        expected_path = Path(self.temp_dir) / "-1001.json"
+        assert expected_path.exists()
+
+    def test_atomic_write(self):
+        """Test that data is written atomically."""
+        room = RoomData(room_id=-1001, bounties=[], next_id=1)
+        self.storage.save(room)
+
+        # Check that the file is valid JSON
+        file_path = Path(self.temp_dir) / "-1001.json"
+        with open(file_path) as f:
+            data = json.load(f)
+        assert data["room_id"] == -1001
+
+
+class TestJsonFileTrackingStorage:
+    """Unit tests for JsonFileTrackingStorage."""
+
+    def setup_method(self):
+        """Set up a temporary directory for each test."""
+        self.temp_dir = tempfile.mkdtemp()
+        self.storage = JsonFileTrackingStorage(tracking_dir=Path(self.temp_dir))
+
+    def teardown_method(self):
+        """Clean up temporary directory after each test."""
+        import shutil
+
+        shutil.rmtree(self.temp_dir, ignore_errors=True)
+
+    def _create_tracked(self, bounty_id=1, created_at=0):
+        """Helper to create a TrackedBounty."""
+        return TrackedBounty(bounty_id=bounty_id, created_at=created_at)
+
+    def test_load_returns_none_for_nonexistent_tracking(self):
+        """Test that load returns None when no tracking exists."""
+        result = self.storage.load(-1001, 123456)
+        assert result is None
+
+    def test_save_and_load_tracking(self):
+        """Test that save and load work correctly."""
+        tracking = TrackingData(room_id=-1001, user_id=123456, tracked=[])
+        self.storage.save(tracking)
+
+        loaded = self.storage.load(-1001, 123456)
+        assert loaded is not None
+        assert loaded.room_id == -1001
+        assert loaded.user_id == 123456
+
+    def test_track_bounty(self):
+        """Test that track_bounty adds a bounty to tracking."""
+        tracked = self._create_tracked(bounty_id=5)
+        self.storage.track_bounty(-1001, 123456, tracked)
+
+        loaded = self.storage.load(-1001, 123456)
+        assert loaded is not None
+        assert len(loaded.tracked) == 1
+        assert loaded.tracked[0].bounty_id == 5
+
+    def test_untrack_bounty(self):
+        """Test that untrack_bounty removes a bounty from tracking."""
+        tracked = self._create_tracked(bounty_id=5)
+        self.storage.track_bounty(-1001, 123456, tracked)
+        self.storage.untrack_bounty(-1001, 123456, 5)
+
+        loaded = self.storage.load(-1001, 123456)
+        assert loaded is not None
+        assert len(loaded.tracked) == 0
+
+    def test_untrack_bounty_nonexistent(self):
+        """Test that untrack_bounty handles nonexistent tracking gracefully."""
+        self.storage.untrack_bounty(-1001, 123456, 999)  # Should not raise
+
+    def test_file_path_format(self):
+        """Test that tracking data is stored in correct location."""
+        tracked = self._create_tracked(bounty_id=5)
+        self.storage.track_bounty(-1001, 123456, tracked)
+
+        expected_path = Path(self.temp_dir) / "-1001_123456.json"
+        assert expected_path.exists()
+
+    def test_multiple_tracked_bounties(self):
+        """Test tracking multiple bounties."""
+        self.storage.track_bounty(-1001, 123456, self._create_tracked(bounty_id=1))
+        self.storage.track_bounty(-1001, 123456, self._create_tracked(bounty_id=2))
+        self.storage.track_bounty(-1001, 123456, self._create_tracked(bounty_id=3))
+
+        loaded = self.storage.load(-1001, 123456)
+        assert len(loaded.tracked) == 3
+
+    def test_different_users_independent_tracking(self):
+        """Test that different users have independent tracking."""
+        self.storage.track_bounty(-1001, 111, self._create_tracked(bounty_id=1))
+        self.storage.track_bounty(-1001, 222, self._create_tracked(bounty_id=1))
+
+        loaded_111 = self.storage.load(-1001, 111)
+        loaded_222 = self.storage.load(-1001, 222)
+
+        assert len(loaded_111.tracked) == 1
+        assert len(loaded_222.tracked) == 1
+
+
+class TestDuplicateTrackingBehavior:
+    """Test that duplicate tracking is handled correctly.
+
+    Note: The deduplication logic is in the TrackingService layer,
+    not in the adapter. This test verifies the adapter behavior
+    when the same bounty is tracked multiple times (which would only
+    happen if the service layer has a bug).
+    """
+
+    def setup_method(self):
+        """Set up a temporary directory for each test."""
+        self.temp_dir = tempfile.mkdtemp()
+        self.storage = JsonFileTrackingStorage(tracking_dir=Path(self.temp_dir))
+
+    def teardown_method(self):
+        """Clean up temporary directory after each test."""
+        import shutil
+
+        shutil.rmtree(self.temp_dir, ignore_errors=True)
+
+    def test_adapter_allows_duplicate_tracking(self):
+        """The adapter does NOT prevent duplicate tracking.
+
+        This is by design - deduplication should be handled by
+        TrackingService.track_bounty(), not the storage adapter.
+        """
+        # Add same bounty twice via adapter (bypassing service)
+        self.storage.track_bounty(
+            -1001, 123456, TrackedBounty(bounty_id=5, created_at=0)
+        )
+        self.storage.track_bounty(
+            -1001, 123456, TrackedBounty(bounty_id=5, created_at=0)
+        )
+
+        loaded = self.storage.load(-1001, 123456)
+        # Adapter allows duplicates - service should prevent them
+        assert len(loaded.tracked) == 2
+        assert loaded.tracked[0].bounty_id == 5
+        assert loaded.tracked[1].bounty_id == 5

tests/test_models.py

@@ -28,6 +28,22 @@ class TestBounty:
         assert b.due_date_ts == 1735689600
         assert b.created_at == 1735603200
         assert b.created_by_user_id == 123
+        assert b.deleted_at is None
+        assert b.created_by_username is None
+
+    def test_bounty_with_new_fields(self):
+        b = Bounty(
+            id=1,
+            text="Fix the bug",
+            link="https://github.com/example/repo/issues/1",
+            due_date_ts=1735689600,
+            created_at=1735603200,
+            created_by_user_id=123,
+            deleted_at=1736200000,
+            created_by_username="johndoe",
+        )
+        assert b.deleted_at == 1736200000
+        assert b.created_by_username == "johndoe"
 
     def test_bounty_optional_fields_can_be_none(self):
         b = Bounty(
@@ -41,6 +57,8 @@ class TestBounty:
         assert b.text is None
         assert b.link is None
         assert b.due_date_ts is None
+        assert b.deleted_at is None
+        assert b.created_by_username is None
 
     def test_bounty_comparison_equal(self):
         b1 = Bounty(
@@ -103,6 +121,8 @@ class TestRoomData:
         assert rd.room_id == -1001
         assert rd.bounties == []
         assert rd.next_id == 1
+        assert rd.timezone is None
+        assert rd.admin_user_ids == []
 
     def test_create_dm_room_data(self):
         rd = RoomData(
@@ -113,6 +133,8 @@ class TestRoomData:
         assert rd.room_id == 123456
         assert rd.bounties == []
         assert rd.next_id == 1
+        assert rd.timezone is None
+        assert rd.admin_user_ids == []
 
     def test_room_data_with_bounties(self):
         b = Bounty(
@@ -128,6 +150,25 @@ class TestRoomData:
         assert rd.bounties[0].text == "Task"
         assert rd.bounties[0].created_by_user_id == 123
 
+    def test_room_data_with_new_fields(self):
+        rd = RoomData(
+            room_id=-1001,
+            bounties=[],
+            next_id=1,
+            timezone="Asia/Jakarta",
+            admin_user_ids=[123, 456],
+        )
+        assert rd.timezone == "Asia/Jakarta"
+        assert rd.admin_user_ids == [123, 456]
+
+    def test_room_data_admin_user_ids_defaults_to_empty_list(self):
+        rd = RoomData(
+            room_id=-1001,
+            bounties=[],
+            next_id=1,
+        )
+        assert rd.admin_user_ids == []
+
 
 class TestTrackingData:
     def test_create_tracking_data(self):

tests/test_ports.py

@@ -48,6 +48,20 @@ class SimpleRoomStorage:
                     return b
         return None
 
+    def list_bounties(self, room_id: int) -> list[Bounty]:
+        if room_id not in self._rooms:
+            return []
+        return [b for b in self._rooms[room_id].bounties if b.deleted_at is None]
+
+    def list_all_bounties(
+        self, room_id: int, include_deleted: bool = True
+    ) -> list[Bounty]:
+        if room_id not in self._rooms:
+            return []
+        if include_deleted:
+            return self._rooms[room_id].bounties
+        return [b for b in self._rooms[room_id].bounties if b.deleted_at is None]
+
 
 class SimpleTrackingStorage:
     """Minimal mock without ensure_tracking - tests if track_bounty works without it.
@@ -119,6 +133,20 @@ class MockRoomStorage:
                     return b
         return None
 
+    def list_bounties(self, room_id: int) -> list[Bounty]:
+        if room_id not in self._rooms:
+            return []
+        return [b for b in self._rooms[room_id].bounties if b.deleted_at is None]
+
+    def list_all_bounties(
+        self, room_id: int, include_deleted: bool = True
+    ) -> list[Bounty]:
+        if room_id not in self._rooms:
+            return []
+        if include_deleted:
+            return self._rooms[room_id].bounties
+        return [b for b in self._rooms[room_id].bounties if b.deleted_at is None]
+
 
 class MockTrackingStorage:
     """Mock implementation of TrackingStorage for testing."""

tests/test_services.py

@@ -15,18 +15,32 @@ class TestBountyService:
         """Set up fresh storage and service for each test."""
         self.storage = MockRoomStorage()
         self.service = BountyService(self.storage)
+        self.admin_user_id = 123
+        self._make_admin(-1001, self.admin_user_id)
+
+    def _make_admin(self, room_id: int, user_id: int):
+        """Helper to set up a room with an admin user."""
+        room_data = self.storage.load(room_id)
+        if room_data is None:
+            room_data = RoomData(
+                room_id=room_id, bounties=[], next_id=0, admin_user_ids=[]
+            )
+        if user_id not in (room_data.admin_user_ids or []):
+            room_data.admin_user_ids = room_data.admin_user_ids or []
+            room_data.admin_user_ids.append(user_id)
+        self.storage.save(room_data)
 
     def test_add_bounty_creates_room_if_not_exists(self):
         """Test that add_bounty creates a new room if it doesn't exist."""
         bounty = self.service.add_bounty(
             room_id=-1001,
-            user_id=123,
+            user_id=self.admin_user_id,
             text="Fix bug",
             link="https://github.com/issue/1",
         )
         assert bounty.id == 1
         assert bounty.text == "Fix bug"
-        assert bounty.created_by_user_id == 123
+        assert bounty.created_by_user_id == self.admin_user_id
 
         room = self.storage.load(-1001)
         assert room is not None
@@ -34,14 +48,25 @@ class TestBountyService:
 
     def test_add_bounty_increments_id(self):
         """Test that add_bounty increments bounty ID for each new bounty."""
-        b1 = self.service.add_bounty(room_id=-1001, user_id=123, text="First")
+        b1 = self.service.add_bounty(
-        b2 = self.service.add_bounty(room_id=-1001, user_id=123, text="Second")
+            room_id=-1001, user_id=self.admin_user_id, text="First"
-        b3 = self.service.add_bounty(room_id=-1001, user_id=123, text="Third")
+        )
+        b2 = self.service.add_bounty(
+            room_id=-1001, user_id=self.admin_user_id, text="Second"
+        )
+        b3 = self.service.add_bounty(
+            room_id=-1001, user_id=self.admin_user_id, text="Third"
+        )
 
         assert b1.id == 1
         assert b2.id == 2
         assert b3.id == 3
 
+    def test_add_bounty_requires_admin(self):
+        """Test that add_bounty raises PermissionError when non-admin tries to add."""
+        with pytest.raises(PermissionError, match="Only admins can add bounties"):
+            self.service.add_bounty(room_id=-1001, user_id=999, text="Not admin")
+
     def test_list_bounties_empty_room(self):
         """Test list_bounties returns empty list for non-existent room."""
         bounties = self.service.list_bounties(-1001)
@@ -49,9 +74,15 @@ class TestBountyService:
 
     def test_list_bounties_returns_all_bounties(self):
         """Test list_bounties returns all bounties in a room."""
-        self.service.add_bounty(room_id=-1001, user_id=123, text="First")
+        self.service.add_bounty(room_id=-1001, user_id=self.admin_user_id, text="First")
-        self.service.add_bounty(room_id=-1001, user_id=123, text="Second")
+        self.service.add_bounty(
-        self.service.add_bounty(room_id=-999, user_id=123, text="Other room")
+            room_id=-1001, user_id=self.admin_user_id, text="Second"
+        )
+        # Add bounty to different room to verify isolation
+        self._make_admin(-999, self.admin_user_id)
+        self.service.add_bounty(
+            room_id=-999, user_id=self.admin_user_id, text="Other room"
+        )
 
         bounties = self.service.list_bounties(-1001)
         assert len(bounties) == 2
@@ -59,7 +90,9 @@ class TestBountyService:
 
     def test_get_bounty_found(self):
         """Test get_bounty returns bounty when it exists."""
-        created = self.service.add_bounty(room_id=-1001, user_id=123, text="Test")
+        created = self.service.add_bounty(
+            room_id=-1001, user_id=self.admin_user_id, text="Test"
+        )
         found = self.service.get_bounty(-1001, created.id)
         assert found is not None
         assert found.text == "Test"
@@ -71,31 +104,35 @@ class TestBountyService:
 
     def test_get_bounty_wrong_room(self):
         """Test get_bounty returns None when bounty is in different room."""
-        self.service.add_bounty(room_id=-1001, user_id=123, text="Test")
+        self.service.add_bounty(room_id=-1001, user_id=self.admin_user_id, text="Test")
         found = self.service.get_bounty(-999, 1)  # room -999 doesn't have bounty 1
         assert found is None
 
     def test_update_bounty_success(self):
-        """Test update_bounty succeeds when creator updates their bounty."""
+        """Test update_bounty succeeds when admin updates their bounty."""
-        bounty = self.service.add_bounty(room_id=-1001, user_id=123, text="Original")
+        bounty = self.service.add_bounty(
+            room_id=-1001, user_id=self.admin_user_id, text="Original"
+        )
         result = self.service.update_bounty(
             room_id=-1001,
             bounty_id=bounty.id,
-            user_id=123,
+            user_id=self.admin_user_id,
             text="Updated",
         )
         assert result is True
         updated = self.service.get_bounty(-1001, bounty.id)
         assert updated.text == "Updated"
 
-    def test_update_bounty_not_creator_raises_permission_error(self):
+    def test_update_bounty_not_admin_raises_permission_error(self):
-        """Test update_bounty raises PermissionError when non-creator tries to update."""
+        """Test update_bounty raises PermissionError when non-admin tries to update."""
-        bounty = self.service.add_bounty(room_id=-1001, user_id=123, text="Original")
+        bounty = self.service.add_bounty(
-        with pytest.raises(PermissionError, match="Only the creator can edit"):
+            room_id=-1001, user_id=self.admin_user_id, text="Original"
+        )
+        with pytest.raises(PermissionError, match="Only admins can edit bounties"):
             self.service.update_bounty(
                 room_id=-1001,
                 bounty_id=bounty.id,
-                user_id=999,  # different user
+                user_id=999,  # different user, not admin
                 text="Hacked",
             )
 
@@ -104,7 +141,7 @@ class TestBountyService:
         result = self.service.update_bounty(
             room_id=-1001,
             bounty_id=999,
-            user_id=123,
+            user_id=self.admin_user_id,
             text="Updated",
         )
         assert result is False
@@ -113,14 +150,14 @@ class TestBountyService:
         """Test update_bounty only updates provided fields."""
         bounty = self.service.add_bounty(
             room_id=-1001,
-            user_id=123,
+            user_id=self.admin_user_id,
             text="Original",
             link="https://original.link",
         )
         self.service.update_bounty(
             room_id=-1001,
             bounty_id=bounty.id,
-            user_id=123,
+            user_id=self.admin_user_id,
             text="Updated only text",
         )
         updated = self.service.get_bounty(-1001, bounty.id)
@@ -131,37 +168,95 @@ class TestBountyService:
         """Test update_bounty can clear link."""
         bounty = self.service.add_bounty(
             room_id=-1001,
-            user_id=123,
+            user_id=self.admin_user_id,
             text="Test",
             link="https://original.link",
         )
         self.service.update_bounty(
             room_id=-1001,
             bounty_id=bounty.id,
-            user_id=123,
+            user_id=self.admin_user_id,
             clear_link=True,
         )
         updated = self.service.get_bounty(-1001, bounty.id)
         assert updated.link is None
 
     def test_delete_bounty_success(self):
-        """Test delete_bounty succeeds when creator deletes their bounty."""
+        """Test delete_bounty soft deletes when admin deletes their bounty."""
-        bounty = self.service.add_bounty(room_id=-1001, user_id=123, text="To delete")
+        bounty = self.service.add_bounty(
-        result = self.service.delete_bounty(-1001, bounty.id, 123)
+            room_id=-1001, user_id=self.admin_user_id, text="To delete"
+        )
+        result = self.service.delete_bounty(-1001, bounty.id, self.admin_user_id)
         assert result is True
+        # Soft delete - bounty should not be found via get_bounty
         assert self.service.get_bounty(-1001, bounty.id) is None
+        # But still exists in list_deleted_bounties
+        deleted = self.service.list_deleted_bounties(-1001)
+        assert len(deleted) == 1
+        assert deleted[0].id == bounty.id
 
-    def test_delete_bounty_not_creator_raises_permission_error(self):
+    def test_delete_bounty_not_admin_raises_permission_error(self):
-        """Test delete_bounty raises PermissionError when non-creator tries to delete."""
+        """Test delete_bounty raises PermissionError when non-admin tries to delete."""
-        bounty = self.service.add_bounty(room_id=-1001, user_id=123, text="To delete")
+        bounty = self.service.add_bounty(
-        with pytest.raises(PermissionError, match="Only the creator can delete"):
+            room_id=-1001, user_id=self.admin_user_id, text="To delete"
-            self.service.delete_bounty(-1001, bounty.id, 999)  # different user
+        )
+        with pytest.raises(PermissionError, match="Only admins can delete bounties"):
+            self.service.delete_bounty(
+                -1001, bounty.id, 999
+            )  # different user, not admin
 
     def test_delete_bounty_not_found(self):
         """Test delete_bounty returns False when bounty doesn't exist."""
-        result = self.service.delete_bounty(-1001, 999, 123)
+        result = self.service.delete_bounty(-1001, 999, self.admin_user_id)
         assert result is False
 
+    def test_delete_bounties_multiple_success(self):
+        """Test delete_bounties soft deletes multiple bounties."""
+        b1 = self.service.add_bounty(
+            room_id=-1001, user_id=self.admin_user_id, text="First"
+        )
+        b2 = self.service.add_bounty(
+            room_id=-1001, user_id=self.admin_user_id, text="Second"
+        )
+        b3 = self.service.add_bounty(
+            room_id=-1001, user_id=self.admin_user_id, text="Third"
+        )
+        results = self.service.delete_bounties(
+            -1001, [b1.id, b2.id, b3.id], self.admin_user_id
+        )
+        assert results == {b1.id: "deleted", b2.id: "deleted", b3.id: "deleted"}
+        assert self.service.get_bounty(-1001, b1.id) is None
+        assert self.service.get_bounty(-1001, b2.id) is None
+        assert self.service.get_bounty(-1001, b3.id) is None
+
+    def test_delete_bounties_mixed_results(self):
+        """Test delete_bounties returns individual results per ID."""
+        b1 = self.service.add_bounty(
+            room_id=-1001, user_id=self.admin_user_id, text="Exists"
+        )
+        results = self.service.delete_bounties(
+            -1001, [b1.id, 999, 888], self.admin_user_id
+        )
+        assert results == {b1.id: "deleted", 999: "not_found", 888: "not_found"}
+
+    def test_delete_bounties_permission_denied(self):
+        """Test delete_bounties returns permission_denied for non-admin."""
+        b1 = self.service.add_bounty(
+            room_id=-1001, user_id=self.admin_user_id, text="First"
+        )
+        b2 = self.service.add_bounty(
+            room_id=-1001, user_id=self.admin_user_id, text="Second"
+        )
+        results = self.service.delete_bounties(
+            -1001,
+            [b1.id, b2.id],
+            999,  # non-admin user
+        )
+        assert results == {b1.id: "permission_denied", b2.id: "permission_denied"}
+        # Bounties should not be deleted
+        assert self.service.get_bounty(-1001, b1.id) is not None
+        assert self.service.get_bounty(-1001, b2.id) is not None
+
 
 class TestTrackingService:
     """Unit tests for TrackingService."""
@@ -171,9 +266,27 @@ class TestTrackingService:
         self.room_storage = MockRoomStorage()
         self.tracking_storage = MockTrackingStorage()
         self.service = TrackingService(self.tracking_storage, self.room_storage)
+        self.admin_user_id = 123
+        self._make_admin(-1001, self.admin_user_id)
+
+    def _make_admin(self, room_id: int, user_id: int):
+        """Helper to set up a room with an admin user."""
+        room_data = self.room_storage.load(room_id)
+        if room_data is None:
+            room_data = RoomData(
+                room_id=room_id, bounties=[], next_id=0, admin_user_ids=[]
+            )
+        if user_id not in (room_data.admin_user_ids or []):
+            room_data.admin_user_ids = room_data.admin_user_ids or []
+            room_data.admin_user_ids.append(user_id)
+        self.room_storage.save(room_data)
 
     def _add_bounty(self, room_id=-1001, user_id=123, text="Test bounty"):
         """Helper to add a bounty for tracking tests."""
+        if self.room_storage.load(room_id) is None or user_id not in (
+            self.room_storage.load(room_id).admin_user_ids or []
+        ):
+            self._make_admin(room_id, user_id)
         bounty_service = BountyService(self.room_storage)
         return bounty_service.add_bounty(room_id=room_id, user_id=user_id, text=text)