feat(/bounty): add pagination, sorting, and filtering

- Default shows 5 bounties per page
- /bounty 10 - show 10 bounties
- /bounty all - show all active (exclude overdue >24h)
- /bounty all 10 - show 10 including expired

Filtering:
- Overdue >24h filtered out by default
- 'all' flag includes overdue

Sorting:
- Bounties with due date sorted by due_date_ts (earliest first)
- Bounties without due date shown last, sorted by created_at

Output format updated:
- Header shows 'Showing X of Y bounties'
- Description sliced to 40 chars when showing pagination info
- Date format changed to '4 Apr 2026' style

Fixes #48

apps/telegram-bot/bot.py

@@ -14,7 +14,6 @@ from commands import (
     cmd_help,
     cmd_my,
     cmd_start,
-    cmd_timezone,
     cmd_track,
     cmd_untrack,
     cmd_update,
@@ -42,7 +41,6 @@ def build_app() -> Application:
     app.add_handler(CommandHandler("delete", cmd_delete))
     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, cmd_help))
 
@@ -58,7 +56,6 @@ async def post_init(app: Application) -> None:
             ("edit", "Edit a bounty"),
             ("track", "Track a bounty"),
             ("untrack", "Stop tracking"),
-            ("timezone", "Get/set room timezone"),
             ("help", "Show help"),
         ]
     )

apps/telegram-bot/commands.py

@@ -3,7 +3,6 @@
 import time
 from functools import wraps
 from typing import Optional
-from zoneinfo import ZoneInfo, ZoneInfoNotFoundError
 
 import dateparser
 from telegram import Update
@@ -49,21 +48,24 @@ def parse_args(args: list[str]) -> tuple[Optional[str], Optional[str], Optional[
     return text, link, due_date_ts
 
 
-def format_bounty(b, show_id: bool = True) -> str:
+def format_bounty(b, show_id: bool = True, slice_length: int = 0) -> str:
     parts = []
     if show_id:
         parts.append(f"[#{b.id}]")
     if b.text:
-        parts.append(b.text)
+        text = b.text
+        if slice_length > 0 and len(text) > slice_length:
+            text = text[:slice_length] + "..."
+        parts.append(text)
     if b.link:
         parts.append(f"🔗 {b.link}")
     if b.due_date_ts:
-        due_str = time.strftime("%Y-%m-%d", time.localtime(b.due_date_ts))
+        due_str = time.strftime("%d %b %Y", time.localtime(b.due_date_ts))
         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)")
+            parts.append(f"⏰ Today (OVERDUE)")
         else:
             parts.append(f"⏰ {due_str} ({days_left}d)")
     if b.created_by_user_id:
@@ -96,13 +98,58 @@ def get_room_id(update: Update) -> int:
 
 async def cmd_bounty(update: Update, ctx: ContextTypes.DEFAULT_TYPE) -> None:
     room_id = get_room_id(update)
-    bounties = BOUNTY_SERVICE.list_bounties(room_id)
+    args = extract_args(update.message.text)
 
-    if not bounties:
+    show_all = "all" in args
+    args = [a for a in args if a != "all"]
+
+    try:
+        limit = int(args[0]) if args else 5
+    except (ValueError, IndexError):
+        limit = 5
+
+    now = int(time.time())
+    cutoff_24h = now - 86400
+
+    all_bounties = BOUNTY_SERVICE.list_bounties(room_id)
+
+    def is_expired(b) -> bool:
+        return b.due_date_ts is not None and b.due_date_ts < cutoff_24h
+
+    def sort_key(b):
+        if b.due_date_ts is not None:
+            return (0, b.due_date_ts)
+        return (1, b.created_at)
+
+    filtered_bounties = [b for b in all_bounties if not is_expired(b) or show_all]
+    filtered_bounties.sort(key=sort_key)
+
+    total_count = len(filtered_bounties)
+    displayed_bounties = filtered_bounties[:limit]
+
+    if not displayed_bounties:
+        if show_all:
             await update.message.reply_text("No bounties yet.")
+        else:
+            await update.message.reply_text(
+                "No active bounties. Use /bounty all to show expired."
+            )
         return
 
-    lines = [format_bounty(b, show_id=True) for b in bounties]
+    lines = []
+    if limit < total_count:
+        lines.append(f"Showing {limit} of {total_count} bounties:")
+        slice_length = 40
+    elif show_all and total_count > limit:
+        lines.append(f"Showing {limit} of {total_count} bounties (including expired):")
+        slice_length = 40
+    else:
+        lines.append(f"Showing {total_count} bounties:")
+        slice_length = 0
+
+    for b in displayed_bounties:
+        lines.append(format_bounty(b, show_id=True, slice_length=slice_length))
+
     await update.message.reply_text("\n".join(lines), disable_web_page_preview=True)
 
 
@@ -211,34 +258,32 @@ 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> [bounty_id ...]")
+        await update.message.reply_text("Usage: /delete <bounty_id>")
         return
 
     try:
-        bounty_ids = [int(arg) for arg in args]
+        bounty_id = int(args[0])
     except ValueError:
-        await update.message.reply_text("Invalid bounty ID(s).")
+        await update.message.reply_text("Invalid bounty ID.")
         return
 
     user_id = get_user_id(update)
     room_id = get_room_id(update)
 
-    results = BOUNTY_SERVICE.delete_bounties(
+    try:
+        success = BOUNTY_SERVICE.delete_bounty(
             room_id=room_id,
-        bounty_ids=bounty_ids,
+            bounty_id=bounty_id,
             user_id=user_id,
         )
+    except PermissionError as e:
+        await update.message.reply_text(f"⛔ {e}")
+        return
 
-    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))
+    if success:
+        await update.message.reply_text(f"✅ Bounty #{bounty_id} deleted.")
+    else:
+        await update.message.reply_text("Bounty not found.")
 
 
 async def cmd_track(update: Update, ctx: ContextTypes.DEFAULT_TYPE) -> None:
@@ -324,37 +369,7 @@ async def cmd_help(update: Update, ctx: ContextTypes.DEFAULT_TYPE) -> None:
         "/delete <id> — delete bounty\n"
         "/track <id> — track a bounty (groups only)\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}.")

core/services.py

@@ -210,31 +210,6 @@ class BountyService:
         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."""

tests/test_services.py

@@ -210,53 +210,6 @@ class TestBountyService:
         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."""