Datasets:

Jambo1988
/

HomeActEval

import json
import re


class KnowledgeRetriever:
    """Retrieve context-relevant static rules and habit rules.
    The retriever intentionally does not use benchmark labels, scenario IDs, or
    oracle habit_GT fields. It only uses the current observation plus the
    structured KB files available to the evaluated assistant.
    """

    DAYS = ["monday", "tuesday", "wednesday", "thursday", "friday", "saturday", "sunday"]
    GLOBAL_LOCATIONS = {"anywhere", "all", "home", "house", "indoor", "indoors", "all rooms"}
    DEVIATION_CUES = {
        "still", "remains", "remain", "remaining", "no ", "not ", "without",
        "missing", "missed", "late", "delayed", "delay", "empty", "dry",
        "cluttered", "untidied", "unplugged", "idle", "scattered", "muddy",
        "full", "asleep", "sleeping", "yawning", "left", "forgotten",
    }
    CONTINUING_CUES = {"still", "remains", "remain", "continuing", "ongoing", "engrossed"}
    ROUTINE_BLOCKING_CUES = {
        "still", "remains", "remain", "remaining", "engrossed", "watching",
        "browsing", "scrolling", "typing", "working", "chatting", "lounging",
        "sitting", "looking for", "getting into bed", "walks from", "directly",
        "straight", "idle", "full", "unplugged", "cooking", "chopping",
        "shower", "reading", "movie", "videos", "computer", "desk", "sofa",
    }
    DURATION_LIMIT_CUES = {
        "has been", "continuously", "continuous", "consecutive", "for ",
        "since", "started at", "2 hours", "2.5 hours", "3 hours", "135 minutes",
        "140th", "timer", "exceeds", "exceeded", "without taking a break",
        "without a break", "continues the gaming session",
    }
    LATE_SCREEN_STRONG_CUES = {
        "active", "actively", "still", "continues", "continuing", "run late",
        "past", "cutoff", "second movie", "vr", "headset", "brightly lit",
        "videos", "watching videos", "watching a movie", "work emails",
        "emails", "social media", "laptop", "tablet", "turning up", "volume",
        "sound system", "music is playing",
    }
    BRIEF_BEDTIME_PHONE_CUES = {
        "brief", "briefly", "short", "one short", "message", "messages",
        "checks a smartphone", "reads a few", "reads messages",
    }
    DEADLINE_BLOCKING_CUES = {
        "go out", "leaving", "leave", "packing", "slowly", "complex",
        "focused", "still sleeping", "asleep",
    }

    STOPWORDS = {
        "a", "an", "and", "are", "as", "at", "be", "before", "between", "by",
        "for", "from", "in", "into", "is", "it", "must", "no", "not", "of",
        "on", "or", "the", "their", "there", "to", "user", "with", "without",
    }

    RULE_KEYWORDS = {
        "coffee": {
            "coffee", "espresso", "caffeine", "latte", "americano", "cup",
        },
        "drinking coffee": {
            "coffee", "espresso", "caffeine", "latte", "americano",
        },
        "feeding pets": {
            "feed", "feeding", "fed", "pet", "pets", "dog", "cat", "bowl",
            "food", "treat", "treats",
        },
        "eating snacks": {
            "snack", "snacks", "chips", "cookie", "cookies", "nuts", "candy",
            "crumbs", "eat", "eating", "lunch", "fruit", "apple", "grapes",
        },
        "using electronic devices": {
            "phone", "smartphone", "tablet", "ipad", "laptop", "charger",
            "charging", "device", "devices", "speaker", "earbuds",
        },
        "high-intensity screen use or electronic entertainment": {
            "game", "games", "gaming", "pc", "video", "videos", "movie",
            "streaming", "screen", "entertainment", "console", "phone",
            "smartphone", "tablet", "ipad", "laptop", "e-book", "ebook",
            "vr", "headset", "music", "sound", "vinyl", "tv",
        },
        "eating (any food)": {
            "eat", "eating", "lunch", "dinner", "breakfast", "meal", "food",
            "snack", "snacks", "noodles", "rice", "sandwich",
        },
        "using phones or tablets": {
            "phone", "smartphone", "tablet", "ipad", "laptop", "screen",
        },
        "playing video games": {
            "game", "games", "gaming", "pc", "console", "video game",
        },
        "using stove": {
            "stove", "burner", "cooktop", "pan", "pot", "cooking",
            "flame", "fire", "boiling",
        },
        "full_house_cleaning": {
            "clean", "cleaning", "cluttered", "untidied", "tidy", "tidying",
            "vacuum", "sweeping", "dust", "bathroom", "living room",
        },
        "watering_plants": {
            "water", "watering", "plants", "planters", "balcony", "dry",
        },
        "laundry_washing": {
            "laundry", "washer", "washing", "dryer", "drying", "basket",
            "clothes", "towels", "sheets", "socks", "pile",
        },
        "playing_piano": {
            "piano", "practice", "keyboard", "music",
        },
    }

    HABIT_KEYWORDS = {
        "wake": {"wake", "wakes", "awake", "asleep", "sleeping", "bed", "lying"},
        "weather_schedule": {
            "weather", "schedule", "calendar", "ipad", "tablet", "morning",
        },
        "grooming": {
            "groom", "grooming", "bathroom", "wash", "washing", "face", "shaving",
            "shaver", "makeup",
        },
        "meditation": {"meditation", "meditates", "quietly", "breathing", "sits"},
        "breakfast": {
            "breakfast", "kitchen", "eggs", "toast", "cereal", "morning meal",
        },
        "medicine": {"medicine", "medication", "pill", "pills", "water"},
        "coffee": {"coffee", "espresso", "caffeine", "kitchen"},
        "lunch": {"lunch", "meal", "kitchen", "sofa", "noodles"},
        "news": {"news", "tablet", "tv", "scrolling", "stories", "media"},
        "nap_rest": {
            "nap", "asleep", "sleep", "rest", "resting", "sofa", "lounging",
        },
        "daily_summary": {
            "summary", "planning", "tasks", "notes", "desk", "study", "editing",
        },
        "deep_work": {
            "work", "working", "typing", "desk", "study", "computer", "reading",
            "research", "notes", "focused", "deep", "editing",
        },
        "exercise": {
            "exercise", "stretch", "stretching", "mobility", "yoga", "mat",
            "wrist", "sports",
        },
        "dinner": {
            "dinner", "cook", "cooking", "chopping", "vegetables", "rice",
            "noodles", "kitchen",
        },
        "trash": {"trash", "garbage", "bag", "bins", "bin", "outdoor"},
        "dog_walk": {"walk", "walking", "leash", "dog", "outdoor", "entrance"},
        "dog_paws": {"paws", "paw", "muddy", "leash", "entrance", "dog"},
        "dog_feeding": {"feed", "feeding", "dog", "bowl", "food", "water", "empty"},
        "tea": {"tea", "herbal", "warm water", "drink", "kitchen"},
        "safety_check": {
            "doors", "windows", "lights", "check", "safety", "bed", "before bed",
        },
        "skincare": {"skincare", "floss", "flossing", "bathroom", "shower"},
        "brushing": {"brush", "brushing", "teeth", "toothbrush", "bathroom"},
        "charging": {
            "charge", "charging", "charger", "unplugged", "phone", "tablet",
            "desk", "nightstand",
        },
        "phone_bed": {
            "phone", "smartphone", "message", "messages", "bed", "reading",
        },
        "sleep": {"sleep", "asleep", "bed", "bedroom", "lamp"},
        "laundry": {
            "laundry", "washer", "washing", "drying", "basket", "clothes",
            "towels", "sheets",
        },
        "plants": {"plants", "planters", "watering", "water", "dry", "balcony"},
        "cleaning": {
            "cleaning", "clean", "cluttered", "untidied", "vacuum", "sweeping",
            "bathroom", "living room",
        },
        "finances": {"finance", "finances", "budget", "spreadsheet", "bills"},
        "music_family": {"music", "piano", "call", "family", "video call"},
    }

    HABIT_CONCEPT_HINTS = [
        ("weather_schedule", {"weather", "schedule", "ipad"}),
        ("grooming", {"groom", "bathroom", "face"}),
        ("breakfast", {"breakfast"}),
        ("medicine", {"medicine"}),
        ("coffee", {"coffee"}),
        ("lunch", {"lunch"}),
        ("news", {"news"}),
        ("nap_rest", {"rest", "sofa", "afternoon"}),
        ("daily_summary", {"summary", "plans", "tasks"}),
        ("dinner", {"dinner"}),
        ("trash", {"trash"}),
        ("dog_walk", {"walks the dog", "dog walk"}),
        ("dog_paws", {"paws", "leash"}),
        ("dog_feeding", {"feeds the dog", "dog food", "water bowl"}),
        ("tea", {"tea", "warm water"}),
        ("safety_check", {"doors", "windows", "lights"}),
        ("skincare", {"skincare", "floss"}),
        ("brushing", {"brushes teeth", "teeth"}),
        ("charging", {"charges", "charging", "mobile devices"}),
        ("phone_bed", {"smartphone", "phone"}),
        ("sleep", {"goes to sleep", "sleep"}),
        ("exercise", {"stretch", "mobility"}),
        ("deep_work", {"deep work", "focused reading", "coding notes", "self-study"}),
        ("laundry", {"laundry", "sheets", "towels"}),
        ("plants", {"plants"}),
        ("cleaning", {"cleaning"}),
        ("finances", {"finances", "budget"}),
        ("music_family", {"music", "family", "piano"}),
    ]

    def __init__(self, static_kb_path, habit_kb_path):
        self.static_rules = self._load_json(static_kb_path)
        self.habit_rules = self._load_json(habit_kb_path)

    def _load_json(self, path):
        if path is None:
            return []
        try:
            with open(path, "r", encoding="utf-8") as f:
                return json.load(f)
        except Exception as exc:
            print(f"Error loading {path}: {exc}")
            return []

    def _normalize(self, text):
        return str(text or "").lower().replace("_", " ")

    def _tokenize(self, text):
        text = self._normalize(text)
        return set(re.findall(r"[a-z0-9]+", text)) - self.STOPWORDS

    def _has_any_phrase(self, text, phrases):
        text = self._normalize(text)
        return any(str(phrase).lower() in text for phrase in phrases)

    def _parse_minutes(self, time_str):
        try:
            time_str = str(time_str).replace("：", ":")
            h, m = map(int, time_str.strip().split(":"))
            return h * 60 + m
        except Exception:
            return -1

    def _extract_window(self, window_str):
        window = self._normalize(window_str)
        match = re.search(r"(\d{1,2}:\d{2})\s*-\s*(\d{1,2}:\d{2})", window)
        if not match:
            return None, None
        return self._parse_minutes(match.group(1)), self._parse_minutes(match.group(2))

    def _day_matches(self, current_day, window_str):
        rule = self._normalize(window_str)
        day = self._normalize(current_day).strip()
        if "always" in rule:
            return True

        has_day = (
            any(d in rule for d in self.DAYS)
            or "weekday" in rule
            or "weekdays" in rule
            or "weekend" in rule
            or "weekends" in rule
        )
        if not has_day:
            return True
        if day in rule:
            return True
        if ("weekday" in rule or "weekdays" in rule) and day not in {"saturday", "sunday"}:
            return True
        if ("weekend" in rule or "weekends" in rule) and day in {"saturday", "sunday"}:
            return True
        return False

    def _is_next_day_after_rule_day(self, current_day, window_str):
        rule = self._normalize(window_str)
        day = self._normalize(current_day).strip()
        if day not in self.DAYS:
            return False
        current_index = self.DAYS.index(day)
        for rule_index, rule_day in enumerate(self.DAYS):
            if rule_day in rule and current_index == (rule_index + 1) % len(self.DAYS):
                return True
        return False

    def _time_relation(self, current_day, current_time_str, window_str, tolerance=0):
        if not self._day_matches(current_day, window_str):
            return None

        window = self._normalize(window_str)
        if "always" in window:
            return {
                "match": True,
                "relation": "always",
                "distance": 0,
                "start": None,
                "end": None,
            }

        start, end = self._extract_window(window)
        current = self._parse_minutes(current_time_str)
        if start is None or end is None or current == -1:
            return {
                "match": True,
                "relation": "day-only",
                "distance": 0,
                "start": start,
                "end": end,
            }

        candidates = [(current, start, end)]
        # Early-morning test events often need the previous evening bedtime
        # routines. Compare them on an extended timeline without changing the
        # public timestamp.
        if current <= 4 * 60:
            candidates.append((current + 24 * 60, start, end + 24 * 60 if end < start else end))
            if start >= 18 * 60:
                candidates.append((current + 24 * 60, start, end + (24 * 60 if end < start else 0)))

        best = None
        for curr, s, e in candidates:
            if s <= e:
                if s - tolerance <= curr <= e + tolerance:
                    distance = 0 if s <= curr <= e else min(abs(curr - s), abs(curr - e))
                    relation = "within" if s <= curr <= e else "near"
                elif curr < s:
                    distance = s - curr
                    relation = "upcoming"
                else:
                    distance = curr - e
                    relation = "overdue"
            else:
                if curr >= s or curr <= e:
                    distance = 0
                    relation = "within"
                elif curr < s:
                    distance = s - curr
                    relation = "upcoming"
                else:
                    distance = curr - e
                    relation = "overdue"

            candidate = {
                "match": relation in {"within", "near"},
                "relation": relation,
                "distance": distance,
                "start": s,
                "end": e,
            }
            if best is None or candidate["distance"] < best["distance"]:
                best = candidate
        return best

    def _is_location_match(self, current_loc, rule_loc):
        current = self._normalize(current_loc)
        rule = self._normalize(rule_loc)

        if any(global_loc == rule or global_loc in rule.split(",") for global_loc in self.GLOBAL_LOCATIONS):
            return True

        current_tokens = self._tokenize(current)
        for loc_part in str(rule_loc or "").split(","):
            loc_tokens = self._tokenize(loc_part)
            if not loc_tokens:
                continue
            if loc_tokens & self.GLOBAL_LOCATIONS:
                return True
            if loc_tokens.issubset(current_tokens):
                return True
        return False

    def _location_score(self, current_loc, rule_loc):
        if self._is_location_match(current_loc, rule_loc):
            return 1.0
        current_tokens = self._tokenize(current_loc)
        rule_tokens = self._tokenize(rule_loc)
        if not current_tokens or not rule_tokens:
            return 0.0
        overlap = len(current_tokens & rule_tokens)
        return overlap / max(len(rule_tokens), 1)

    def _event_has_deviation_cue(self, event_text):
        text = self._normalize(event_text)
        return self._has_any_phrase(text, self.DEVIATION_CUES)

    def _event_has_continuing_cue(self, event_text):
        text = self._normalize(event_text)
        return self._has_any_phrase(text, self.CONTINUING_CUES)

    def _event_has_routine_blocking_cue(self, event_text):
        text = self._normalize(event_text)
        return self._has_any_phrase(text, self.ROUTINE_BLOCKING_CUES)

    def _event_has_deadline_blocking_cue(self, event_text):
        text = self._normalize(event_text)
        return self._has_any_phrase(text, self.DEADLINE_BLOCKING_CUES)

    def _keyword_score(self, event_text, keywords):
        if not event_text or not keywords:
            return 0.0
        text = self._normalize(event_text)
        event_tokens = self._tokenize(text)
        score = 0.0
        for keyword in keywords:
            keyword = self._normalize(keyword)
            if " " in keyword:
                if keyword in text:
                    score += 1.25
            elif keyword in event_tokens:
                score += 1.0
        return score

    def _rule_keywords(self, rule):
        target = self._normalize(rule.get("target_action", ""))
        desc = self._normalize(rule.get("description", ""))
        keywords = set()
        for key, values in self.RULE_KEYWORDS.items():
            normalized_key = self._normalize(key)
            if normalized_key in target or normalized_key in desc:
                keywords.update(values)
        if not keywords:
            keywords.update(self._tokenize(target))
        return keywords

    def _numeric_duration_minutes(self, event_text):
        text = self._normalize(event_text)
        durations = []
        for value, unit in re.findall(r"(\d+(?:\.\d+)?)\s*(hour|hours|hr|hrs|minute|minutes|min|mins)", text):
            amount = float(value)
            if unit.startswith(("hour", "hr")):
                durations.append(amount * 60)
            else:
                durations.append(amount)
        # Phrases such as "2 hours and 15 minutes" produce two matches;
        # returning the sum is a useful approximation for limit checks.
        if durations:
            return sum(durations)
        return None

    def _duration_limit_rule_applies(self, event_text):
        text = self._normalize(event_text)
        if "after playing" in text or "taking a walk" in text or "take a break" in text:
            return False
        if not self._keyword_score(text, self.RULE_KEYWORDS["playing video games"]):
            return False

        duration = self._numeric_duration_minutes(text)
        if duration is not None:
            return duration > 120

        if "started at" in text or "since" in text:
            return True
        return self._has_any_phrase(text, self.DURATION_LIMIT_CUES)

    def _late_screen_rule_applies(self, event_text, relation, current_time):
        text = self._normalize(event_text)
        tokens = self._tokenize(text)
        current_minutes = self._parse_minutes(current_time)
        in_late_window = (
            relation
            and relation.get("relation") in {"within", "near"}
            and current_minutes != -1
            and (current_minutes >= 23 * 60 or current_minutes <= 6 * 60)
        )
        near_cutoff = (
            relation
            and relation.get("relation") == "upcoming"
            and relation.get("distance") is not None
            and relation["distance"] <= 10
        )
        if not (in_late_window or near_cutoff):
            return False

        is_charging_only = (
            self._has_any_phrase(text, {"plugging in", "plugged in", "charging", "charger", "charge"})
            and not self._has_any_phrase(
                text,
                {
                    "using", "watch", "watching", "scrolling", "browsing",
                    "playing", "active", "actively", "videos", "movie",
                    "emails", "social media", "vr", "headset",
                },
            )
        )
        if is_charging_only:
            return False

        inactive_device_state = (
            bool(tokens & {"phone", "smartphone", "tablet", "laptop"})
            and self._has_any_phrase(text, {"remain", "remains", "unplugged", "on the desk", "on desk"})
            and not self._has_any_phrase(
                text,
                {
                    "using", "watch", "watching", "scrolling", "browsing",
                    "playing", "active", "actively", "videos", "movie",
                    "emails", "social media", "vr", "headset",
                },
            )
        )
        if inactive_device_state:
            return False

        # The user's short phone-in-bed routine is explicitly allowed. Keep it
        # out unless the observation also contains stronger work/entertainment
        # cues such as videos, emails, VR, or prolonged active use.
        is_bed_phone = (
            "bed" in tokens
            and bool(tokens & {"phone", "smartphone"})
            and self._has_any_phrase(text, self.BRIEF_BEDTIME_PHONE_CUES)
        )
        if is_bed_phone and not self._has_any_phrase(text, self.LATE_SCREEN_STRONG_CUES):
            return False

        # Plain "is playing games" is not enough to activate a late-night rule:
        # the observation needs an overrun, active-continuation, intensity, or
        # explicit cutoff cue. Duration-specific gaming is handled by R009.
        is_plain_gaming = (
            bool(tokens & {"game", "games", "gaming", "pc", "console"})
            and not self._has_any_phrase(text, self.LATE_SCREEN_STRONG_CUES)
            and not self._duration_limit_rule_applies(text)
        )
        if is_plain_gaming:
            return False

        if self._has_any_phrase(text, self.LATE_SCREEN_STRONG_CUES):
            return True
        if near_cutoff and self._has_any_phrase(text, {"setting up", "watch", "movie", "laptop", "tablet"}):
            return True
        if in_late_window and bool(tokens & {"smartphone", "phone", "tablet", "laptop", "vr", "headset"}):
            return True
        return False

    def _is_completion_or_progress_event(self, event_text):
        text = self._normalize(event_text)
        progress_words = {
            "using", "doing", "cleaning", "vacuum", "sweeping", "watering",
            "organizing", "sorting", "washing", "preparing", "cooking",
        }
        return bool(self._tokenize(text) & progress_words) and not self._event_has_deviation_cue(text)

    def _rule_relevance(self, rule, current_day, current_time, current_location, event_text):
        relation = self._time_relation(current_day, current_time, rule.get("time_window", "always"))
        event_text = event_text or ""
        action = self._normalize(rule.get("action", ""))
        target = self._normalize(rule.get("target_action", ""))
        keywords = self._rule_keywords(rule)
        keyword_score = self._keyword_score(event_text, keywords)
        has_deviation_cue = self._event_has_deviation_cue(event_text)
        location_match = self._is_location_match(current_location, rule.get("location", "anywhere"))
        current_minutes = self._parse_minutes(current_time)
        minutes_to_window_end = None
        if relation is not None and isinstance(relation.get("end"), int) and current_minutes != -1:
            end = relation["end"]
            if end >= current_minutes:
                minutes_to_window_end = end - current_minutes

        if relation is None:
            # Deadline rules can still be relevant on the morning after a
            # missed deadline if the event text is semantically related.
            if action == "remind if incomplete" and keyword_score > 0 and self._is_next_day_after_rule_day(
                current_day,
                rule.get("time_window", "always"),
            ):
                relation = {
                    "match": False,
                    "relation": "missed-deadline",
                    "distance": 24 * 60,
                    "start": None,
                    "end": None,
                }
            else:
                return None

        # Do not let global rules appear in every prompt. Rules need either
        # action relevance or an incomplete/deadline cue.
        if action in {"forbid", "limit count", "limit duration", "forbid except brief bedtime phone use"}:
            near_cutoff = (
                rule.get("rule_id") == "R006"
                and relation["relation"] == "upcoming"
                and relation["distance"] is not None
                and relation["distance"] <= 10
            )
            if not relation["match"] and relation["relation"] not in {"always", "day-only"} and not near_cutoff:
                return None
            if not location_match:
                return None
            if keyword_score <= 0:
                return None
            if rule.get("rule_id") == "R009" and not self._duration_limit_rule_applies(event_text):
                return None
            if rule.get("rule_id") == "R006" and not self._late_screen_rule_applies(
                event_text,
                relation,
                current_time,
            ):
                return None
            # Boundary protection: a normal electric shaver should not be
            # treated as the same as phone/tablet/laptop use in a bathroom.
            if rule.get("rule_id") == "R005" and "shaver" in self._tokenize(event_text):
                return None
        elif "require presence" in action:
            if not relation["match"] and relation["relation"] not in {"always", "day-only"}:
                return None
            if keyword_score <= 0:
                return None
            # Presence rules may describe a remote appliance state, e.g. the
            # user is in the living room while the kitchen stove is active.
            if not location_match and "kitchen" not in self._normalize(event_text) and "stove" not in self._normalize(event_text):
                return None
        elif action == "remind if incomplete":
            has_deadline_blocking_cue = self._event_has_deadline_blocking_cue(event_text)
            imminent_deadline = (
                relation["relation"] == "within"
                and minutes_to_window_end is not None
                and minutes_to_window_end <= 90
            )
            urgent_deadline = (
                relation["relation"] == "within"
                and minutes_to_window_end is not None
                and minutes_to_window_end <= 15
            )
            recently_missed_deadline = (
                relation["relation"] in {"overdue", "missed-deadline"}
                and relation["distance"] is not None
                and relation["distance"] <= 180
            )
            very_recently_missed_deadline = (
                relation["relation"] in {"overdue", "missed-deadline"}
                and relation["distance"] is not None
                and relation["distance"] <= 30
            )
            semantic_related = keyword_score > 0
            deadline_attention_needed = (
                urgent_deadline
                or very_recently_missed_deadline
                or (imminent_deadline and (has_deviation_cue or has_deadline_blocking_cue))
                or (
                    recently_missed_deadline
                    and (semantic_related or has_deviation_cue or has_deadline_blocking_cue)
                )
            )
            relation_ok = (
                semantic_related
                or deadline_attention_needed
            )
            if not relation_ok:
                return None
            if (
                keyword_score > 0
                and self._is_completion_or_progress_event(event_text)
                and not has_deviation_cue
                and not recently_missed_deadline
            ):
                return None
        elif action == "enforce schedule":
            relation_ok = relation["match"] or relation["relation"] == "within"
            if not relation_ok:
                return None
        elif keyword_score <= 0 and target:
            return None
        elif not location_match:
            return None

        score = 50 + keyword_score * 10
        if relation["relation"] in {"within", "always", "day-only"}:
            score += 20
        elif relation["relation"] in {"overdue", "upcoming"} and relation["distance"] is not None:
            score += max(0, 18 - relation["distance"] / 10)
        elif relation["relation"] == "missed-deadline":
            score += 8
        if has_deviation_cue:
            score += 8
        return {
            "score": score,
            "relation": relation["relation"],
            "distance": relation["distance"],
            "kind": "rule",
        }

    def _habit_concepts(self, habit):
        text = self._normalize(habit.get("description", ""))
        concepts = set()
        for concept, hints in self.HABIT_CONCEPT_HINTS:
            if any(self._normalize(hint) in text for hint in hints):
                concepts.add(concept)
        if "goes to sleep" in text:
            concepts.add("sleep")
        return concepts

    def _habit_keywords(self, habit):
        concepts = self._habit_concepts(habit)
        keywords = set(self._tokenize(habit.get("description", "")))
        for concept in concepts:
            keywords.update(self.HABIT_KEYWORDS.get(concept, set()))
        return keywords

    def _habit_signal(self, relation, loc_score, keyword_score, event_text):
        if not relation or relation.get("distance") is None:
            return ""

        distance = relation["distance"]
        relation_name = relation["relation"]
        has_deviation_cue = self._event_has_deviation_cue(event_text)
        has_continuing_cue = self._event_has_continuing_cue(event_text)
        has_blocking_cue = self._event_has_routine_blocking_cue(event_text)
        location_shift = loc_score < 0.35

        timing = ""
        if relation_name == "within":
            timing = "routine is due now"
        elif relation_name == "overdue" and distance <= 180:
            timing = f"routine is about {int(distance)} min overdue"
        elif relation_name == "upcoming" and distance <= 45:
            timing = f"routine is due in about {int(distance)} min"
        elif relation_name == "near" and distance <= 30:
            timing = "routine is close to its usual window"

        if not timing:
            return ""

        cues = []
        if has_deviation_cue:
            cues.append("the observation contains an omission/delay cue")
        elif has_continuing_cue:
            cues.append("the observation suggests the current activity is continuing")
        elif has_blocking_cue:
            cues.append("the observation may be occupying the routine window")
        if keyword_score > 0 and relation_name in {"overdue", "upcoming"}:
            cues.append("the event is semantically related to this routine")

        if not cues:
            return ""
        if location_shift and relation_name in {"within", "upcoming", "overdue", "near"}:
            cues.append("the usual routine location differs from the current location")
        return f"Signal: {timing}; {'; '.join(cues)}"

    def _habit_relevance(self, habit, current_day, current_time, current_location, event_text):
        relation = self._time_relation(
            current_day,
            current_time,
            habit.get("time_window", "always"),
            tolerance=15,
        )
        if relation is None:
            return None

        event_text = event_text or ""
        keyword_score = self._keyword_score(event_text, self._habit_keywords(habit))
        loc_score = self._location_score(current_location, habit.get("location", "anywhere"))
        has_deviation_cue = self._event_has_deviation_cue(event_text)
        has_continuing_cue = self._event_has_continuing_cue(event_text)

        score = 0.0
        match_type = None

        if relation["match"] and loc_score > 0:
            score = 80 + keyword_score * 8 + loc_score * 10
            match_type = "current routine"
        elif keyword_score > 0 and relation["distance"] <= 180:
            score = 70 + keyword_score * 10 - relation["distance"] / 12 + loc_score * 5
            match_type = f"{relation['relation']} semantic routine"
        elif has_deviation_cue and relation["relation"] == "overdue" and relation["distance"] <= 180:
            score = 62 - relation["distance"] / 10 + loc_score * 8 + keyword_score * 8
            match_type = "possibly missed routine"
        elif has_continuing_cue and relation["relation"] == "upcoming" and relation["distance"] <= 120:
            score = 58 - relation["distance"] / 12 + loc_score * 8 + keyword_score * 8
            match_type = "upcoming routine transition"
        elif relation["distance"] <= 30:
            score = 44 - relation["distance"] / 10 + loc_score * 6 + keyword_score * 5
            match_type = "nearby routine transition"
        elif relation["distance"] <= 60 and loc_score > 0:
            score = 48 - relation["distance"] / 8 + loc_score * 8 + keyword_score * 4
            match_type = "nearby same-location routine"
        elif relation["distance"] <= 90 and has_deviation_cue:
            score = 43 - relation["distance"] / 12 + keyword_score * 6 + loc_score * 4
            match_type = "nearby routine candidate"

        if score <= 0 or match_type is None:
            return None

        signal = self._habit_signal(relation, loc_score, keyword_score, event_text)
        if signal:
            score += 10

        return {
            "score": score,
            "relation": relation["relation"],
            "distance": relation["distance"],
            "kind": "habit",
            "match_type": match_type,
            "keyword_score": keyword_score,
            "location_score": loc_score,
            "signal": signal,
        }

    def _habit_fallback_candidates(self, current_day, current_time, current_location, event_text, selected_ids):
        """Return broad routine candidates when strict retrieval misses habits.
        This fallback is deliberately generic: it uses temporal proximity,
        action words, and deviation cues, not benchmark labels or IDs.
        """
        candidates = []
        has_deviation_cue = self._event_has_deviation_cue(event_text)
        has_continuing_cue = self._event_has_continuing_cue(event_text)

        for habit in self.habit_rules:
            habit_id = habit.get("rule_id")
            if habit_id in selected_ids:
                continue
            relation = self._time_relation(
                current_day,
                current_time,
                habit.get("time_window", "always"),
                tolerance=0,
            )
            if relation is None or relation["distance"] is None:
                continue
            keyword_score = self._keyword_score(event_text or "", self._habit_keywords(habit))
            loc_score = self._location_score(current_location, habit.get("location", "anywhere"))

            score = 0.0
            match_type = None
            if keyword_score > 0 and relation["distance"] <= 240:
                score = 55 + keyword_score * 9 - relation["distance"] / 18 + loc_score * 4
                match_type = "semantic routine fallback"
            elif has_deviation_cue and relation["relation"] == "overdue" and relation["distance"] <= 240:
                score = 46 - relation["distance"] / 18 + loc_score * 5
                match_type = "missed routine fallback"
            elif has_continuing_cue and relation["relation"] == "upcoming" and relation["distance"] <= 180:
                score = 42 - relation["distance"] / 20 + loc_score * 4
                match_type = "next routine fallback"
            elif relation["distance"] <= 75 and loc_score > 0:
                score = 36 - relation["distance"] / 15 + loc_score * 4
                match_type = "nearby routine fallback"

            if match_type and score > 0:
                signal = self._habit_signal(relation, loc_score, keyword_score, event_text)
                if signal:
                    score += 8
                candidates.append((score, habit, {
                    "score": score,
                    "relation": relation["relation"],
                    "distance": relation["distance"],
                    "kind": "habit",
                    "match_type": match_type,
                    "keyword_score": keyword_score,
                    "location_score": loc_score,
                    "signal": signal,
                }))

        candidates.sort(key=lambda item: item[0], reverse=True)
        return candidates

    def _format_item(self, src, item, meta):
        item_id = item.get("rule_id", "N/A")
        desc = item.get("description", "")
        window = item.get("time_window", "always")
        loc = item.get("location", "anywhere")
        if src == "Habit":
            match_type = meta.get("match_type", "routine candidate")
            distance = meta.get("distance")
            detail = f"Match: {match_type}"
            if isinstance(distance, (int, float)) and distance:
                detail += f", {int(distance)} min from routine window"
            signal = meta.get("signal")
            if signal:
                detail += f"; {signal}"
            return f"[{src} {item_id}] {desc} (Routine: {window} @ {loc}; {detail}; habits are probabilistic, not hard rules)"
        return f"[{src} {item_id}] {desc} (Scope: {window} @ {loc}; Match: {meta.get('relation', 'relevant')})"

    def get_relevant_context(self, current_day, current_time_str, current_location, current_event=None):
        """Return context lines for a current observation.
        Static rules are action-aware. Habit rules use tolerant retrieval so
        missed, delayed, substituted, or location-shifted routines can still be
        surfaced to the model.
        """
        rule_candidates = []
        for rule in self.static_rules:
            meta = self._rule_relevance(
                rule,
                current_day,
                current_time_str,
                current_location,
                current_event or "",
            )
            if meta:
                rule_candidates.append((meta["score"], rule, meta))

        habit_candidates = []
        for habit in self.habit_rules:
            meta = self._habit_relevance(
                habit,
                current_day,
                current_time_str,
                current_location,
                current_event or "",
            )
            if meta:
                habit_candidates.append((meta["score"], habit, meta))

        habit_candidates.sort(key=lambda item: item[0], reverse=True)
        selected_habit_ids = {item[1].get("rule_id") for item in habit_candidates[:6]}
        if self.habit_rules:
            habit_candidates.extend(
                self._habit_fallback_candidates(
                    current_day,
                    current_time_str,
                    current_location,
                    current_event or "",
                    selected_habit_ids,
                )
            )

        # Keep prompts compact and reduce over-intervention from weak weekly
        # routines. Rules are listed before habits because hard constraints are
        # more important than statistical habits.
        rule_candidates.sort(key=lambda item: item[0], reverse=True)
        habit_candidates.sort(key=lambda item: item[0], reverse=True)

        lines = []
        seen = set()
        for _, rule, meta in rule_candidates[:5]:
            key = ("Rule", rule.get("rule_id"))
            if key in seen:
                continue
            seen.add(key)
            lines.append(self._format_item("Rule", rule, meta))

        for _, habit, meta in habit_candidates[:5]:
            key = ("Habit", habit.get("rule_id"))
            if key in seen:
                continue
            seen.add(key)
            lines.append(self._format_item("Habit", habit, meta))

        return lines


if __name__ == "__main__":
    print("KnowledgeRetriever uses action-aware rules and tolerant habit retrieval.")