fix: make creating and viewing activities work like a conversation

Reported: scheduling only happened when the user typed "masukkan ke kegiatan",
the double-confirmation felt awkward, the agenda could not be checked, and old
activity titles leaked into brand new ones.

Routing
- "ingetin aku", "jangan lupa aku", "pengingat" and stated plans ("aku ada X
besok jam 10", "aku mau X jam 2 sore") now always produce ADD_ACTIVITY, even
with no details yet, instead of falling through to CHAT. The model previously
replied "siap, nanti aku ingetin" and saved nothing, which is worse than not
replying at all.
- Word order no longer matters ("jam 2 sore ... aku mau ngechat pacar" and
"aku mau ngechat pacar ... jam 2 sore" both work).
- Agenda/view phrasings broadened.

Draft filling
- Dates and times are now parsed locally as well as by the model. The model
answered CHAT for a plain "Hari Minggu, 11 Oktober 2026" while a draft was
open, which stranded the user mid-flow; a bare instruction followed by a date
and a time now completes correctly.
- Asking for a missing slot now echoes what is already captured instead of
repeating "boleh, aku catatin~" on every turn.
- Extractor handles "pukul 5 sore", "11/10", weekday names, and relative days,
and never resolves a named weekday to a past date.

Titles can no longer be inherited
- The router prompt forbids copying a title from the stored activity list,
which is what made a new event appear as "Tugas Internship".

Flow
- Adding an activity now saves immediately with done/delete buttons, the same
as logging food: asking "are you sure?" before saving something the user just
said, then asking again on the result, is what made it feel like double work.
Deletions and corrections still confirm, because those are destructive.
- reply_fn was accepted but never invoked, so an activity could be saved with
no reply sent at all.
- The agenda listing now carries per-activity selesai/hapus buttons, with a
"batalkan selesai" toggle once one is marked.

54 tests pass (up from 40); 14 fresh router cases and 14 extractor cases.

bot/handlers/message_handler.py

@@ -14,9 +14,12 @@ TTL, so a stale inline button can never re-trigger an old action and a container
 restart simply invalidates whatever was pending.
 """
 
+import inspect
 import logging
+import re
 import secrets
 import time
+from datetime import date, timedelta
 
 from telegram import InlineKeyboardButton, InlineKeyboardMarkup, Update
 from telegram.ext import ContextTypes, MessageHandler, filters
@@ -30,6 +33,7 @@ from services.activity_service import (
     get_today_activities,
     get_upcoming_activities,
     mark_activity_done,
+    unmark_activity_done,
     update_activity,
 )
 from services.intent_service import (
@@ -147,22 +151,26 @@ async def handle_message(update: Update, context: ContextTypes.DEFAULT_TYPE) ->
 
     # A pending activity draft absorbs follow-up slot-filling messages.
     if draft:
-        if intent.action == ACTION_ADD_ACTIVITY or _looks_like_slot_answer(text):
-            merged = _merge_draft(draft, intent)
-            if _draft_complete(merged):
-                context.user_data.pop(KEY_DRAFT, None)
-                await _stage_confirmation(
-                    update, context, user_id,
-                    Intent(action=ACTION_ADD_ACTIVITY, slots=merged["slots"], missing=[]),
-                    text,
-                )
-            else:
-                context.user_data[KEY_DRAFT] = merged
-                await _ask_for_missing(update, merged)
+        merged = _merge_draft(draft, intent)
+
+        # Deterministic safety net: the model sometimes answers CHAT for a plain
+        # "Hari Minggu, 11 Oktober 2026" while a draft is open, which used to
+        # strand the user mid-flow. Extract dates/times locally so slot filling
+        # never depends on the model remembering the draft.
+        merged = _fill_slots_locally(merged, text)
+
+        if _draft_complete(merged):
+            context.user_data.pop(KEY_DRAFT, None)
+            await _finish_activity_draft(update, context, user_id, merged, text)
             return
 
-        # Different topic: drop the stale draft and continue with the new intent.
-        context.user_data.pop(KEY_DRAFT, None)
+        # The user switched to an unrelated topic: drop the draft.
+        if intent.action not in (ACTION_ADD_ACTIVITY,) and not _looks_like_slot_answer(text):
+            context.user_data.pop(KEY_DRAFT, None)
+        else:
+            context.user_data[KEY_DRAFT] = merged
+            await _ask_for_missing(update, merged)
+            return
 
     if intent.action == ACTION_LOG_FOOD:
         await _execute_log_food(update, context, user_id, text, intent, ai_service)
@@ -177,7 +185,24 @@ async def handle_message(update: Update, context: ContextTypes.DEFAULT_TYPE) ->
         await _handle_chat(update, context, user_id, text, ai_service)
         return
 
-    # Everything below changes data and must be confirmed first.
+    # ── Actions that write data ──────────────────────────────────────────────
+    #
+    # Adding an activity behaves like logging food: it happens straight away.
+    # Asking "are you sure?" before saving something the user just said out
+    # loud, then asking again on the result, is what made this feel like double
+    # work. Deletion and corrections stay behind a confirmation because those
+    # are destructive and easy to trigger by accident.
+    if intent.action == ACTION_ADD_ACTIVITY and intent.is_complete:
+        await _apply_confirmed_action(
+            user_id,
+            intent,
+            reply_fn=lambda message, keyboard: update.message.reply_text(
+                message, parse_mode="Markdown", reply_markup=keyboard
+            ),
+        )
+        await _remember(user_id, text, "kegiatan disimpan")
+        return
+
     if not intent.is_complete:
         context.user_data[KEY_DRAFT] = {
             "action": intent.action,
@@ -264,25 +289,51 @@ async def _show_agenda(update, user_id: int) -> None:
         return
 
     lines = ["📅 *agenda kamu*\n"]
+    buttons: list[list[InlineKeyboardButton]] = []
+
+    def _entry(act: dict) -> str:
+        marker = "✅" if act.get("done") else "📌"
+        return (
+            f"{marker} *{_md(act.get('title'))}*\n   🕒 "
+            f"{format_activity_datetime(act.get('activity_dt'))}"
+        )
+
     if today:
         lines.append("✨ *hari ini:*")
         for act in today:
-            marker = "✅" if act.get("done") else "📌"
-            lines.append(
-                f"{marker} *{_md(act.get('title'))}*\n   🕒 "
-                f"{format_activity_datetime(act.get('activity_dt'))}"
-            )
+            lines.append(_entry(act))
+            buttons.append(_activity_buttons(act))
 
     if future:
         lines.append("\n🗓️ *7 hari ke depan:*")
         for act in future:
-            marker = "✅" if act.get("done") else "📌"
-            lines.append(
-                f"{marker} *{_md(act.get('title'))}*\n   🕒 "
-                f"{format_activity_datetime(act.get('activity_dt'))}"
-            )
+            lines.append(_entry(act))
+            buttons.append(_activity_buttons(act))
 
-    await update.message.reply_text("\n".join(lines), parse_mode="Markdown")
+    lines.append(
+        "\n💡 _ketuk tombol di bawah buat tandai selesai atau hapus_"
+    )
+
+    await update.message.reply_text(
+        "\n".join(lines),
+        parse_mode="Markdown",
+        reply_markup=InlineKeyboardMarkup(buttons) if buttons else None,
+    )
+
+
+def _activity_buttons(act: dict) -> list[InlineKeyboardButton]:
+    """Per-activity actions shown under the agenda listing."""
+    activity_id = act["id"]
+    if act.get("done"):
+        return [
+            InlineKeyboardButton(
+                "↩️ batalkan selesai", callback_data=f"undone:{activity_id}"
+            )
+        ]
+    return [
+        InlineKeyboardButton("✅ selesai", callback_data=f"done:{activity_id}"),
+        InlineKeyboardButton("🗑️ hapus", callback_data=f"del_activity:{activity_id}"),
+    ]
 
 
 async def _build_chat_context(user_id: int) -> dict:
@@ -336,17 +387,36 @@ def _draft_note(draft: dict) -> str:
 
 
 def _looks_like_slot_answer(text: str) -> bool:
-    """Whether a message plausibly supplies a missing slot value."""
-    stripped = text.strip()
-    if not stripped:
+    """Whether a message plausibly supplies a missing slot value.
+
+    Used to decide whether to keep an open draft alive. Deliberately narrow:
+    while a draft is open, a bare "besok" or "jam 3" is part of it, but a
+    sentence about something else should be allowed to start a new topic.
+    """
+    stripped = (text or "").strip()
+    if not stripped or stripped.startswith("/"):
         return False
-    if stripped.startswith("/"):
-        return False
-    words = stripped.split()
-    if len(words) <= 6:
+
+    lowered = stripped.lower()
+
+    # Signals that the user is changing the subject entirely.
+    for cue in ("hadeh", "lupakan", "udahan", "stop", "batal", "nggajadi", "nggak jadi"):
+        if cue in lowered:
+            return False
+
+    # Anything short is treated as an answer to the pending question.
+    if len(stripped.split()) <= 8:
         return True
-    # A longer sentence can still be "besok jam 3 sore ya meetingnya di kafe".
-    return any(token.isdigit() for token in stripped) if len(words) <= 14 else False
+
+    # Longer messages still count when they carry a concrete date/time.
+    return bool(
+        _CLOCK_HOUR.search(lowered)
+        or _BARE_TIME.search(lowered)
+        or _DATE_DAY_MONTH.search(lowered)
+        or _DATE_NUMERIC.search(lowered)
+        or any(word in lowered for word in ("besok", "lusa", "hari ini", "minggu", "senin",
+                                            "selasa", "rabu", "kamis", "jumat", "sabtu"))
+    )
 
 
 def _merge_draft(draft: dict, intent: Intent) -> dict:
@@ -377,19 +447,182 @@ def _draft_complete(draft: dict) -> bool:
     return not (draft.get("missing") or [])
 
 
+# ── Deterministic slot extraction ─────────────────────────────────────────────
+#
+# Filling the date/time of a half-finished activity used to depend entirely on
+# the model, which answered CHAT for plain "Hari Minggu, 11 Oktober 2026" and
+# left the user stranded mid-flow. The clock is interchangeable, the schedule is
+# not, so parse it locally.
+
+_TIME_WORDS = {
+    "pagi": 9, "subuh": 5, "dini": 5, "siang": 12, "sore": 15,
+    "petang": 17, "malam": 20, "begadang": 23,
+}
+
+_DAY_WORDS = {
+    "senin": 0, "selasa": 1, "rabu": 2, "kamis": 3,
+    "jumat": 4, "jum'at": 4, "sabtu": 5, "minggu": 6,
+}
+
+_MONTH_WORDS = {
+    "januari": 1, "februari": 2, "maret": 3, "april": 4, "mei": 5, "juni": 6,
+    "juli": 7, "agustus": 8, "september": 9, "oktober": 10, "november": 11, "desember": 12,
+}
+
+_BARE_TIME = re.compile(r"\b([01]?\d|2[0-3])[.:]([0-5]\d)\b")
+_CLOCK_HOUR = re.compile(r"\b(?:jam|pukul)\s+([01]?\d|2[0-3])(?:[.:]([0-5]\d))?\b")
+_DATE_NUMERIC = re.compile(r"\b(\d{1,2})[-/](\d{1,2})(?:[-/](\d{2,4}))?\b")
+_DATE_DAY_MONTH = re.compile(
+    r"\b(\d{1,2})\s+([a-z]+)\s*(?:(\d{4}))?\b", re.IGNORECASE
+)
+
+
+def _extract_time(text: str) -> str | None:
+    """Pull an HH:MM out of free text, including 'jam 3 sore'."""
+    lowered = text.lower()
+
+    match = _CLOCK_HOUR.search(lowered)
+    if match:
+        hour = int(match.group(1))
+        minute = int(match.group(2) or 0)
+        # "jam 3 sore" means 15:00, not 03:00.
+        for word, shift in sorted(_TIME_WORDS.items(), key=lambda kv: -kv[1]):
+            if word in lowered and hour < 12 and shift >= 12:
+                hour += 12
+                break
+        return f"{hour:02d}:{minute:02d}"
+
+    match = _BARE_TIME.search(lowered)
+    if match:
+        return f"{int(match.group(1)):02d}:{int(match.group(2)):02d}"
+
+    for word, hour in sorted(_TIME_WORDS.items(), key=lambda kv: -kv[1]):
+        if word in lowered and "jam" not in lowered and "pukul" not in lowered:
+            return f"{hour:02d}:00"
+    return None
+
+
+def _extract_date(text: str, today: date) -> str | None:
+    """Pull a YYYY-MM-DD out of free text."""
+    lowered = text.lower()
+
+    # "Hari Minggu, 11 Oktober 2026" / "11 Oktober"
+    match = _DATE_DAY_MONTH.search(lowered)
+    if match:
+        day = int(match.group(1))
+        month = _MONTH_WORDS.get(match.group(2))
+        if month:
+            year = int(match.group(3)) if match.group(3) else today.year
+            try:
+                return date(year, month, day).isoformat()
+            except ValueError:
+                pass
+
+    # "11/10", "11-10", or "11-10-2026". Day/month order (Indonesian habit).
+    match = _DATE_NUMERIC.search(lowered)
+    if match:
+        day, month = int(match.group(1)), int(match.group(2))
+        raw_year = match.group(3)
+        if raw_year:
+            year = int(raw_year)
+            if year < 100:
+                year += 2000
+        else:
+            year = today.year
+        try:
+            return date(year, month, day).isoformat()
+        except ValueError:
+            pass
+
+    # Weekday names resolve to the NEXT occurrence, so a reminder is never
+    # silently scheduled in the past.
+    for word, weekday in _DAY_WORDS.items():
+        if word in lowered:
+            delta = (weekday - today.weekday()) % 7
+            delta = delta or 7
+            return (today + timedelta(days=delta)).isoformat()
+
+    if "hari ini" in lowered:
+        return today.isoformat()
+    if "besok" in lowered:
+        return (today + timedelta(days=1)).isoformat()
+    if "lusa" in lowered:
+        return (today + timedelta(days=2)).isoformat()
+
+    return None
+
+
+def _fill_slots_locally(draft: dict, text: str) -> dict:
+    """Fill empty date/time slots from the raw message without calling the model."""
+    slots = dict(draft.get("slots") or {})
+    today = _today_for_draft()
+
+    if not slots.get("time"):
+        found = _extract_time(text)
+        if found:
+            slots["time"] = found
+
+    if not slots.get("date"):
+        found = _extract_date(text, today)
+        if found:
+            slots["date"] = found
+
+    draft = dict(draft)
+    draft["slots"] = slots
+    draft["missing"] = [
+        slot for slot in _REQUIRED_ACTIVITY_SLOTS if not slots.get(slot)
+    ]
+    return draft
+
+
+def _today_for_draft() -> date:
+    return date.today()
+
+
+async def _finish_activity_draft(update, context, user_id, draft, text) -> None:
+    """Save a fully-specified activity and reply with its undo/delete buttons."""
+    await _apply_confirmed_action(
+        user_id,
+        Intent(
+            action=ACTION_ADD_ACTIVITY,
+            slots=draft["slots"],
+            missing=[],
+        ),
+        reply_fn=lambda message, keyboard: update.message.reply_text(
+            message, parse_mode="Markdown", reply_markup=keyboard
+        ),
+    )
+    await _remember(user_id, text, "kegiatan disimpan")
+
+
 async def _ask_for_missing(update: Update, draft: dict) -> None:
+    """Ask for whatever an activity is still missing, in Ginchiee's voice.
+
+    Shows what is already known so the user can see the draft taking shape,
+    instead of the same "boleh, aku catatin~" line on every turn.
+    """
     slots = draft.get("slots") or {}
     missing = draft.get("missing") or list(_REQUIRED_ACTIVITY_SLOTS)
 
-    lines = ["boleh, aku catatin~"]
+    known: list[str] = []
     if slots.get("title"):
-        lines.append(f"\n📌 *{_md(slots['title'])}*")
+        known.append(f"📌 *{_md(slots['title'])}*")
+    if slots.get("date"):
+        known.append(f"🗓️ {slots['date']}")
+    elif slots.get("time"):
+        known.append(f"🕒 {slots['time']}")
 
     question = SLOT_QUESTIONS.get(missing[0], missing[0])
-    lines.append(f"\n{question}")
+
+    if known:
+        lines = ["oke, ini yang aku tangkep sejauh ini:"] + known + ["", question]
+    else:
+        lines = [question]
 
     await update.message.reply_text("\n".join(lines), parse_mode="Markdown")
-    await _remember(update.effective_user.id, update.message.text or "", "\n".join(lines))
+    await _remember(
+        update.effective_user.id, update.message.text or "", "\n".join(lines)
+    )
 
 
 # ── Confirmation ──────────────────────────────────────────────────────────────
@@ -580,7 +813,10 @@ async def handle_confirm_callback(update: Update, context: ContextTypes.DEFAULT_
 
     try:
         message, keyboard = await _apply_confirmed_action(
-            update.effective_user.id, intent
+            update.effective_user.id, intent,
+            reply_fn=lambda m, k: query.edit_message_text(
+                m, parse_mode="Markdown", reply_markup=k
+            ),
         )
     except Exception as exc:
         logger.error("Confirmed action failed: %s", exc, exc_info=True)
@@ -608,15 +844,67 @@ async def handle_done_callback(update: Update, context: ContextTypes.DEFAULT_TYP
         await query.edit_message_text("hmm, kegiatannya nggak ketemu")
         return
 
+    # Re-render the entry in place so the row now reads as completed.
     await query.edit_message_text(
-        f"✅ *{_md(updated['title'])}* selesai ya. mantap! 🎉",
+        f"✅ *{_md(updated['title'])}* selesai ya. mantap! 🎉\n"
+        f"🕒 {format_activity_datetime(updated['activity_dt'])}",
         parse_mode="Markdown",
+        reply_markup=InlineKeyboardMarkup([_activity_buttons(updated)]),
     )
     await _remember(user_id, "[tombol tandai selesai]", f"{updated['title']} selesai")
 
 
-async def _apply_confirmed_action(user_id: int, intent: Intent):
-    """Run the staged action. Returns (message, keyboard_or_None)."""
+async def handle_undone_callback(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
+    query = update.callback_query
+    await query.answer()
+    user_id = update.effective_user.id
+
+    try:
+        activity_id = int((query.data or "").split(":", 1)[1])
+    except (ValueError, IndexError):
+        await query.edit_message_text("id-nya aneh, coba lagi ya")
+        return
+
+    updated = await unmark_activity_done(activity_id, user_id)
+    if not updated:
+        await query.edit_message_text("hmm, kegiatannya nggak ketemu")
+        return
+
+    await query.edit_message_text(
+        f"📌 *{_md(updated['title'])}*\n"
+        f"🕒 {format_activity_datetime(updated['activity_dt'])}\n\n"
+        f"_oke, aku aktifin lagi ya_",
+        parse_mode="Markdown",
+        reply_markup=InlineKeyboardMarkup([_activity_buttons(updated)]),
+    )
+    await _remember(user_id, "[tombol batalkan selesai]", f"{updated['title']} aktif lagi")
+
+
+async def _apply_confirmed_action(user_id: int, intent: Intent, reply_fn=None):
+    """Run an action and return (message, keyboard_or_None).
+
+    When `reply_fn` is given the result is also delivered through it, which
+    lets the same body serve both a fresh chat reply (an activity added
+    straight away) and the confirmation callback (which edits the button
+    message itself and passes None).
+    """
+    message, keyboard = await _run_action(user_id, intent)
+
+    if reply_fn is None:
+        return message, keyboard
+
+    try:
+        result = reply_fn(message, keyboard)
+        if inspect.isawaitable(result):
+            await result
+    except Exception as exc:  # noqa: BLE001
+        logger.error("Failed to deliver action reply: %s", exc, exc_info=True)
+
+    return message, keyboard
+
+
+async def _run_action(user_id: int, intent: Intent):
+    """Execute an action. Returns (message, keyboard_or_None)."""
     slots = intent.slots or {}
     action = intent.action
 
@@ -700,7 +988,10 @@ async def _apply_confirmed_action(user_id: int, intent: Intent):
         if not when:
             return "tanggal atau jamnya masih kurang lengkap nih", None
 
-        title = str(slots.get("title"))
+        title = str(slots.get("title") or "").strip()
+        if not title:
+            return "judul kegiatannya apa nih? aku belum tangkep", None
+
         remind = int(slots.get("remind_mins", 30) or 30)
         activity_id = await add_activity(
             user_id=user_id,
@@ -710,19 +1001,16 @@ async def _apply_confirmed_action(user_id: int, intent: Intent):
             remind_mins=remind,
         )
 
-        keyboard = InlineKeyboardMarkup([
-            [
-                InlineKeyboardButton("✅ tandai selesai", callback_data=f"done:{activity_id}"),
-                InlineKeyboardButton("🗑️ hapus", callback_data=f"del_activity:{activity_id}"),
-            ]
-        ])
-        return (
-            f"✅ oke, udah aku simpan!\n\n"
+        message = (
+            f"✅ oke, udah aku catat!\n\n"
             f"📌 *{_md(title)}*\n"
             f"🕒 {format_activity_datetime(when)} WIB\n"
-            f"⏰ aku ingatkan {remind} menit sebelumnya 🔔",
-            keyboard,
+            f"⏰ aku ingatkan {remind} menit sebelumnya 🔔"
         )
+        return message, InlineKeyboardMarkup([[
+            InlineKeyboardButton("✅ selesai", callback_data=f"done:{activity_id}"),
+            InlineKeyboardButton("🗑️ hapus", callback_data=f"del_activity:{activity_id}"),
+        ]])
 
     if action == ACTION_UPDATE_ACTIVITY:
         existing = await find_activity_by_reference(user_id, str(slots.get("target") or ""))
@@ -770,3 +1058,5 @@ def build_message_handlers():
     return [
         MessageHandler(filters.TEXT & ~filters.COMMAND, handle_message),
     ]
+
+

main.py

@@ -82,6 +82,7 @@ from bot.handlers.message_handler import (
     handle_confirm_callback,
     handle_done_callback,
     handle_message,
+    handle_undone_callback,
 )
 from bot.handlers.photo_handler import build_photo_handlers
 from bot.handlers.profile_handler import build_profile_handlers
@@ -278,6 +279,7 @@ def build_app() -> Application:
     # per-activity done/delete buttons.
     app.add_handler(CallbackQueryHandler(handle_confirm_callback, pattern=r"^confirm:"))
     app.add_handler(CallbackQueryHandler(handle_done_callback, pattern=r"^done:"))
+    app.add_handler(CallbackQueryHandler(handle_undone_callback, pattern=r"^undone:"))
 
     # Free-form text is handled by the intent router.
     app.add_handler(MessageHandler(filters.TEXT & ~filters.COMMAND, handle_message))

services/intent_service.py

@@ -214,12 +214,32 @@ Pilih TEPAT SATU action:
    Isi: {{"target": "semua" atau "terakhir" atau nama makanan}}
    Contoh: "hapus nasi goreng dari catatan", "gajadi deh nasi tadi hapus aja", "hapus semua makananku hari ini".
 
-4. ADD_ACTIVITY - user ingin MENYIMPAN kegiatan/jadwal baru.
-   Isi: {{"title": "...", "date": "YYYY-MM-DD", "time": "HH:MM", "description": "...", "remind_mins": 30}}
+4. ADD_ACTIVITY - user ingin MENYIMPAN kegiatan/jadwal/acara baru, atau minta
+   diingatkan sesuatu. Isi:
+   {{"title": "...", "date": "YYYY-MM-DD", "time": "HH:MM", "description": "...", "remind_mins": 30}}
    Slot wajib: title, date, time. Kalau user belum menyebut salah satunya,
    kosongkan field tsb (biarkan "") dan laporkan di "missing".
    Untuk "besok jam 3 sore" pakai date/tanggal besok dan time 15:00 (sore = 15:00-18:00).
-   Contoh: "ingetin aku besok jam 10 meeting", "tambahin jadwal kontrol dokter lusa".
+
+   WAJIB pilih ADD_ACTIVITY kalau pesan mengandung salah satu pemicu ini,
+   TERLEPAS dari berapa informasi yang ada:
+   - "ingetin aku...", "ingetin ya...", "tolong ingetin...", "bisa ingetin aku?"
+   - "jangan lupa aku...", "pengingat..."
+   - "masukkan ke jadwal/kegiatan/agenda", "catat jadwal", "simpen jadwal"
+   - pernyataan rencana yang punya hari/tanggal/jam: "aku ada X besok jam 10",
+     "aku mau X jam 2 sore", "besok ada X", "lusa ada X jam 3"
+   Kalau hanya pemicu tanpa detail (mis. "ingetin aku ya"), tetap ADD_ACTIVITY
+   dengan missing berisi semua slot yang belum diketahui. JANGAN jatuh ke CHAT.
+
+   URUTAN KATA TIDAK PENTING. Semua ini sama saja:
+   - "aku mau ngechat pacar jam 2 sore"
+   - "jam 2 sore aku mau ngechat pacar"
+   - "jam 2 sore yaa, aku mau ngechat pacar"
+
+   JUDUL HARUS BARU. Judul kegiatan hanya boleh berasal dari pesan user.
+   DILARANG KERAS menyalin judul dari "Kegiatan milik user yang tersimpan" di
+   atas — daftar itu hanya untuk melacak kegiatan yang mau diubah/dihapus.
+   Kalau user belum menyebut judulnya, title dibiarkan "" dan masuk ke missing.
 
 5. UPDATE_ACTIVITY - user ingin MENGUBAH kegiatan yang sudah ada.
    Isi: {{"target": "nama/judul kegiatan", "title": "...", "date": "...", "time": "...", "description": "...", "remind_mins": 30}}
@@ -237,8 +257,10 @@ Pilih TEPAT SATU action:
    Isi: {{"name": "nama baru"}}
    Contoh: "panggil aku Bella aja", "ganti nama aku ya", "namaku sekarang Gyna".
 
-9. VIEW_AGENDA - user minta MELIHAT jadwal/kegiatan.
+9. VIEW_AGENDA - user minta MELIHAT jadwal/kegiatan/agenda.
    Isi: {{}}
+   Pemicu: "agenda aku apa aja", "ada jadwal apa", "list kegiatan aku",
+   "apa aja yang harus aku lakukan", "kegiatan minggu ini apa", "jadwalku dong".
 
 10. CHAT - selain semua di atas: ngobrol santai, tanya jawab, curhat, cerita,
     pujian, atau menanyakan progress makanan (bukan mencatat).

tests/test_slot_extraction.py

@@ -0,0 +1,154 @@
+"""
+tests/test_slot_extraction.py
+
+Unit tests for the deterministic date/time extractor that backs activity
+drafting.
+
+Why this exists: filling the date and time of a half-finished activity used to
+depend entirely on the model, which answered CHAT for a plain "Hari Minggu,
+11 Oktober 2026" and stranded the user mid-flow. The clock is interchangeable,
+the schedule is not, so these are parsed locally and never need a model.
+
+Run:
+    python -m unittest tests.test_slot_extraction -v
+"""
+
+import unittest
+from datetime import date
+from pathlib import Path
+import sys
+
+PROJECT_ROOT = Path(__file__).resolve().parents[1]
+sys.path.insert(0, str(PROJECT_ROOT))
+
+from bot.handlers.message_handler import (  # noqa: E402
+    _extract_date,
+    _extract_time,
+    _fill_slots_locally,
+)
+
+# A Sunday, chosen so weekday resolution is unambiguous.
+TODAY = date(2026, 10, 11)
+
+
+class ExtractTimeTests(unittest.TestCase):
+    def test_clock_phrases(self) -> None:
+        for text, expected in [
+            ("Jam 2 sore ginchiee", "14:00"),
+            ("jam 3 sore", "15:00"),
+            ("jam 10 pagi", "10:00"),
+            ("jam 7 malam", "19:00"),
+            ("pukul 5 sore", "17:00"),
+            ("jam 5 subuh", "05:00"),
+        ]:
+            with self.subTest(text=text):
+                self.assertEqual(_extract_time(text), expected)
+
+    def test_numeric_times(self) -> None:
+        for text, expected in [
+            ("jam 09:30", "09:30"),
+            ("14:00", "14:00"),
+            ("jam 23.15", "23:15"),
+        ]:
+            with self.subTest(text=text):
+                self.assertEqual(_extract_time(text), expected)
+
+    def test_no_time_returns_none(self) -> None:
+        self.assertIsNone(_extract_time("aku ada rapat"))
+        self.assertIsNone(_extract_time("besok ya"))
+
+    def test_pm_words_shift_late_hours(self) -> None:
+        # "sore" must push a morning-shaped hour into the afternoon.
+        self.assertEqual(_extract_time("jam 11 sore"), "23:00")
+        self.assertEqual(_extract_time("jam 11 pagi"), "11:00")
+
+
+class ExtractDateTests(unittest.TestCase):
+    def test_long_date(self) -> None:
+        self.assertEqual(
+            _extract_date("Hari Minggu, 11 Oktober 2026", TODAY), "2026-10-11"
+        )
+
+    def test_day_month_without_year(self) -> None:
+        self.assertEqual(_extract_date("11 Oktober", TODAY), "2026-10-11")
+        self.assertEqual(_extract_date("3 Desember", TODAY), "2026-12-03")
+
+    def test_numeric_dates(self) -> None:
+        self.assertEqual(_extract_date("11/10", TODAY), "2026-10-11")
+        self.assertEqual(_extract_date("11-10", TODAY), "2026-10-11")
+        self.assertEqual(_extract_date("11-10-2026", TODAY), "2026-10-11")
+
+    def test_relative_days(self) -> None:
+        self.assertEqual(_extract_date("hari ini", TODAY), "2026-10-11")
+        self.assertEqual(_extract_date("besok", TODAY), "2026-10-12")
+        self.assertEqual(_extract_date("lusa", TODAY), "2026-10-13")
+
+    def test_weekday_names_resolve_to_next_occurrence(self) -> None:
+        # TODAY is Sunday 11 Oct 2026.
+        self.assertEqual(_extract_date("hari jumat", TODAY), "2026-10-16")
+        self.assertEqual(_extract_date("hari senin", TODAY), "2026-10-12")
+
+    def test_weekday_never_returns_today_or_past(self) -> None:
+        """A named day always means a future one, so a reminder is never lost."""
+        result = _extract_date("minggu", TODAY)
+        self.assertEqual(result, "2026-10-18")
+        self.assertGreater(result, TODAY.isoformat())
+
+    def test_no_date_returns_none(self) -> None:
+        self.assertIsNone(_extract_date("jam 2 sore", TODAY))
+        self.assertIsNone(_extract_date("mau ngechat pacar", TODAY))
+
+
+class FillSlotsTests(unittest.TestCase):
+    """The exact production sequence that used to break."""
+
+    def test_bare_instruction_then_date_then_time(self) -> None:
+        draft = {
+            "slots": {"title": "", "date": "", "time": ""},
+            "missing": ["title", "date", "time"],
+        }
+
+        # 1. "Masukkin ke jadwal kegiatan ginchiee" -> nothing parseable yet.
+        draft = _fill_slots_locally(draft, "Masukkin ke jadwal kegiatan ginchiee")
+        self.assertEqual(draft["slots"]["date"], "")
+        self.assertEqual(draft["slots"]["time"], "")
+        self.assertEqual(sorted(draft["missing"]), ["date", "time", "title"])
+
+        # 2. Date-only reply, which the model used to answer CHAT for.
+        draft = _fill_slots_locally(draft, "Hari Minggu, 11 Oktober 2026")
+        self.assertEqual(draft["slots"]["date"], "2026-10-11")
+        self.assertEqual(draft["slots"]["time"], "")
+        self.assertNotIn("date", draft["missing"])
+
+        # 3. Time-only reply.
+        draft = _fill_slots_locally(draft, "Jam 2 sore ginchiee")
+        self.assertEqual(draft["slots"]["time"], "14:00")
+
+        # Only the title is still outstanding, so the bot asks for just that.
+        self.assertEqual(draft["missing"], ["title"])
+
+    def test_does_not_overwrite_existing_slots(self) -> None:
+        draft = {
+            "slots": {"title": "rapat", "date": "2026-10-12", "time": ""},
+            "missing": ["time"],
+        }
+        draft = _fill_slots_locally(draft, "besok jam 9 pagi")
+        # Date already set, so "besok" must not replace 2026-10-12.
+        self.assertEqual(draft["slots"]["date"], "2026-10-12")
+        self.assertEqual(draft["slots"]["time"], "09:00")
+        self.assertEqual(draft["missing"], [])
+
+    def test_never_uses_an_old_activity_title(self) -> None:
+        """The extractor cannot invent a title, so old titles cannot leak."""
+        draft = {
+            "slots": {"title": "", "date": "", "time": ""},
+            "missing": ["title", "date", "time"],
+        }
+        draft = _fill_slots_locally(draft, "Hari Minggu, 11 Oktober 2026")
+        draft = _fill_slots_locally(draft, "Jam 2 sore ginchiee")
+        self.assertEqual(draft["slots"]["title"], "")
+        self.assertIn("title", draft["missing"])
+
+
+if __name__ == "__main__":
+    unittest.main()