infinity-context 0.1.0__py3-none-any.whl

infinity_context_core/application/context_hydration.py

@@ -0,0 +1,329 @@
+"""Hydrate derived candidates through canonical repositories."""
+
+from __future__ import annotations
+
+from dataclasses import replace
+
+from infinity_context_core.application.context_media_time import enrich_context_item_with_media_time
+from infinity_context_core.application.context_policy import (
+    is_context_anchor_visible,
+    is_context_fact_visible,
+    is_graph_fact_visible,
+)
+from infinity_context_core.application.context_snippets import (
+    query_focused_snippet,
+    query_snippet_diagnostics,
+    query_snippet_score_signals,
+    source_refs_with_query_snippet,
+)
+from infinity_context_core.application.context_source_sibling_evidence_rules import (
+    _is_activity_event_duration_source_sibling_strong,
+)
+from infinity_context_core.application.context_source_siblings import (
+    is_direct_source_sibling_obligation_evidence,
+)
+from infinity_context_core.application.document_text import document_chunk_retrieval_text
+from infinity_context_core.application.dto import BuildContextQuery, ContextItem
+from infinity_context_core.application.source_refs import chunk_source_refs
+from infinity_context_core.domain.entities import MemoryChunk
+from infinity_context_core.ports.clock import ClockPort
+from infinity_context_core.ports.unit_of_work import UnitOfWorkFactoryPort
+
+_PREFOCUSED_CHUNK_EVIDENCE_SOURCES = frozenset(
+    {
+        "keyword_aggregation_chunks",
+        "keyword_source_sibling_chunks",
+    }
+)
+
+
+class ContextHydrator:
+    def __init__(
+        self,
+        *,
+        uow_factory: UnitOfWorkFactoryPort,
+        clock: ClockPort | None = None,
+    ) -> None:
+        self._uow_factory = uow_factory
+        self._clock = clock
+
+    async def hydrate_visible_chunks(
+        self,
+        *,
+        chunk_ids: tuple[str, ...],
+        query: BuildContextQuery,
+        memory_scope_ids: tuple[str, ...],
+    ) -> tuple[MemoryChunk, ...]:
+        if not chunk_ids:
+            return ()
+        async with self._uow_factory() as uow:
+            chunks = await uow.chunks.hydrate_visible_chunks(
+                chunk_ids=chunk_ids,
+                space_id=str(query.space_id),
+                memory_scope_ids=memory_scope_ids,
+                thread_id=str(query.thread_id) if query.thread_id else None,
+            )
+        return tuple(chunks)
+
+    async def hydrate_graph_facts(
+        self,
+        *,
+        fact_ids: tuple[str, ...],
+        query: BuildContextQuery,
+        memory_scope_ids: tuple[str, ...],
+    ) -> tuple[tuple[ContextItem, ...], int]:
+        if not fact_ids:
+            return (), 0
+        async with self._uow_factory() as uow:
+            hydrated: list[ContextItem] = []
+            stale_count = 0
+            now = self._clock.now() if self._clock is not None else None
+            facts_by_id = {str(fact.id): fact for fact in await uow.facts.get_by_ids(fact_ids)}
+            for fact_id in fact_ids:
+                fact = facts_by_id.get(fact_id)
+                if fact is not None and is_graph_fact_visible(
+                    fact,
+                    query=query,
+                    memory_scope_ids=memory_scope_ids,
+                    now=now,
+                ):
+                    snippet = query_focused_snippet(query=query.query, text=fact.text)
+                    hydrated.append(
+                        enrich_context_item_with_media_time(
+                            ContextItem(
+                                item_id=str(fact.id),
+                                item_type="fact",
+                                text=fact.text,
+                                score=0.78,
+                                source_refs=source_refs_with_query_snippet(
+                                    fact.source_refs,
+                                    snippet,
+                                ),
+                                diagnostics={
+                                    "memory_scope_id": str(fact.memory_scope_id),
+                                    "retrieval_source": "graph_hydrated",
+                                    "retrieval_sources": ["graph_hydrated"],
+                                    "ranking_reason": (
+                                        "graph candidate resolved to visible active fact"
+                                    ),
+                                    "score_signals": {
+                                        "base_score": 0.78,
+                                        "retrieval_channel": "graph_hydrated",
+                                        "fact_status": fact.status.value,
+                                        **query_snippet_score_signals(snippet),
+                                    },
+                                    "provenance": {
+                                        "retrieval_sources": ["graph_hydrated"],
+                                        "source_ref_count": len(fact.source_refs),
+                                        "fact_status": fact.status.value,
+                                        "fact_version": fact.version,
+                                        **query_snippet_diagnostics(snippet),
+                                    },
+                                    **query_snippet_diagnostics(snippet),
+                                },
+                            ),
+                            query_text=query.query,
+                        )
+                    )
+                else:
+                    stale_count += 1
+        return tuple(hydrated), stale_count
+
+    async def revalidate_visible_items(
+        self,
+        items: tuple[ContextItem, ...],
+        *,
+        query: BuildContextQuery,
+        memory_scope_ids: tuple[str, ...],
+    ) -> tuple[ContextItem, ...]:
+        if not items:
+            return ()
+
+        chunk_ids = tuple(
+            dict.fromkeys(item.item_id for item in items if item.item_type == "chunk")
+        )
+        visible_chunks = {
+            str(chunk.id): chunk
+            for chunk in await self.hydrate_visible_chunks(
+                chunk_ids=chunk_ids,
+                query=query,
+                memory_scope_ids=memory_scope_ids,
+            )
+        }
+        fact_ids = tuple(dict.fromkeys(item.item_id for item in items if item.item_type == "fact"))
+        visible_facts = {}
+        if fact_ids:
+            async with self._uow_factory() as uow:
+                now = self._clock.now() if self._clock is not None else None
+                for fact in await uow.facts.get_by_ids(fact_ids):
+                    if is_context_fact_visible(
+                        fact,
+                        query=query,
+                        memory_scope_ids=memory_scope_ids,
+                        now=now,
+                    ):
+                        visible_facts[str(fact.id)] = fact
+        anchor_ids = tuple(
+            dict.fromkeys(item.item_id for item in items if item.item_type == "anchor")
+        )
+        visible_anchors = {}
+        if anchor_ids:
+            async with self._uow_factory() as uow:
+                now = self._clock.now() if self._clock is not None else None
+                if hasattr(uow.anchors, "get_by_ids"):
+                    anchors = await uow.anchors.get_by_ids(anchor_ids)
+                else:
+                    anchors = []
+                    for anchor_id in anchor_ids:
+                        anchor = await uow.anchors.get_by_id(anchor_id)
+                        if anchor is not None:
+                            anchors.append(anchor)
+                for anchor in anchors:
+                    if is_context_anchor_visible(
+                        anchor,
+                        query=query,
+                        memory_scope_ids=memory_scope_ids,
+                        now=now,
+                    ):
+                        visible_anchors[str(anchor.id)] = anchor
+
+        visible_items: list[ContextItem] = []
+        for item in items:
+            if item.item_type == "fact":
+                fact = visible_facts.get(item.item_id)
+                if fact is None:
+                    continue
+                snippet = query_focused_snippet(query=query.query, text=fact.text)
+                visible_items.append(
+                    enrich_context_item_with_media_time(
+                        ContextItem(
+                            item_id=str(fact.id),
+                            item_type=item.item_type,
+                            text=fact.text,
+                            score=item.score,
+                            source_refs=source_refs_with_query_snippet(
+                                fact.source_refs,
+                                snippet,
+                            ),
+                            is_instruction=item.is_instruction,
+                            diagnostics=item.diagnostics,
+                        ),
+                        query_text=query.query,
+                    )
+                )
+            elif item.item_type == "anchor":
+                anchor = visible_anchors.get(item.item_id)
+                if anchor is None:
+                    continue
+                visible_items.append(
+                    ContextItem(
+                        item_id=str(anchor.id),
+                        item_type=item.item_type,
+                        text=item.text,
+                        score=item.score,
+                        source_refs=anchor.evidence_refs,
+                        is_instruction=item.is_instruction,
+                        diagnostics=item.diagnostics,
+                    )
+                )
+            elif item.item_type == "chunk":
+                chunk = visible_chunks.get(item.item_id)
+                if chunk is None:
+                    continue
+                chunk_text = document_chunk_retrieval_text(
+                    text=chunk.text,
+                    metadata=chunk.metadata,
+                )
+                preserve_existing_evidence = _should_preserve_chunk_item_evidence(item)
+                snippet = (
+                    None
+                    if preserve_existing_evidence
+                    else query_focused_snippet(query=query.query, text=chunk_text)
+                )
+                if preserve_existing_evidence and item.text.strip():
+                    evidence_text = item.text
+                elif snippet is not None:
+                    evidence_text = snippet.text
+                else:
+                    evidence_text = chunk_text
+                visible_items.append(
+                    enrich_context_item_with_media_time(
+                        _with_application_evidence_contract(
+                            ContextItem(
+                                item_id=str(chunk.id),
+                                item_type=item.item_type,
+                                text=evidence_text,
+                                score=item.score,
+                                source_refs=source_refs_with_query_snippet(
+                                    item.source_refs
+                                    if preserve_existing_evidence and item.source_refs
+                                    else chunk_source_refs(
+                                        chunk,
+                                        text_preview=snippet.text if snippet else chunk_text,
+                                    ),
+                                    snippet,
+                                    include_char_range=True,
+                                ),
+                                is_instruction=item.is_instruction,
+                                diagnostics=item.diagnostics,
+                            ),
+                            query_text=query.query,
+                        ),
+                        query_text=query.query,
+                    )
+                )
+        return tuple(visible_items)
+
+
+def _should_preserve_chunk_item_evidence(item: ContextItem) -> bool:
+    """Keep bounded application evidence projections while revalidating canonicals."""
+
+    diagnostics = item.diagnostics if isinstance(item.diagnostics, dict) else {}
+    retrieval_sources = diagnostics.get("retrieval_sources")
+    if isinstance(retrieval_sources, (list, tuple)) and any(
+        source in _PREFOCUSED_CHUNK_EVIDENCE_SOURCES for source in retrieval_sources
+    ):
+        return True
+    return diagnostics.get("retrieval_source") in _PREFOCUSED_CHUNK_EVIDENCE_SOURCES
+
+
+def _with_application_evidence_contract(
+    item: ContextItem,
+    *,
+    query_text: str,
+) -> ContextItem:
+    """Materialize a bounded direct-evidence contract before final ranking."""
+
+    diagnostics = dict(item.diagnostics or {})
+    raw_signals = diagnostics.get("score_signals")
+    signals = dict(raw_signals) if isinstance(raw_signals, dict) else {}
+    if not _positive_signal(signals.get("source_sibling_answer_evidence")):
+        return item
+    expansion_reason = str(signals.get("query_expansion_reason") or "")
+    direct_duration = (
+        expansion_reason == "decomposition_activity_duration"
+        and _is_activity_event_duration_source_sibling_strong(
+            expansion_query=query_text,
+            text=item.text,
+        )
+    )
+    direct_obligation = is_direct_source_sibling_obligation_evidence(
+        query_text=query_text,
+        text=item.text,
+    )
+    signals.pop("application_evidence_contract_tier", None)
+    if expansion_reason == "decomposition_activity_duration" and not direct_duration:
+        diagnostics["score_signals"] = signals
+        return replace(item, diagnostics=diagnostics)
+    if not direct_duration and not direct_obligation:
+        diagnostics["score_signals"] = signals
+        return replace(item, diagnostics=diagnostics)
+    diagnostics["score_signals"] = {
+        "application_evidence_contract_tier": 1,
+        **signals,
+    }
+    return replace(item, diagnostics=diagnostics)
+
+
+def _positive_signal(value: object) -> bool:
+    return isinstance(value, int | float) and not isinstance(value, bool) and value > 0

