superlocalmemory 4.1.13 → 4.1.14

package/src/superlocalmemory/retrieval/temporal_validity_filter.py

@@ -1,499 +0,0 @@
-# Copyright (c) 2026 Varun Pratap Bhardwaj / Qualixar
-# Licensed under AGPL-3.0-or-later - see LICENSE file
-# Part of SuperLocalMemory V3 | https://qualixar.com | https://varunpratap.com
-
-"""Bi-temporal validity filter for the retrieval pipeline (Phase 4, T1 + T1b).
-
-Post-retrieval filter that demotes facts whose bi-temporal validity window
-makes them ineligible for the current recall point in time. Two independent
-demotion axes:
-
-**Axis 1 — Transaction-time supersession (P5-INT-01, existing):**
-A fact whose temporal record has ``system_expired_at`` set was superseded or
-contradicted by a newer fact (see ``invalidate_fact_temporal`` /
-conflict-resolution supersession). Its per-channel score is multiplied by
-``superseded_demotion_factor`` (default 0.25).
-
-**Axis 2 — Event-time expiry (Phase 4 T1b, new):**
-A fact whose ``valid_until`` has passed (in wall-clock time) was true in the
-real world only up to that date. Its per-channel score is multiplied by
-``event_time_demotion_factor`` (default 0.5, softer than supersession). A
-separate "not-yet-valid" demotion applies when ``as_of`` is set for
-point-in-time time-travel recall: facts whose ``valid_from > as_of`` are
-also demoted.
-
-**Zero-regression guarantee (default path):**
-Almost all existing facts have ``valid_until = NULL`` (open-ended / still
-valid). The event-time expiry lookup therefore returns an empty set on the
-default path, so no scores change and default recall output is identical.
-Additionally, when ``include_expired_in_history = True`` (the config default)
-AND no explicit ``as_of`` is requested, event-time demotion is skipped
-entirely — the guard ensures historical recall modes that intentionally want
-to surface expired facts are unaffected.
-
-**As-of time-travel:**
-When ``as_of`` is packed into the filter context dict (``{"as_of": "..."}``),
-event-time demotion is always applied regardless of
-``include_expired_in_history``, because the caller explicitly requested a
-point-in-time view. Facts not yet valid at ``as_of`` (``valid_from > as_of``)
-and facts already expired at ``as_of`` (``valid_until <= as_of``, half-open) are
-both demoted.
-
-**Demotion priority:**
-- System-invalidated facts: score × ``superseded_demotion_factor`` (0.25).
-- Event-time-expired only (not system-invalidated): score × ``event_time_demotion_factor`` (0.5).
-- Both: system-invalidated wins (the harder demotion, 0.25, is applied; event-time
-  demotion is not stacked to avoid excessive double-penalty).
-
-All demotions are non-destructive (P5-INT-01): facts stay in the candidate
-list but rank below valid facts. A factor of 0.0 restores the legacy hide
-behaviour (a score of zero is gated out by the evidence floor).
-
-All correction-admission lookups are bounded (candidate ids only), chunked,
-and indexed.  Admission is deliberately **fail-closed**: if SLM cannot prove
-which candidates are invalidated, it returns no candidates rather than let an
-approved stale fact re-enter recall.  The legacy score-demotion filter follows
-the same rule for its system-invalidated lookup.  Event-time demotion remains a
-best-effort ranking signal; it is not the correction authority.
-
-Integrates with ChannelRegistry.register_filter() using the FilterFn signature:
-    (all_channel_results, profile_id, context) -> filtered_results
-
-Part of Qualixar | Author: Varun Pratap Bhardwaj
-License: AGPL-3.0-or-later
-"""
-
-from __future__ import annotations
-
-import logging
-from dataclasses import dataclass, field
-from typing import TYPE_CHECKING, Any
-
-if TYPE_CHECKING:
-    from superlocalmemory.core.config import TemporalValidatorConfig
-    from superlocalmemory.retrieval.channel_registry import ChannelRegistry
-    from superlocalmemory.storage.database import DatabaseManager
-
-logger = logging.getLogger(__name__)
-
-# Module-level fallback for event-time demotion factor.
-# Used when the config object does not yet carry ``event_time_demotion_factor``
-# (e.g. older serialised configs loaded from disk). Softer than the supersession
-# factor (0.25) because event-time expiry is a softer signal — the boundary may
-# be approximate or the fact may still be conceptually relevant.
-_EVENT_TIME_DEMOTION_FACTOR: float = 0.5
-
-
-@dataclass
-class CorrectionAdmissionCache:
-    """Per-recall lifecycle admission cache.
-
-    The retrieval engine performs a mandatory second admission after bridge or
-    scene expansion.  Facts already checked before fusion do not need a second
-    database read in the *same* recall, while any newly expanded id is checked
-    immediately.  The cache never crosses requests, profiles, or DB writes.
-    """
-
-    checked_fact_ids: set[str] = field(default_factory=set)
-    inadmissible_fact_ids: set[str] = field(default_factory=set)
-    unavailable: bool = False
-
-
-def _normalized_as_of(as_of: str | None) -> str | None:
-    """Normalize an optional transaction-time boundary at one boundary.
-
-    The MCP/HTTP adapters already reject invalid non-blank values.  Engine
-    callers are also public, however, so an invalid direct value must degrade
-    to current recall rather than turn a read into an exception.
-    """
-    if as_of is None:
-        return None
-    from superlocalmemory.retrieval.temporal_utils import normalize_as_of
-    return normalize_as_of(as_of)
-
-
-def _invalidated_candidate_ids(
-    db: DatabaseManager,
-    fact_ids: set[str],
-    profile_id: str,
-    *,
-    as_of: str | None = None,
-    include_global: bool = False,
-    include_shared: bool = False,
-    lifecycle_cache: CorrectionAdmissionCache | None = None,
-) -> set[str] | None:
-    """Return correction failures, or ``None`` when admission is unprovable.
-
-    ``None`` is intentionally distinct from an empty set.  Callers MUST turn
-    it into an abstention (an empty candidate path), never treat it as "nothing
-    invalidated".  Treating an unavailable lifecycle read as an empty set is a
-    fail-open path through which an approved stale fact can be re-admitted.
-    """
-    if not fact_ids:
-        return set()
-    if lifecycle_cache is not None and lifecycle_cache.unavailable:
-        return None
-    unchecked = (
-        fact_ids - lifecycle_cache.checked_fact_ids
-        if lifecycle_cache is not None
-        else fact_ids
-    )
-    if not unchecked:
-        return (
-            lifecycle_cache.inadmissible_fact_ids & fact_ids
-            if lifecycle_cache is not None
-            else set()
-        )
-    try:
-        kwargs: dict[str, Any] = {"as_of": _normalized_as_of(as_of)}
-        if include_global:
-            kwargs["include_global"] = True
-        if include_shared:
-            kwargs["include_shared"] = True
-        # Do not infer support from a permissive mock's dynamic attributes.
-        # The concrete storage manager owns this optimized contract; older
-        # adapters continue through the two focused public queries below.
-        combined = getattr(type(db), "get_correction_inadmissible_fact_ids", None)
-        if callable(combined):
-            invalid = db.get_correction_inadmissible_fact_ids(
-                list(unchecked), profile_id, **kwargs,
-            )
-        else:
-            invalid = db.get_invalidated_fact_ids(list(unchecked), profile_id, **kwargs)
-            pending_successors = db.get_nonapplied_correction_successor_ids(
-                list(unchecked),
-                profile_id,
-                include_global=include_global,
-                include_shared=include_shared,
-            )
-            if not isinstance(pending_successors, set):
-                return None
-            invalid |= pending_successors
-    except Exception as exc:
-        logger.warning("Correction admission lookup failed: %s", exc)
-        if lifecycle_cache is not None:
-            lifecycle_cache.unavailable = True
-        return None
-    if not isinstance(invalid, set):
-        if lifecycle_cache is not None:
-            lifecycle_cache.unavailable = True
-        return None
-    if lifecycle_cache is not None:
-        lifecycle_cache.checked_fact_ids.update(unchecked)
-        lifecycle_cache.inadmissible_fact_ids.update(invalid)
-        return lifecycle_cache.inadmissible_fact_ids & fact_ids
-    return invalid
-
-
-def _strict_temporal_candidate_ids(
-    db: DatabaseManager,
-    fact_ids: set[str],
-    profile_id: str,
-    *,
-    known_as_of: str | None = None,
-    valid_at: str | None = None,
-    include_unknown: bool = False,
-    include_global: bool = False,
-    include_shared: bool = False,
-) -> set[str] | None:
-    """Return strict two-clock failures, or ``None`` when admission is unprovable."""
-    if not fact_ids or (known_as_of is None and valid_at is None):
-        return set()
-    try:
-        invalid = db.get_strict_temporal_inadmissible_fact_ids(
-            list(fact_ids), profile_id,
-            known_as_of=_normalized_as_of(known_as_of),
-            valid_at=_normalized_as_of(valid_at),
-            include_unknown=include_unknown,
-            include_global=include_global,
-            include_shared=include_shared,
-        )
-    except Exception as exc:
-        logger.warning("Strict temporal admission lookup failed: %s", exc)
-        return None
-    return invalid if isinstance(invalid, set) else None
-
-
-def _abstain_candidates(
-    all_results: dict[str, list[tuple[str, float]]],
-    *,
-    stage: str,
-) -> dict[str, list[tuple[str, float]]]:
-    """Fail closed without changing the retrieval filter public contract.
-
-    ``ChannelRegistry`` and the retrieval engine both expect the original
-    channel-result shape.  Returning the same channel names with empty lists
-    is an explicit candidate-level abstention: downstream fusion naturally
-    produces no materializable facts, while callers keep their stable response
-    schema and can report ``no_confident_match``.
-    """
-    logger.error(
-        "Temporal correction admission unavailable at %s; abstaining from recall candidates",
-        stage,
-    )
-    return {channel_name: [] for channel_name in all_results}
-
-
-def admit_correction_candidates(
-    all_results: dict[str, list[tuple[str, float]]],
-    profile_id: str,
-    db: DatabaseManager,
-    *,
-    as_of: str | None = None,
-    known_as_of: str | None = None,
-    valid_at: str | None = None,
-    include_unknown: bool = False,
-    include_global: bool = False,
-    include_shared: bool = False,
-    lifecycle_cache: CorrectionAdmissionCache | None = None,
-) -> dict[str, list[tuple[str, float]]]:
-    """Hard-exclude system-superseded facts before candidate fusion.
-
-    This is the SLM 4.0.2 Brain Core admission invariant.  Ranking is unable to
-    enforce a correction because a high-scoring stale fact can still win.  The
-    historical ``as_of`` boundary preserves facts that had not yet been
-    superseded at that point, so current corrections do not rewrite history.
-    """
-    fact_ids = {
-        fact_id
-        for channel_results in all_results.values()
-        for fact_id, _ in channel_results
-    }
-    invalid = _invalidated_candidate_ids(
-        db, fact_ids, profile_id, as_of=as_of,
-        include_global=include_global, include_shared=include_shared,
-        lifecycle_cache=lifecycle_cache,
-    )
-    if invalid is None:
-        return _abstain_candidates(all_results, stage="pre_fusion.lifecycle")
-    strict = _strict_temporal_candidate_ids(
-        db, fact_ids, profile_id,
-        known_as_of=known_as_of, valid_at=valid_at,
-        include_unknown=include_unknown,
-        include_global=include_global, include_shared=include_shared,
-    )
-    if strict is None:
-        return _abstain_candidates(all_results, stage="pre_fusion.strict_temporal")
-    if strict:
-        invalid |= strict
-    if not invalid:
-        return all_results
-    return {
-        channel_name: [
-            (fact_id, score)
-            for fact_id, score in channel_results
-            if fact_id not in invalid
-        ]
-        for channel_name, channel_results in all_results.items()
-    }
-
-
-def admit_correction_fusion_results(
-    fused_results: list[Any],
-    profile_id: str,
-    db: DatabaseManager,
-    *,
-    as_of: str | None = None,
-    known_as_of: str | None = None,
-    valid_at: str | None = None,
-    include_unknown: bool = False,
-    include_global: bool = False,
-    include_shared: bool = False,
-    lifecycle_cache: CorrectionAdmissionCache | None = None,
-) -> list[Any]:
-    """Re-apply correction admission after graph/scene candidate expansion."""
-    fact_ids = {result.fact_id for result in fused_results}
-    invalid = _invalidated_candidate_ids(
-        db, fact_ids, profile_id, as_of=as_of,
-        include_global=include_global, include_shared=include_shared,
-        lifecycle_cache=lifecycle_cache,
-    )
-    if invalid is None:
-        logger.error(
-            "Temporal correction admission unavailable at post_fusion.lifecycle; "
-            "abstaining from recall candidates",
-        )
-        return []
-    strict = _strict_temporal_candidate_ids(
-        db, fact_ids, profile_id,
-        known_as_of=known_as_of, valid_at=valid_at,
-        include_unknown=include_unknown,
-        include_global=include_global, include_shared=include_shared,
-    )
-    if strict is None:
-        logger.error(
-            "Temporal correction admission unavailable at post_fusion.strict_temporal; "
-            "abstaining from recall candidates",
-        )
-        return []
-    if strict:
-        invalid |= strict
-    if not invalid:
-        return fused_results
-    return [result for result in fused_results if result.fact_id not in invalid]
-
-
-class TemporalValidityFilter:
-    """Demotes bi-temporally invalid facts in retrieval candidates.
-
-    Two demotion axes:
-    - Axis 1: system-invalidated (superseded) facts — existing behaviour.
-    - Axis 2: event-time-expired facts — new in Phase 4 T1b.
-
-    Both are non-destructive: facts stay recallable but rank below valid ones.
-    """
-
-    __slots__ = (
-        "_db",
-        "_demotion_factor",
-        "_event_time_factor",
-        "_include_expired_in_history",
-    )
-
-    def __init__(
-        self,
-        db: DatabaseManager,
-        demotion_factor: float = 0.25,
-        event_time_factor: float = _EVENT_TIME_DEMOTION_FACTOR,
-        include_expired_in_history: bool = True,
-    ) -> None:
-        self._db = db
-        # Clamp to [0, 1]. 0.0 = legacy hide; 1.0 = no demotion.
-        self._demotion_factor = max(0.0, min(1.0, float(demotion_factor)))
-        self._event_time_factor = max(0.0, min(1.0, float(event_time_factor)))
-        self._include_expired_in_history = bool(include_expired_in_history)
-
-    def filter(
-        self,
-        all_results: dict[str, list[tuple[str, float]]],
-        profile_id: str,
-        context: Any,
-    ) -> dict[str, list[tuple[str, float]]]:
-        """Demote bi-temporally invalid fact_ids in every channel's candidate list.
-
-        Matches FilterFn signature from channel_registry.py.
-
-        Args:
-            all_results: Channel name -> [(fact_id, score)] dict.
-            profile_id: Current profile.
-            context: Optional dict that may carry ``as_of`` (ISO 8601 string)
-                for point-in-time time-travel recall. None or any non-dict value
-                means "current time, no time-travel" — the default path.
-
-        Returns:
-            A new dict where invalid facts keep their channel presence but have
-            their score scaled by the appropriate demotion factor and the channel
-            lists re-sorted so valid facts rank above them. Inputs are never
-            mutated (immutability contract). Returns the input unchanged when
-            nothing is invalid (fast path).
-        """
-        # Collect all unique candidate fact_ids across every channel.
-        all_fact_ids: set[str] = set()
-        for channel_results in all_results.values():
-            for fact_id, _ in channel_results:
-                all_fact_ids.add(fact_id)
-
-        if not all_fact_ids:
-            return all_results
-
-        # Extract as_of FIRST — needed for both Axis 1 and Axis 2. Must happen
-        # before any DB call so as_of is available for transaction-time gating.
-        # None context = legacy/default; non-dict = upstream caller without
-        # as_of support. Both treated as "no time-travel, current time".
-        as_of: str | None = (
-            context.get("as_of") if isinstance(context, dict) else None
-        )
-        # UTC-normalize at the filter boundary to guarantee format consistency
-        # before forwarding to DB comparisons.
-        if as_of is not None:
-            from superlocalmemory.retrieval.temporal_utils import normalize_as_of
-            as_of = normalize_as_of(as_of)
-            # normalize_as_of returns None on invalid input; treat as no as_of.
-
-        # --- Axis 1: Transaction-time supersession ---
-        # When as_of is set: only supersessions that occurred AT OR BEFORE
-        # as_of contribute (Phase 4b bi-temporal fix). Supersessions after
-        # as_of are invisible — the fact was still valid at the query point.
-        invalid = _invalidated_candidate_ids(
-            self._db, all_fact_ids, profile_id, as_of=as_of,
-        )
-        if invalid is None:
-            return _abstain_candidates(all_results, stage="legacy_filter.lifecycle")
-
-        # --- Axis 2: Event-time expiry (Phase 4 T1b) ---
-        # Guard: skip event-time demotion when the caller signals it wants
-        # historical / all-expired-included mode AND no explicit as_of point
-        # is requested.  Config default is include_expired_in_history=True,
-        # so the default recall path always takes this skip branch — the two
-        # new DB calls are never made, and no scores change.
-        apply_event_time = (as_of is not None) or (not self._include_expired_in_history)
-
-        event_expired: set[str] = set()
-        if apply_event_time:
-            try:
-                event_expired = self._db.get_event_time_expired_fact_ids(
-                    list(all_fact_ids), profile_id, as_of=as_of,
-                )
-            except Exception as exc:
-                # Fail-open: continue with empty event_expired set.
-                logger.warning("Event-time expiry lookup failed: %s", exc)
-
-        # Fast path: nothing to demote — return input unchanged.
-        if not invalid and not event_expired:
-            return all_results
-
-        system_factor = self._demotion_factor
-        event_factor = self._event_time_factor
-        # event_time_only: expired by event-time but NOT system-invalidated.
-        # System-invalid already carries the harder demotion (0.25 < 0.5).
-        # We do not stack both factors to avoid excessive double-penalty.
-        event_time_only = event_expired - invalid
-
-        demoted: dict[str, list[tuple[str, float]]] = {}
-        for channel_name, channel_results in all_results.items():
-            new_list = [
-                (fact_id,
-                 score * system_factor if fact_id in invalid
-                 else score * event_factor if fact_id in event_time_only
-                 else score)
-                for fact_id, score in channel_results
-            ]
-            # Re-sort descending so demoted facts fall below currently-valid
-            # facts in this channel's rank order.
-            new_list.sort(key=lambda pair: (-pair[1], pair[0]))
-            demoted[channel_name] = new_list
-        return demoted
-
-
-def register_temporal_validity_filter(
-    registry: ChannelRegistry,
-    db: DatabaseManager,
-    config: TemporalValidatorConfig,
-) -> None:
-    """Register the bi-temporal validity filter into the channel registry.
-
-    Does nothing if config.enabled is False.
-
-    Reads ``event_time_demotion_factor`` from the config with a fallback to the
-    module constant ``_EVENT_TIME_DEMOTION_FACTOR`` (0.5) so older serialised
-    configs without this field work without a migration.
-
-    Args:
-        registry: Channel registry to register with.
-        db: Database manager for validity queries.
-        config: Temporal-validator configuration.
-    """
-    if not getattr(config, "enabled", True):
-        return
-    factor = getattr(config, "superseded_demotion_factor", 0.25)
-    event_time_factor = getattr(
-        config, "event_time_demotion_factor", _EVENT_TIME_DEMOTION_FACTOR,
-    )
-    include_expired_in_history = getattr(config, "include_expired_in_history", True)
-    f = TemporalValidityFilter(
-        db,
-        demotion_factor=factor,
-        event_time_factor=event_time_factor,
-        include_expired_in_history=include_expired_in_history,
-    )
-    registry.register_filter(f.filter)

