[NOTICKET] feat(scope): relative periods resolved against today and applied by code (P0-5)

"6 bulan terakhir" ran as week 1–44 (the whole year); the planner.md rule was
prose only. period.relative_window (D7, WIB): "N bulan terakhir" = the N
complete months before today's month; bulan lalu/ini, tahun lalu/ini, kuartal
lalu/ini. Released to the planner: windows across two years, period
comparisons (YoY, "dibanding tahun lalu"), "N bulan lalu", open ranges, weekly.
A period comparison releases even when one side parses (review round 3).
Comparisons against a target or between sites keep the window. All-time wording
("selama ini", "seluruh data", "ever") releases. The scope hook takes `today`;
the planner eval passes each case's date. Scope line hides only `*_id` next to
its code column.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

eval/planner/run_eval.py

@@ -458,7 +458,8 @@ async def _run_case(catalog: Any, tools: Any, n2id: dict, case: dict, **plan_kw:
             user_message=case["question"], value_index=_fixture_value_index(catalog)
         )
         plan_kw["prepare"] = SlowPathCoordinator._scope_hook(
-            context, catalog, inputs, None, case["question"], {}
+            context, catalog, inputs, None, case["question"], {},
+            today=plan_kw.get("today"),  # P0-5: relative periods resolve on the case's date
         )
     try:
         task_list = await planner.plan(

src/agents/scope/engine.py

@@ -1144,7 +1144,8 @@ def render_scope_line(
             for f in _meta_filters(out):
                 col = str(f.get("column", "")).lower()
                 # `site_id 2009` is the resolved id of `site_code IPR`, already shown (P0-4).
-                if col in eff_cols or _stem(col) in eff_stems:
+                # Only `*_id` columns: a `unit_no` next to `unit_name` may disagree.
+                if col in eff_cols or (col.endswith("_id") and _stem(col) in eff_stems):
                     continue
                 rendered = _render_filter(f)
                 bucket = period_parts if col in _PERIOD_COLUMNS else others

src/agents/scope/period.py

@@ -121,7 +121,9 @@ _OWN_PERIOD = re.compile(
     r"by year|per year)\b|"
     r"\b(awal|akhir|pertengahan)\s+(tahun|bulan)\b|"
     r"\b(semua|seluruh)\s+(tahun|periode)\b|\bkeseluruhan data\b|\bsepanjang waktu\b|"
-    r"\ball (years|time|periods)\b|\btanggal\s+\d+|\bdalam\s+\d+\s+(tahun|bulan)\b",
+    r"\ball (years|time|periods)\b|\btanggal\s+\d+|\bdalam\s+\d+\s+(tahun|bulan)\b|"
+    r"\b(ever|historically|all data|historis|selama ini|sepanjang masa|"
+    r"(semua|seluruh)\s+data(\s+yang\s+ada)?)\b|\b\d+\s+(days?|weeks?|months?|years?)\s+ago\b",
     re.IGNORECASE,
 )
 _INT_TYPES = ("int", "integer")
@@ -192,23 +194,141 @@ def names_own_period(text: str) -> bool:
         return True
 
 
-def turn_window(user_text: str, objective: str) -> tuple[Window | None, str]:
+# Relative periods (audit P0-5, D7: counted back from TODAY, WIB). "6 bulan terakhir"
+# ran as `week 1–44` (the whole year) on analysis 2d841e2f; the planner.md rule (N
+# complete months before today's month) was prose only.
+_NUM_WORDS = {
+    "satu": 1, "dua": 2, "tiga": 3, "empat": 4, "lima": 5, "enam": 6, "tujuh": 7,
+    "delapan": 8, "sembilan": 9, "sepuluh": 10, "sebelas": 11, "dua belas": 12,
+    "one": 1, "two": 2, "three": 3, "four": 4, "five": 5, "six": 6, "seven": 7,
+    "eight": 8, "nine": 9, "ten": 10, "eleven": 11, "twelve": 12,
+}
+_N = r"(\d{1,2}|" + "|".join(sorted(_NUM_WORDS, key=len, reverse=True)) + r")"
+_LAST_N_MONTHS = re.compile(
+    rf"\b{_N}\s+bulan\s+(?:terakhir|ke\s*belakang|belakangan)\b|"
+    rf"\b(?:last|past|previous)\s+{_N}\s+months?\b",
+    re.IGNORECASE,
+)
+_PREV_MONTH = re.compile(r"\b(bulan\s+(?:lalu|kemarin|sebelumnya)|last month|previous month)\b",
+                         re.IGNORECASE)
+_THIS_MONTH = re.compile(r"\b(bulan\s+ini|this month)\b", re.IGNORECASE)
+_THIS_YEAR = re.compile(r"\b(tahun\s+ini|this year)\b", re.IGNORECASE)
+_PREV_YEAR = re.compile(r"\b(tahun\s+(?:lalu|kemarin|sebelumnya)|last year|previous year)\b",
+                        re.IGNORECASE)
+_PREV_QUARTER = re.compile(r"\b((?:kuartal|triwulan)\s+(?:lalu|sebelumnya)|last quarter|"
+                           r"previous quarter)\b", re.IGNORECASE)
+_THIS_QUARTER = re.compile(r"\b((?:kuartal|triwulan)\s+ini|this quarter)\b", re.IGNORECASE)
+# A comparison BETWEEN PERIODS (review 2026-11-03): the comparison word near a period
+# word, or a year-over-year phrase. "dibandingkan target 85%" and "IPR vs ADT" compare
+# something else and keep the window.
+_COMPARE = re.compile(
+    r"\b(dibanding\w*|banding\w*|vs\.?|versus|compared?(?:\s+(?:to|with))?)\s+"
+    r"(?:\S+\s+){0,3}?(periode|tahun|bulan|kuartal|triwulan|minggu|sebelumnya|"
+    r"(?:the\s+)?(?:last|previous|prior|same)\s+(?:year|month|quarter|week|period)|"
+    r"year|month|quarter|week)\b|"
+    r"\b(yoy|year[- ]over[- ]year|tahun ke tahun|periode yang sama|same period)\b",
+    re.IGNORECASE,
+)
+# "3 bulan lalu" is ONE month three months back, not "bulan lalu"; "2 tahun lalu" is
+# not last year; "3 months ago" — ambiguous windows, left to the planner.
+_N_AGO = re.compile(
+    rf"\b{_N}\s+(bulan|tahun|minggu|pekan|kuartal|triwulan)\s+(lalu|sebelumnya|kemarin)\b|"
+    rf"\b{_N}\s+(months?|years?|weeks?|quarters?)\s+ago\b",
+    re.IGNORECASE,
+)
+# An open range from a relative point ("sejak tahun lalu", "dari bulan lalu sampai
+# sekarang") runs to today — across a year boundary, so left to the planner.
+_OPEN_RANGE = re.compile(
+    r"\b(sejak|dari|mulai|since|from)\s+(tahun|bulan|kuartal|triwulan|last|the last)\b|"
+    r"\b(sampai|hingga)\s+(sekarang|saat ini|kini)\b|\b(until now|to date|so far)\b",
+    re.IGNORECASE,
+)
+UNRESOLVED = "unresolved"
+
+
+def _n(token: str) -> int | None:
+    t = token.lower()
+    return int(t) if t.isdigit() else _NUM_WORDS.get(t)
+
+
+def relative_window(text: str, today: _dt.date) -> Window | str | None:
+    """A relative period in `text` resolved against `today`.
+
+    Window — resolved inside one calendar year; UNRESOLVED — a relative period that
+    spans two years, compares periods ("dibanding tahun lalu"), or is weekly (the
+    planner keeps it); None — no relative period. "N bulan terakhir" = the N complete
+    months before today's month (planner.md's rule, now code).
+    """
+    if not text:
+        return None
+    if _N_AGO.search(text):
+        return UNRESOLVED
+    y, m = today.year, today.month
+    found: list[Window | str] = []
+    hit = _LAST_N_MONTHS.search(text)
+    if hit:
+        n = _n(next(g for g in hit.groups() if g))
+        if n and 1 <= n <= 12:
+            found.append(Window(y, m - n, m - 1) if m - n >= 1 else UNRESOLVED)
+        else:
+            found.append(UNRESOLVED)
+    if _PREV_MONTH.search(text):
+        found.append(Window(y, m - 1, m - 1) if m > 1 else Window(y - 1, 12, 12))
+    if _THIS_MONTH.search(text):
+        found.append(Window(y, m, m))
+    if _PREV_YEAR.search(text):
+        found.append(Window(y - 1))
+    if _THIS_YEAR.search(text):
+        found.append(Window(y))
+    q = (m - 1) // 3  # 0-based current quarter
+    if _PREV_QUARTER.search(text):
+        found.append(Window(y, 3 * q - 2, 3 * q) if q > 0 else Window(y - 1, 10, 12))
+    if _THIS_QUARTER.search(text):
+        found.append(Window(y, 3 * q + 1, 3 * q + 3))
+    if re.search(r"\b\d+\s+(minggu|pekan)\s+terakhir\b|\blast\s+\d+\s+weeks?\b", text,
+                 re.IGNORECASE):
+        found.append(UNRESOLVED)
+    if not found:
+        return None
+    if len(found) > 1 or _COMPARE.search(text) or _OPEN_RANGE.search(text):
+        return UNRESOLVED  # two periods, a period comparison, or an open range
+    return found[0]
+
+
+def turn_window(
+    user_text: str, objective: str, today: _dt.date | None = None
+) -> tuple[Window | None, str]:
     """The window code applies this turn, and where it came from.
 
     - the user's own words name a clean window ("Juni–September 2026") → that window:
       Sofhia's analysis a67625f2 typed it and the planner still filtered month 6–9 with
       no year, reading June–September of every year (records #3, #6);
     - they name months but no year ("Januari–Juli") → those months in the objective's year;
-    - they name a period the parser does not resolve ("6 bulan terakhir", "dibanding
-      tahun lalu", two years) → None: the planner keeps it ("released");
+    - a relative period inside one year ("6 bulan terakhir", "bulan lalu", "tahun ini")
+      → resolved against `today` (D7; WIB by default);
+    - they name a period the parser does not resolve ("dibanding tahun lalu", a window
+      across two years, "8 minggu terakhir", two years) → None: the planner keeps it
+      ("released");
     - they name no period → the objective's window (None if it has none).
     Never raises.
     """
     try:
         obj = parse_window(objective)
+        # A period comparison ("Juni–September 2026 dibanding tahun lalu", YoY) is the
+        # planner's to build, even when one side parses: applying that side by code
+        # would collapse a one-query comparison into one period (review 2026-11-03).
+        if _COMPARE.search(user_text or ""):
+            return None, "released"
         own = parse_window(user_text)
         if own is not None:
             return own, "question"
+        if today is None:
+            today = _dt.datetime.now(_dt.timezone(_dt.timedelta(hours=7))).date()
+        rel = relative_window(user_text, today)
+        if isinstance(rel, Window):
+            return rel, "relative"
+        if rel == UNRESOLVED:
+            return None, "released"
         if obj is not None and _month_numbers(user_text) and not _years(user_text):
             merged = parse_window(f"{user_text} {obj.year}")
             if merged is not None:

src/agents/slow_path/coordinator.py

@@ -11,7 +11,7 @@ See AGENT_ARCHITECTURE_CONTEXT_new.md §5.2 / §6.1.
 from __future__ import annotations
 
 from collections.abc import Awaitable, Callable
-from datetime import UTC, datetime
+from datetime import UTC, date, datetime
 from typing import Any
 
 from src.middlewares.logging import get_logger
@@ -145,10 +145,14 @@ class SlowPathCoordinator:
         scope_values: Awaitable[dict[str, list[str]]] | None,
         query: str,
         held: dict[str, Any],
+        today: date | None = None,
     ) -> Callable[[TaskList], Awaitable[None]]:
         """The planner's `prepare` hook: resolve this turn's scope and apply it to every
         retrieve_data of each attempt, BEFORE validation (2026-10-29).
 
+        `today` resolves relative periods (P0-5); None = today in WIB, as the planner's
+        own "Today's date" line. The planner eval passes its case's fixed date.
+
         Before validation because the planner's own site handling was what failed:
         gate run 2 lost 6 of 31 turns to typed ids and made-up placeholders that code
         can replace with the right join. The value lists (`values.py`) load alongside
@@ -201,7 +205,7 @@ class SlowPathCoordinator:
                     turn_window,
                 )
 
-                window, origin = turn_window(scope.user_message or query, objective)
+                window, origin = turn_window(scope.user_message or query, objective, today)
                 if (
                     window is not None
                     and not plan_forecasts(task_list)
@@ -321,8 +325,13 @@ def _infeasible_output(
 ) -> AssembledOutput:
     """Build the data-gap answer + a faithful (non-substantive) record."""
     reason = task_list.infeasible_reason or ""
+    # A plan that failed its checks is not a data gap (P0-9): its own text, no lead.
+    answer = (
+        reason if getattr(task_list, "_exhausted", False) and reason
+        else data_gap_message(reason, reply_language)
+    )
     return AssembledOutput(
-        chat_answer=data_gap_message(reason, reply_language),
+        chat_answer=answer,
         analysis_record=AnalysisRecord(
             goal_restated=task_list.goal_restated,
             findings=[],