infinity_context_core/application/context_identity_fact_rerank.py

@@ -0,0 +1,362 @@
+"""Identity fact, object, and emotion rerank policies."""
+
+from __future__ import annotations
+
+import re
+
+from infinity_context_core.application.context_domain_rerank_types import DomainRerankSignal
+from infinity_context_core.application.context_item_purchase_evidence import (
+    has_item_purchase_object_evidence,
+    has_item_purchase_object_marker,
+    has_item_purchase_temporal_or_media_marker,
+    has_item_purchase_verb_marker,
+)
+from infinity_context_core.application.context_relevance import QueryRelevance
+from infinity_context_core.application.context_score_signal_rerank import (
+    score_signal_reason as _score_signal_reason,
+)
+from infinity_context_core.application.dto import ContextItem
+
+_AGE_BIRTHDAY_RERANK_REASONS = frozenset(("age_birthday_bridge",))
+
+_BIRTHPLACE_RERANK_REASONS = frozenset(("birthplace_origin_bridge",))
+
+_BEACH_OR_MOUNTAINS_RERANK_REASONS = frozenset(("beach_or_mountains_inference_bridge",))
+
+_ITEM_PURCHASE_RERANK_REASONS = frozenset(("item_purchase_bridge",))
+
+_SYMBOL_IMPORTANCE_RERANK_REASONS = frozenset(("symbol_importance_bridge",))
+
+_POST_EVENT_EMOTION_RERANK_REASONS = frozenset(("post_event_emotion_bridge",))
+
+_AGE_BIRTHDAY_EXACT_RE = re.compile(
+    r"\b(?:born\s+in\s+\d{4}|born\s+on\b|date\s+of\s+birth|birthdate|"
+    r"birthday|age\s+(?:is\s+)?\d{1,3}|\d{1,3}\s+years?\s+old)\b|"
+    r"\b(?:родил(?:ся|ась|ись)\s+в\s+\d{4}|дата\s+рождения|"
+    r"день\s+рождения|возраст\s+\d{1,3}|\d{1,3}\s+лет)\b",
+    re.IGNORECASE,
+)
+
+_AGE_BIRTHDAY_WEAK_OLD_RE = re.compile(
+    r"\bold\s+(?:friend|plan|state|policy|note|home|school|job)\b|"
+    r"\b(?:стар(?:ый|ая|ое|ые)\s+(?:друг|план|политик\w*|заметк\w*))\b",
+    re.IGNORECASE,
+)
+
+_BIRTHPLACE_QUERY_RE = re.compile(
+    r"\bwhere\b(?=.{0,80}\bborn\b)|\bborn\b(?=.{0,80}\bwhere\b)|"
+    r"\b(?:где|откуда)\b(?=.{0,80}\bродил)",
+    re.IGNORECASE | re.DOTALL,
+)
+
+_BIRTHPLACE_EXACT_RE = re.compile(
+    r"\b(?:birthplace|born\s+in\s+(?!\d{4}\b)[A-Z][A-Za-z]+(?:\s+[A-Z][A-Za-z]+)?|"
+    r"born\s+near\s+[A-Z][A-Za-z]+|home\s+country\s+is\s+[A-Z][A-Za-z]+)\b|"
+    r"\b(?:место\s+рождения|родил(?:ся|ась|ись)\s+в\s+(?!\d{4}\b)[А-ЯЁA-Z]"
+    r"[\wА-Яа-яЁё-]+)\b",
+    re.IGNORECASE,
+)
+
+_BIRTHPLACE_BIRTHDATE_NOISE_RE = re.compile(
+    r"\bborn\s+in\s+\d{4}\b|\b(?:birthday|date\s+of\s+birth|birthdate)\b|"
+    r"\bродил(?:ся|ась|ись)\s+в\s+\d{4}\b|\b(?:дата\s+рождения|день\s+рождения)\b",
+    re.IGNORECASE,
+)
+
+_BEACH_OR_MOUNTAINS_QUERY_RE = re.compile(
+    r"\b(?:beach|beaches|ocean|shore|coast|mountain|mountains)\b"
+    r"(?=.{0,120}\b(?:close|near|nearby|live|lives|living|by|next\s+to)\b)|"
+    r"\b(?:close|near|nearby|live|lives|living|by|next\s+to)\b"
+    r"(?=.{0,120}\b(?:beach|beaches|ocean|shore|coast|mountain|mountains)\b)",
+    re.IGNORECASE | re.DOTALL,
+)
+
+_BEACH_OR_MOUNTAINS_DOMAIN_RE = re.compile(
+    r"\b(?:beach|beaches|ocean|shore|coast|coastal|sailboat|sand|sunset|"
+    r"mountain|mountains|trail|hiking|hike)\b",
+    re.IGNORECASE,
+)
+
+_BEACH_OR_MOUNTAINS_PROXIMITY_RE = re.compile(
+    r"\b(?:close|near|nearby|by|next\s+to|weekly\s+walks?|walks?|goes?\s+on\s+"
+    r"walks?|lives?\s+close|lives?\s+near|from\s+home|local)\b",
+    re.IGNORECASE,
+)
+
+_BEACH_OR_MOUNTAINS_TOPIC_ONLY_RE = re.compile(
+    r"\b(?:whether|sounded\s+nice|someday|maybe|vacation|wallpaper|poster|"
+    r"preference|would\s+like|dream(?:ed)?\s+of)\b"
+    r"(?=.{0,120}\b(?:beach|beaches|ocean|mountains?)\b)|"
+    r"\b(?:beach|beaches|ocean|mountains?)\b"
+    r"(?=.{0,120}\b(?:whether|sounded\s+nice|someday|maybe|vacation|"
+    r"wallpaper|poster|preference|would\s+like|dream(?:ed)?\s+of)\b)",
+    re.IGNORECASE | re.DOTALL,
+)
+
+_SYMBOL_IMPORTANCE_EXACT_RE = re.compile(
+    r"\b(?:symboli[sz](?:e|es|ed|ing)|represents?|meaning|means|stands?\s+for|"
+    r"important|reminds?\s+(?:me|her|him|them)\s+of|pride|freedom|courage|"
+    r"resilience|identity|acceptance)\b|"
+    r"\b(?:символизир\w*|значит|значение|важн\w*|напомина\w*|гордост\w*|"
+    r"свобод\w*|смелост\w*|идентичност\w*|приняти\w*)\b",
+    re.IGNORECASE,
+)
+
+_SYMBOL_IMPORTANCE_MEANING_RE = re.compile(
+    r"\b(?:symboli[sz](?:e|es|ed|ing)|represents?|meaning|means|stands?\s+for|"
+    r"reminds?\s+(?:me|her|him|them)\s+of|pride|freedom|courage|resilience|"
+    r"identity|acceptance)\b|"
+    r"\b(?:символизир\w*|значит|значение|напомина\w*|гордост\w*|свобод\w*|"
+    r"смелост\w*|идентичност\w*|приняти\w*)\b",
+    re.IGNORECASE,
+)
+
+_SYMBOL_IMPORTANCE_OBJECT_RE = re.compile(
+    r"\b(?:rainbow\s+flag|flag|mural|eagle|pendant|necklace|"
+    r"transgender\s+symbol|cross|heart|symbol|symbols)\b|"
+    r"\b(?:радужн\w+\s+флаг|флаг|орел|орёл|кулон|ожерелье|крест|"
+    r"сердце|символ\w*)\b",
+    re.IGNORECASE,
+)
+
+_SYMBOL_IMPORTANCE_PERSONAL_OBJECT_RE = re.compile(
+    r"\b(?:pendant|necklace)\b(?=.{0,100}\b(?:symbol|cross|heart|transgender)\b)|"
+    r"\b(?:symbol|cross|heart|transgender)\b(?=.{0,100}\b(?:pendant|necklace)\b)",
+    re.IGNORECASE | re.DOTALL,
+)
+
+_SYMBOL_IMPORTANCE_VISUAL_OBJECT_RE = re.compile(
+    r"\b(?:visual\s+query|image\s+caption|caption)\b"
+    r"(?=.{0,140}\b(?:pendant|necklace)\b)"
+    r"(?=.{0,140}\b(?:transgender\s+symbol|cross|heart|symbol)\b)",
+    re.IGNORECASE | re.DOTALL,
+)
+
+_SYMBOL_IMPORTANCE_TECHNICAL_NOISE_RE = re.compile(
+    r"\b(?:unicode|currency|math(?:ematical)?|keyboard|font|icon|icons|"
+    r"svg|css|ui|interface|variable|operator|code|programming)\b",
+    re.IGNORECASE,
+)
+
+_POST_EVENT_EMOTION_EXACT_RE = re.compile(
+    r"\b(?:felt|feel|feeling|grateful|thankful|relieved|lucky|scared|"
+    r"freaked|inspired|proud|happy|sad|upset|awe|means?\s+the\s+world|"
+    r"meaningful)\b",
+    re.IGNORECASE,
+)
+
+_POST_EVENT_FAMILY_APPRECIATION_RE = re.compile(
+    r"\b(?:i|i'm|i've|me|my|we|our)\b"
+    r"(?=.{0,220}\b(?:family|fam|loved\s+ones|them|they)\b)"
+    r"(?=.{0,180}\b(?:super\s+important|important\s+to\s+me|"
+    r"mean\s+the\s+world|means\s+the\s+world|need\s+them|"
+    r"thankful\s+to\s+have|grateful\s+to\s+have|cherish|"
+    r"biggest\s+motivation|support|rock)\b)|"
+    r"\b(?:super\s+important|important\s+to\s+me|mean\s+the\s+world|"
+    r"means\s+the\s+world|need\s+them|thankful\s+to\s+have|"
+    r"grateful\s+to\s+have|cherish|biggest\s+motivation|support|rock)\b"
+    r"(?=.{0,180}\b(?:family|fam|loved\s+ones|them|they)\b)"
+    r"(?=.{0,220}\b(?:i|i'm|i've|me|my|we|our)\b)",
+    re.IGNORECASE | re.DOTALL,
+)
+
+_POST_EVENT_EMOTION_EVENT_ONLY_RE = re.compile(
+    r"\b(?:accident|roadtrip|trip|event|happened|mentioned|talked|family)\b",
+    re.IGNORECASE,
+)
+
+def age_birthday_rerank_signal(
+    *,
+    query: str = "",
+    query_reason: str,
+    item: ContextItem,
+    relevance: QueryRelevance,
+) -> DomainRerankSignal:
+    if not _is_age_birthday_candidate(query_reason=query_reason, item=item):
+        return DomainRerankSignal()
+    if (
+        _BIRTHPLACE_QUERY_RE.search(query) is not None
+        and _AGE_BIRTHDAY_EXACT_RE.search(item.text) is not None
+    ):
+        return DomainRerankSignal(
+            penalty=0.052,
+            reason="age_birthday_birthplace_query_noise",
+        )
+    if _AGE_BIRTHDAY_EXACT_RE.search(item.text) is not None:
+        return DomainRerankSignal(boost=0.026, reason="age_birthday_exact_evidence")
+    if (
+        _AGE_BIRTHDAY_WEAK_OLD_RE.search(item.text) is not None
+        or relevance.distinctive_term_hits < 4
+    ):
+        return DomainRerankSignal(penalty=0.05, reason="age_birthday_weak_evidence")
+    return DomainRerankSignal()
+
+def birthplace_rerank_signal(
+    *,
+    query_reason: str,
+    item: ContextItem,
+    relevance: QueryRelevance,
+) -> DomainRerankSignal:
+    if not _is_birthplace_candidate(query_reason=query_reason, item=item):
+        return DomainRerankSignal()
+    if _BIRTHPLACE_EXACT_RE.search(item.text) is not None:
+        return DomainRerankSignal(boost=0.026, reason="birthplace_exact_evidence")
+    if (
+        _BIRTHPLACE_BIRTHDATE_NOISE_RE.search(item.text) is not None
+        or relevance.distinctive_term_hits < 4
+    ):
+        return DomainRerankSignal(penalty=0.052, reason="birthplace_birthdate_noise")
+    return DomainRerankSignal()
+
+def beach_or_mountains_rerank_signal(
+    *,
+    query: str,
+    query_reason: str,
+    item: ContextItem,
+    relevance: QueryRelevance,
+) -> DomainRerankSignal:
+    if not _is_beach_or_mountains_candidate(
+        query=query,
+        query_reason=query_reason,
+        item=item,
+    ):
+        return DomainRerankSignal()
+    has_domain = _BEACH_OR_MOUNTAINS_DOMAIN_RE.search(item.text) is not None
+    has_proximity = _BEACH_OR_MOUNTAINS_PROXIMITY_RE.search(item.text) is not None
+    if has_domain and has_proximity:
+        return DomainRerankSignal(
+            boost=0.026,
+            reason="beach_mountains_proximity_evidence",
+        )
+    if (
+        _BEACH_OR_MOUNTAINS_TOPIC_ONLY_RE.search(item.text) is not None
+        or not has_domain
+        or relevance.distinctive_term_hits < 3
+    ):
+        return DomainRerankSignal(
+            penalty=0.038,
+            reason="beach_mountains_topic_only_noise",
+        )
+    return DomainRerankSignal()
+
+def item_purchase_rerank_signal(
+    *,
+    query_reason: str,
+    item: ContextItem,
+    relevance: QueryRelevance,
+) -> DomainRerankSignal:
+    if not _is_item_purchase_candidate(query_reason=query_reason, item=item):
+        return DomainRerankSignal()
+    if has_item_purchase_object_evidence(item.text):
+        return DomainRerankSignal(
+            boost=0.055,
+            reason="item_purchase_object_evidence",
+            rank_signal_key="item_purchase_object_evidence",
+            rank_signal=3.0,
+        )
+    if (
+        has_item_purchase_temporal_or_media_marker(item.text)
+        or not has_item_purchase_object_marker(item.text)
+        or not has_item_purchase_verb_marker(item.text)
+        or relevance.distinctive_term_hits < 4
+    ):
+        return DomainRerankSignal(
+            penalty=0.11,
+            reason="item_purchase_temporal_weak_evidence",
+        )
+    return DomainRerankSignal()
+
+def symbol_importance_rerank_signal(
+    *,
+    query_reason: str,
+    item: ContextItem,
+    relevance: QueryRelevance,
+) -> DomainRerankSignal:
+    if not _is_symbol_importance_candidate(query_reason=query_reason, item=item):
+        return DomainRerankSignal()
+    has_symbol_object = _SYMBOL_IMPORTANCE_OBJECT_RE.search(item.text) is not None
+    has_personal_object = _SYMBOL_IMPORTANCE_PERSONAL_OBJECT_RE.search(item.text) is not None
+    if _SYMBOL_IMPORTANCE_TECHNICAL_NOISE_RE.search(item.text) is not None:
+        return DomainRerankSignal(penalty=0.042, reason="symbol_importance_weak_evidence")
+    if has_personal_object and _SYMBOL_IMPORTANCE_VISUAL_OBJECT_RE.search(item.text):
+        return DomainRerankSignal(
+            boost=0.036,
+            reason="symbol_importance_visual_object",
+            rank_signal_key="symbol_importance_visual_evidence",
+            rank_signal=3.0,
+        )
+    if has_symbol_object and _SYMBOL_IMPORTANCE_EXACT_RE.search(item.text) is not None:
+        return DomainRerankSignal(
+            boost=0.028,
+            reason="symbol_importance_exact_evidence",
+            rank_signal_key="symbol_importance_visual_evidence",
+            rank_signal=1.0 if has_personal_object else 0.0,
+        )
+    if has_personal_object:
+        return DomainRerankSignal(boost=0.02, reason="symbol_importance_personal_object")
+    if (
+        _SYMBOL_IMPORTANCE_TECHNICAL_NOISE_RE.search(item.text) is not None
+        or not has_symbol_object
+        or relevance.distinctive_term_hits < 3
+    ):
+        return DomainRerankSignal(penalty=0.042, reason="symbol_importance_weak_evidence")
+    return DomainRerankSignal()
+
+def post_event_emotion_rerank_signal(
+    *,
+    query_reason: str,
+    item: ContextItem,
+    relevance: QueryRelevance,
+) -> DomainRerankSignal:
+    if not _is_post_event_emotion_candidate(query_reason=query_reason, item=item):
+        return DomainRerankSignal()
+    if _POST_EVENT_FAMILY_APPRECIATION_RE.search(item.text) is not None:
+        return DomainRerankSignal(
+            boost=0.052,
+            reason="post_event_family_appreciation_evidence",
+        )
+    if _POST_EVENT_EMOTION_EXACT_RE.search(item.text) is not None:
+        return DomainRerankSignal(boost=0.026, reason="post_event_emotion_exact_evidence")
+    if (
+        _POST_EVENT_EMOTION_EVENT_ONLY_RE.search(item.text) is not None
+        or relevance.distinctive_term_hits < 4
+    ):
+        return DomainRerankSignal(penalty=0.038, reason="post_event_emotion_weak_evidence")
+    return DomainRerankSignal()
+
+def _is_age_birthday_candidate(*, query_reason: str, item: ContextItem) -> bool:
+    if query_reason in _AGE_BIRTHDAY_RERANK_REASONS:
+        return True
+    return _score_signal_reason(item) in _AGE_BIRTHDAY_RERANK_REASONS
+
+def _is_birthplace_candidate(*, query_reason: str, item: ContextItem) -> bool:
+    if query_reason in _BIRTHPLACE_RERANK_REASONS:
+        return True
+    return _score_signal_reason(item) in _BIRTHPLACE_RERANK_REASONS
+
+def _is_beach_or_mountains_candidate(
+    *,
+    query: str,
+    query_reason: str,
+    item: ContextItem,
+) -> bool:
+    if _BEACH_OR_MOUNTAINS_QUERY_RE.search(query) is not None:
+        return True
+    if query_reason in _BEACH_OR_MOUNTAINS_RERANK_REASONS:
+        return True
+    return _score_signal_reason(item) in _BEACH_OR_MOUNTAINS_RERANK_REASONS
+
+def _is_symbol_importance_candidate(*, query_reason: str, item: ContextItem) -> bool:
+    if query_reason in _SYMBOL_IMPORTANCE_RERANK_REASONS:
+        return True
+    return _score_signal_reason(item) in _SYMBOL_IMPORTANCE_RERANK_REASONS
+
+def _is_item_purchase_candidate(*, query_reason: str, item: ContextItem) -> bool:
+    if query_reason in _ITEM_PURCHASE_RERANK_REASONS:
+        return True
+    return _score_signal_reason(item) in _ITEM_PURCHASE_RERANK_REASONS
+
+def _is_post_event_emotion_candidate(*, query_reason: str, item: ContextItem) -> bool:
+    if query_reason in _POST_EVENT_EMOTION_RERANK_REASONS:
+        return True
+    return _score_signal_reason(item) in _POST_EVENT_EMOTION_RERANK_REASONS