package/src/superlocalmemory/retrieval/time_window.py

@@ -1,181 +0,0 @@
-# Copyright (c) 2026 Varun Pratap Bhardwaj / Qualixar
-# Licensed under AGPL-3.0-or-later - see LICENSE file
-# Part of SuperLocalMemory V3 | https://qualixar.com | https://varunpratap.com
-
-"""Time-window parsing + membership for recall (Phase 4, T-window).
-
-Pure, dependency-free helpers so recall() can prune candidates to an
-event-time range. Two window forms are accepted:
-
-  * relative string — ``"1h" | "24h" | "7d" | "30d" | "90d" | "1y"`` etc.
-    (``<int><unit>`` where unit is h/d/w/m/y; m≈30d, y≈365d) → ``[now-Δ, now]``.
-  * explicit range — ``(start_iso, end_iso)`` two-tuple of timestamps.
-
-Timestamps are parsed tolerantly: SQLite ``datetime('now')`` form
-(``"YYYY-MM-DD HH:MM:SS"``), ISO-8601 with ``T`` and/or trailing ``Z``, and
-date-only ``"YYYY-MM-DD"`` are all accepted. Comparing the *strings* would be
-wrong (a space sorts before ``T``), so everything is parsed to tz-aware UTC
-datetimes before comparison — never lexicographic.
-
-Part of Qualixar | Author: Varun Pratap Bhardwaj
-License: AGPL-3.0-or-later
-"""
-
-from __future__ import annotations
-
-import re
-from datetime import datetime, timedelta, timezone
-
-__all__ = [
-    "parse_timestamp",
-    "parse_window",
-    "in_window",
-    "infer_window_from_query",
-]
-
-_REL = re.compile(r"^\s*(\d+)\s*([hdwmy])\s*$", re.IGNORECASE)
-
-# Hours per unit. Month and year are documented approximations.
-_UNIT_HOURS: dict[str, int] = {
-    "h": 1,
-    "d": 24,
-    "w": 24 * 7,
-    "m": 24 * 30,
-    "y": 24 * 365,
-}
-
-
-def parse_timestamp(value: str | None) -> datetime | None:
-    """Parse a stored timestamp into a tz-aware UTC datetime, or None.
-
-    Accepts SQLite ``datetime('now')`` (space-separated), ISO-8601 (``T`` and
-    optional ``Z``), and date-only strings. Naive values are assumed UTC.
-    """
-    if not value or not isinstance(value, str):
-        return None
-    text = value.strip()
-    if not text:
-        return None
-    if text.endswith(("Z", "z")):
-        text = text[:-1] + "+00:00"
-    dt: datetime | None = None
-    try:
-        dt = datetime.fromisoformat(text)
-    except ValueError:
-        # Fall back to a date-only prefix (e.g. "2026-03-15 ...").
-        try:
-            dt = datetime.fromisoformat(text[:10])
-        except ValueError:
-            return None
-    if dt.tzinfo is None:
-        dt = dt.replace(tzinfo=timezone.utc)
-    return dt.astimezone(timezone.utc)
-
-
-def parse_window(
-    window: str | tuple[str, str] | list | None,
-    now: datetime | None = None,
-) -> tuple[datetime, datetime] | None:
-    """Resolve a window spec to a ``(start, end)`` UTC datetime pair, or None.
-
-    Returns None when the spec is None or unparseable (caller then applies no
-    time filter — additive, fail-open).
-    """
-    if window is None:
-        return None
-    _now = now or datetime.now(timezone.utc)
-    if _now.tzinfo is None:
-        _now = _now.replace(tzinfo=timezone.utc)
-
-    # Explicit (start, end) range.
-    if isinstance(window, (tuple, list)):
-        if len(window) != 2:
-            return None
-        start = parse_timestamp(window[0])
-        end = parse_timestamp(window[1])
-        if start is None or end is None:
-            return None
-        return (start, end) if start <= end else (end, start)
-
-    # String forms: relative "<int><unit>" or an explicit range written as
-    # "start..end" / "start,end" (so it survives URL params, JSON, and CLI args
-    # as a single value — no tuple serialization needed on the wire).
-    if isinstance(window, str):
-        m = _REL.match(window)
-        if m:
-            n = int(m.group(1))
-            unit = m.group(2).lower()
-            hours = n * _UNIT_HOURS[unit]
-            return (_now - timedelta(hours=hours), _now)
-        for sep in ("..", ","):
-            if sep in window:
-                left, _, right = window.partition(sep)
-                start = parse_timestamp(left)
-                end = parse_timestamp(right)
-                if start is None or end is None:
-                    return None
-                return (start, end) if start <= end else (end, start)
-
-    return None
-
-
-# Natural-language temporal-scope patterns → relative window spec. Ordered:
-# more specific ("last 3 weeks") is matched before generic ("last week").
-_UNIT_TO_SPEC = {"day": "d", "week": "w", "month": "m", "year": "y"}
-_QUERY_N_UNIT = re.compile(
-    r"\b(?:last|past|previous|prior)\s+(\d{1,3})\s+(day|week|month|year)s?\b",
-    re.IGNORECASE,
-)
-_QUERY_PHRASES: tuple[tuple[re.Pattern[str], str], ...] = (
-    (re.compile(r"\btoday\b", re.IGNORECASE), "1d"),
-    (re.compile(r"\byesterday\b", re.IGNORECASE), "2d"),
-    (re.compile(r"\b(?:this|last|past|previous)\s+week\b", re.IGNORECASE), "7d"),
-    (re.compile(r"\b(?:this|last|past|previous)\s+month\b", re.IGNORECASE), "30d"),
-    (re.compile(r"\b(?:this|last|past|previous)\s+year\b", re.IGNORECASE), "1y"),
-    (re.compile(r"\b(?:recent|recently|lately)\b", re.IGNORECASE), "30d"),
-)
-
-
-def infer_window_from_query(query: str | None) -> str | None:
-    """Infer a relative time window from natural-language scope in a query.
-
-    Recognises a small, unambiguous set of temporal-scope phrases ("yesterday",
-    "last week", "past 3 months", "recently") and maps them to a relative
-    window spec ("2d", "7d", "3m", …) that ``parse_window`` understands. Returns
-    None when no clear temporal scope is present, so recall applies no window.
-
-    Deliberately conservative — only fires on explicit scope words, never on
-    bare content — so it augments, never surprises. Callers use it only when the
-    user did not pass an explicit window.
-    """
-    if not query or not isinstance(query, str):
-        return None
-    m = _QUERY_N_UNIT.search(query)
-    if m:
-        n = int(m.group(1))
-        unit = _UNIT_TO_SPEC.get(m.group(2).lower())
-        if unit and n > 0:
-            return f"{n}{unit}"
-    for pattern, spec in _QUERY_PHRASES:
-        if pattern.search(query):
-            return spec
-    return None
-
-
-def in_window(
-    event_time: str | None,
-    bounds: tuple[datetime, datetime] | None,
-) -> bool:
-    """True if ``event_time`` falls within ``bounds`` (inclusive).
-
-    No bounds → always True (no filtering). An unparseable/missing event time
-    is excluded (conservative: a windowed query returns only datable facts in
-    range).
-    """
-    if bounds is None:
-        return True
-    dt = parse_timestamp(event_time)
-    if dt is None:
-        return False
-    start, end = bounds
-    return start <= dt <= end