Fix: Unprecission

.env.example

@@ -111,6 +111,7 @@ PLACES_CHAT_AMBIGUITY_DELTA=0.15
 PLACES_CHAT_HYPOTHESIS_MIN_CONFIDENCE=0.60
 PLACES_CHAT_HYPOTHESIS_MAX_GAP=0.15
 PLACES_CHAT_DEFAULT_RADIUS_METERS=5000
+PLACES_CHAT_MAX_AUTO_RADIUS_METERS=50000
 PLACES_CHAT_RANKING_VERSION=places-chat-v2
 PLACES_CHAT_INTENT_PROVIDER=deterministic
 # Required only when PLACES_CHAT_INTENT_PROVIDER=bert. The model must expose

README.md

@@ -205,6 +205,14 @@ Las ambiguedades que cambiarian los resultados devuelven `action=clarification`
 `state_patch` con `pending_clarification`; el siguiente turno puede resolverlo con frases
 como "la primera opcion" o "la segunda, cerca de mi".
 
+Los turnos puramente sociales (`hola`, `ola`, `gracias`, despedidas y confirmaciones)
+se responden sin ejecutar clasificacion, filtro geografico ni retrieval. Un saludo que
+tambien contiene una busqueda, por ejemplo `hola, recomiendame una cafeteria`, conserva
+la intencion de lugares. Las hipotesis de una aclaracion solo se muestran cuando superan
+el umbral semantico y cuentan con candidatos locales suficientes; sus IDs siguen siendo
+tecnicos, pero sus etiquetas fallback son legibles y la localizacion final pertenece a
+la API principal.
+
 El chat no exige que el usuario nombre siempre una categoria. Puede habilitar un BERT
 fine-tuneado de token classification para extraer valores abiertos de categoria,
 preferencia, exclusion, ubicacion, referencia y radio. Esos textos se alinean despues
@@ -222,6 +230,16 @@ del ranking cuando el proveedor de lugares cercanos esta configurado. El flag in
 `PLACES_CHAT_V2_ENABLED=false` y debe activarse despues de desplegar en Go tanto el proxy
 de chat como `/api/v1/internal/places/resolve-anchor`.
 
+Un radio implicito inicia con `PLACES_CHAT_DEFAULT_RADIUS_METERS` y, si no produce
+lugares o evidencia de la categoria, puede ampliarse hasta
+`PLACES_CHAT_MAX_AUTO_RADIUS_METERS`. Un radio escrito por el usuario nunca se amplia.
+El radio efectivo queda en `location_directive.radius_meters`; los `place_ids` usados
+para cada consulta son transitorios y no se persisten en `state_patch`.
+
+Los ajustes que pertenecen a otros repositorios se documentan en
+`docs/cambios_api_principal_chat_lugares.md` y
+`docs/cambios_app_movil_chat_lugares.md`; no se implementan desde este servicio.
+
 ## SQL RDS
 
 Contrato de referencia:

app/modules/places/api/dependencies.py

@@ -237,4 +237,7 @@ def get_chat_place_recommendations_use_case() -> ChatPlaceRecommendationsUseCase
             else None
         ),
         default_radius_meters=settings.places_chat_default_radius_meters,
+        maximum_auto_radius_meters=(
+            settings.places_chat_max_auto_radius_meters
+        ),
     )

app/modules/places/api/internal_chat_schemas.py

@@ -333,5 +333,12 @@ def internal_chat_result_to_schema(
             "category_source": result.category_source,
             "raw_category_phrase": result.raw_category_phrase,
             "intent_model_version": result.intent_model_version,
+            "input_kind": (
+                "non_search"
+                if "non_search_input" in result.unresolved
+                else "place_search"
+            ),
+            "effective_radius_meters": directive.radius_meters,
+            "radius_is_strict": directive.strict_radius,
         },
     )

app/modules/places/application/use_cases/chat_place_recommendations.py

@@ -86,6 +86,7 @@ class ChatPlaceRecommendationsUseCase:
         maximum_hypothesis_gap: float = 0.15,
         nearby_place_provider: NearbyPlaceProvider | None = None,
         default_radius_meters: int = 5_000,
+        maximum_auto_radius_meters: int = 50_000,
     ) -> None:
         if not 0.0 <= minimum_intent_confidence <= 1.0:
             raise ValueError("minimum_intent_confidence must be between zero and one")
@@ -97,6 +98,11 @@ class ChatPlaceRecommendationsUseCase:
             raise ValueError("maximum_hypothesis_gap must be between zero and one")
         if not 1 <= default_radius_meters <= 50_000:
             raise ValueError("default_radius_meters must be between 1 and 50000")
+        if not default_radius_meters <= maximum_auto_radius_meters <= 50_000:
+            raise ValueError(
+                "maximum_auto_radius_meters must be between the default radius "
+                "and 50000"
+            )
         self._intent_parser = intent_parser
         self._anchor_resolver = anchor_resolver
         self._retriever = retriever
@@ -111,6 +117,7 @@ class ChatPlaceRecommendationsUseCase:
         self._maximum_hypothesis_gap = maximum_hypothesis_gap
         self._nearby_place_provider = nearby_place_provider
         self._default_radius_meters = default_radius_meters
+        self._maximum_auto_radius_meters = maximum_auto_radius_meters
 
     async def execute(
         self,
@@ -136,6 +143,19 @@ class ChatPlaceRecommendationsUseCase:
             has_user_location,
             clarification_choice,
         )
+        if intent.action == "no_match":
+            return self._result(
+                action="no_match",
+                message=(
+                    intent.response_message
+                    or "Cuéntame qué tipo de lugar o actividad buscas."
+                ),
+                intent=intent,
+                directive=self._location_directive(intent),
+                candidates=(),
+                unresolved=intent.unresolved,
+                trace_id=trace_id,
+            )
         if intent.action == "clarification":
             return self._clarification_result(intent, trace_id)
 
@@ -175,27 +195,48 @@ class ChatPlaceRecommendationsUseCase:
             if directive.source == "user_current"
             else intent.location.longitude
         )
+        can_auto_expand_radius = False
         if (
             directive.source in {"user_current", "explicit_anchor", "state_anchor"}
             and self._nearby_place_provider is not None
             and geographic_latitude is not None
             and geographic_longitude is not None
         ):
+            allows_auto_expansion = (
+                directive.radius_meters is None and not directive.strict_radius
+            )
+            effective_radius = (
+                directive.radius_meters or self._default_radius_meters
+            )
             nearby_ids = await self._nearby_place_provider.get_nearby_place_ids(
                 latitude=geographic_latitude,
                 longitude=geographic_longitude,
-                radius_meters=(
-                    directive.radius_meters or self._default_radius_meters
-                ),
+                radius_meters=effective_radius,
             )
+            if (
+                not nearby_ids
+                and allows_auto_expansion
+                and effective_radius < self._maximum_auto_radius_meters
+            ):
+                effective_radius = self._maximum_auto_radius_meters
+                nearby_ids = await self._nearby_place_provider.get_nearby_place_ids(
+                    latitude=geographic_latitude,
+                    longitude=geographic_longitude,
+                    radius_meters=effective_radius,
+                )
+            directive = replace(directive, radius_meters=effective_radius)
             if not nearby_ids:
                 return self._result(
                     action="no_match",
-                    message="No encontre lugares cercanos dentro del radio solicitado.",
+                    message=(
+                        "No encontré lugares disponibles cerca de tu ubicación "
+                        f"dentro de {self._distance_label(effective_radius)}. "
+                        "Puedes indicar otra zona o intentarlo con un plan distinto."
+                    ),
                     intent=intent,
                     directive=directive,
                     candidates=(),
-                    unresolved=(),
+                    unresolved=("nearby_catalog_empty",),
                     trace_id=trace_id,
                 )
             intent = replace(
@@ -205,6 +246,10 @@ class ChatPlaceRecommendationsUseCase:
                     "place_ids": tuple(sorted(nearby_ids)),
                 },
             )
+            can_auto_expand_radius = (
+                allows_auto_expansion
+                and effective_radius < self._maximum_auto_radius_meters
+            )
 
         if intent.confidence < self._minimum_intent_confidence:
             evidence_candidates = tuple(
@@ -214,7 +259,10 @@ class ChatPlaceRecommendationsUseCase:
                 )
             )
             pending = (
-                self._category_clarification_from_hypotheses(intent)
+                self._category_clarification_from_hypotheses(
+                    intent,
+                    evidence_candidates,
+                )
                 or self._category_clarification_from_candidates(evidence_candidates)
             )
             if pending is not None:
@@ -223,7 +271,11 @@ class ChatPlaceRecommendationsUseCase:
                     pending,
                     unresolved=("intent_confidence",),
                 )
-                return self._clarification_result(clarified, trace_id)
+                return self._clarification_result(
+                    clarified,
+                    trace_id,
+                    directive=directive,
+                )
 
             sufficient_candidates = tuple(
                 candidate
@@ -277,12 +329,80 @@ class ChatPlaceRecommendationsUseCase:
         candidates = tuple(
             await self._retriever.retrieve(intent=intent, limit=candidate_limit)
         )
+        category_supported = self._has_category_supported_candidate(
+            intent,
+            candidates,
+        )
+        if (
+            can_auto_expand_radius
+            and (not candidates or (intent.target_category and not category_supported))
+            and self._nearby_place_provider is not None
+            and geographic_latitude is not None
+            and geographic_longitude is not None
+        ):
+            expanded_radius = self._maximum_auto_radius_meters
+            expanded_ids = await self._nearby_place_provider.get_nearby_place_ids(
+                latitude=geographic_latitude,
+                longitude=geographic_longitude,
+                radius_meters=expanded_radius,
+            )
+            directive = replace(directive, radius_meters=expanded_radius)
+            if expanded_ids:
+                expanded_intent = replace(
+                    intent,
+                    hard_filters={
+                        **intent.hard_filters,
+                        "place_ids": tuple(sorted(expanded_ids)),
+                    },
+                )
+                expanded_candidates = tuple(
+                    await self._retriever.retrieve(
+                        intent=expanded_intent,
+                        limit=candidate_limit,
+                    )
+                )
+                expanded_category_supported = (
+                    self._has_category_supported_candidate(
+                        expanded_intent,
+                        expanded_candidates,
+                    )
+                )
+                if (
+                    not candidates
+                    or expanded_category_supported
+                    or not intent.target_category
+                ):
+                    intent = expanded_intent
+                    candidates = expanded_candidates
+                    category_supported = expanded_category_supported
+
+        if intent.target_category and candidates and not category_supported:
+            category_label = self._display_category(intent.target_category)
+            radius_label = (
+                f" dentro de {self._distance_label(directive.radius_meters)}"
+                if directive.radius_meters is not None
+                else ""
+            )
+            return self._result(
+                action="no_match",
+                message=(
+                    f"No encontré opciones disponibles de {category_label}"
+                    f"{radius_label}. Prueba con otra categoría o indícame "
+                    "una zona diferente."
+                ),
+                intent=intent,
+                directive=directive,
+                candidates=(),
+                unresolved=("category_availability",),
+                trace_id=trace_id,
+            )
         if not candidates:
             return self._result(
                 action="no_match",
                 message=(
-                    "No encontre opciones suficientemente relacionadas con lo que buscas. "
-                    "Puedes cambiar alguna preferencia o pedirme otro tipo de lugar."
+                    "No encontré opciones suficientemente relacionadas con lo que "
+                    "buscas. Puedes cambiar alguna preferencia o pedirme otro tipo "
+                    "de lugar."
                 ),
                 intent=intent,
                 directive=directive,
@@ -595,21 +715,47 @@ class ChatPlaceRecommendationsUseCase:
     def _category_clarification_from_hypotheses(
         self,
         intent: ParsedPlaceChatIntent,
+        candidates: Sequence[PlaceChatCandidate],
     ) -> PendingClarification | None:
         scores: dict[str, float] = {}
         labels: dict[str, str] = {}
+        category_values: dict[str, tuple[str, ...]] = {}
         if intent.target_category:
             scores[intent.target_category] = intent.confidence
+            category_values[intent.target_category] = tuple(
+                dict.fromkeys(
+                    (
+                        intent.target_category,
+                        *intent.category_values,
+                    )
+                )
+            )
 
         for alternative in intent.alternatives:
             key = alternative.key.strip()
             if not key or key in _NON_CATEGORY_ALTERNATIVE_KEYS:
                 continue
             scores[key] = max(scores.get(key, 0.0), alternative.confidence)
+            category_values[key] = tuple(
+                dict.fromkeys((key, *alternative.category_values))
+            )
             if alternative.description.strip():
                 labels[key] = alternative.description.strip()
 
-        ranked = sorted(scores.items(), key=lambda item: (-item[1], item[0]))
+        ranked = sorted(
+            (
+                (category, score)
+                for category, score in scores.items()
+                if any(
+                    self._candidate_supports_category_values(
+                        candidate,
+                        category_values.get(category, (category,)),
+                    )
+                    for candidate in candidates
+                )
+            ),
+            key=lambda item: (-item[1], item[0]),
+        )
         if not ranked or ranked[0][1] < self._minimum_hypothesis_confidence:
             return None
         top_score = ranked[0][1]
@@ -633,6 +779,7 @@ class ChatPlaceRecommendationsUseCase:
     ) -> PendingClarification | None:
         counts: dict[str, int] = {}
         best_scores: dict[str, float] = {}
+        display_labels: dict[str, str] = {}
         for candidate in candidates:
             diagnostics = candidate.metadata.get("retrieval_diagnostics", {})
             if diagnostics.get("meets_minimum_content_score") is False:
@@ -645,6 +792,9 @@ class ChatPlaceRecommendationsUseCase:
                 best_scores.get(category, 0.0),
                 candidate.content_score,
             )
+            source_label = candidate.metadata.get("category_label")
+            if isinstance(source_label, str) and source_label.strip():
+                display_labels[category] = source_label.strip()
         ordered = tuple(
             category
             for category, _ in sorted(
@@ -656,7 +806,7 @@ class ChatPlaceRecommendationsUseCase:
             return None
         labels = {
             category: (
-                f"{category.replace('_', ' ').title()} "
+                f"{display_labels.get(category) or _display_category(category)} "
                 f"({counts[category]} opciones encontradas)"
             )
             for category in ordered
@@ -781,6 +931,57 @@ class ChatPlaceRecommendationsUseCase:
             return bool(diagnostics["meets_minimum_content_score"])
         return candidate.content_score > 0.0
 
+    @classmethod
+    def _candidate_supports_category_values(
+        cls,
+        candidate: PlaceChatCandidate,
+        values: Sequence[str],
+    ) -> bool:
+        if not cls._meets_content_threshold(candidate):
+            return False
+        supported = {
+            normalized
+            for value in values
+            if (normalized := _normalized_category(value))
+        }
+        return _candidate_has_category_evidence(candidate, supported)
+
+    @staticmethod
+    def _has_category_supported_candidate(
+        intent: ParsedPlaceChatIntent,
+        candidates: Sequence[PlaceChatCandidate],
+    ) -> bool:
+        if not intent.target_category:
+            return True
+
+        requested_values = {
+            normalized
+            for value in (
+                intent.target_category,
+                *intent.category_values,
+                *intent.compatible_category_values,
+            )
+            if (normalized := _normalized_category(value))
+        }
+        for candidate in candidates:
+            diagnostics = candidate.metadata.get("retrieval_diagnostics", {})
+            category_match = diagnostics.get("category_match")
+            if category_match not in {None, "none", "not_requested"}:
+                return True
+            if _candidate_has_category_evidence(candidate, requested_values):
+                return True
+        return False
+
+    @staticmethod
+    def _display_category(value: str) -> str:
+        return _display_category(value).casefold()
+
+    @staticmethod
+    def _distance_label(radius_meters: int) -> str:
+        if radius_meters >= 1_000 and radius_meters % 1_000 == 0:
+            return f"{radius_meters // 1_000} km"
+        return f"{radius_meters} m"
+
     @staticmethod
     def _candidate_context(candidate: PlaceChatCandidate) -> dict[str, Any]:
         return {
@@ -798,6 +999,8 @@ class ChatPlaceRecommendationsUseCase:
         self,
         intent: ParsedPlaceChatIntent,
         trace_id: str,
+        *,
+        directive: PlaceChatLocationDirective | None = None,
     ) -> ChatPlaceRecommendationsResult:
         if intent.clarification is None:
             raise RuntimeError("clarification action requires structured options")
@@ -805,7 +1008,7 @@ class ChatPlaceRecommendationsUseCase:
             action="clarification",
             message=intent.clarification.prompt,
             intent=intent,
-            directive=self._location_directive(intent),
+            directive=directive or self._location_directive(intent),
             candidates=(),
             unresolved=intent.unresolved,
             trace_id=trace_id,
@@ -819,6 +1022,12 @@ class ChatPlaceRecommendationsUseCase:
     ) -> ParsedPlaceChatIntent:
         clarification = to_public_clarification(pending)
         patch = intent.state_patch
+        source_hard_filters = (
+            patch.hard_filters
+            if patch.hard_filters is not None
+            else intent.hard_filters
+        )
+        persistent_hard_filters = _persistent_hard_filters(source_hard_filters)
         return replace(
             intent,
             action="clarification",
@@ -829,9 +1038,9 @@ class ChatPlaceRecommendationsUseCase:
                     patch.target_category or intent.target_category
                 ),
                 hard_filters=(
-                    patch.hard_filters
-                    if patch.hard_filters is not None
-                    else (dict(intent.hard_filters) if intent.hard_filters else None)
+                    persistent_hard_filters
+                    if patch.hard_filters is not None or persistent_hard_filters
+                    else None
                 ),
                 soft_preferences=(
                     patch.soft_preferences
@@ -924,6 +1133,79 @@ class ChatPlaceRecommendationsUseCase:
         )
 
 
+def _persistent_hard_filters(filters: dict[str, Any] | None) -> dict[str, Any]:
+    if not filters:
+        return {}
+    return {
+        key: value
+        for key, value in filters.items()
+        if key != "place_ids"
+    }
+
+
+def _normalized_category(value: str | None) -> str:
+    if not value:
+        return ""
+    return " ".join(value.replace("_", " ").replace("-", " ").casefold().split())
+
+
+def _display_category(value: str) -> str:
+    humanized = " ".join(value.replace("_", " ").replace("-", " ").split())
+    if not humanized:
+        return "Lugar"
+    return humanized[:1].upper() + humanized[1:]
+
+
+def _candidate_category_values(candidate: PlaceChatCandidate) -> set[str]:
+    values: set[str] = set()
+    for raw_value in (
+        candidate.category,
+        candidate.metadata.get("category_label"),
+        candidate.metadata.get("tags"),
+        candidate.metadata.get("tag_names"),
+    ):
+        for value in _text_values(raw_value):
+            normalized = _normalized_category(value)
+            if normalized:
+                values.add(normalized)
+    return values
+
+
+def _candidate_has_category_evidence(
+    candidate: PlaceChatCandidate,
+    requested_values: set[str],
+) -> bool:
+    if not requested_values:
+        return False
+    if _candidate_category_values(candidate) & requested_values:
+        return True
+
+    raw_evidence: list[str] = []
+    for raw_value in (
+        candidate.category,
+        candidate.metadata.get("category_label"),
+        candidate.metadata.get("tags"),
+        candidate.metadata.get("tag_names"),
+    ):
+        raw_evidence.extend(_text_values(raw_value))
+    haystack = f" {' '.join(_normalized_category(value) for value in raw_evidence)} "
+    return any(f" {value} " in haystack for value in requested_values)
+
+
+def _text_values(value: Any) -> tuple[str, ...]:
+    if value is None:
+        return ()
+    if isinstance(value, str):
+        return tuple(
+            part.strip()
+            for part in value.replace(";", ",").split(",")
+            if part.strip()
+        )
+    if isinstance(value, Sequence) and not isinstance(value, bytes | bytearray):
+        return tuple(str(item).strip() for item in value if str(item).strip())
+    return (str(value).strip(),) if str(value).strip() else ()
+
+
 def _distance_meters(
     left: ResolvedPlaceAnchor,
     right: ResolvedPlaceAnchor,

app/modules/places/domain/chat_intent.py

@@ -122,6 +122,7 @@ class IntentAlternative:
     key: str
     description: str
     confidence: float
+    category_values: tuple[str, ...] = ()
 
 
 @dataclass(frozen=True)
@@ -224,6 +225,7 @@ class ParsedPlaceChatIntent:
     alternatives: tuple[IntentAlternative, ...] = ()
     unresolved: tuple[str, ...] = ()
     clarification_message: str | None = None
+    response_message: str | None = None
     raw_category_phrase: str | None = None
     intent_model_version: str = "deterministic-open-v2"
 

app/modules/places/domain/clarifications.py

@@ -32,9 +32,9 @@ def new_category_clarification(
                 option_id=option_id,
                 value=category,
                 label=_bounded_text(
-                    option_labels.get(
+                    _category_display_label(
                         category,
-                        category.replace("_", " ").title(),
+                        option_labels.get(category),
                     ),
                     160,
                 ),
@@ -157,6 +157,13 @@ def _bounded_text(value: str, maximum: int) -> str:
     return value[: maximum - 1].rstrip() + "…"
 
 
+def _category_display_label(category: str, label: str | None) -> str:
+    value = " ".join((label or category).replace("_", " ").split()).strip()
+    if not value:
+        value = "Lugar"
+    return value[:1].upper() + value[1:]
+
+
 def _category_option_ids(values: Sequence[str]) -> tuple[str, ...]:
     seen: set[str] = set()
     option_ids: list[str] = []

app/modules/places/infrastructure/deterministic_intent_parser.py

@@ -66,6 +66,45 @@ _RADIUS_VALUE_PATTERN = re.compile(
     r"(?P<unit>km|kilometros?|m|metros?)\b"
 )
 _LOGGER = logging.getLogger(__name__)
+_TRANSIENT_HARD_FILTER_KEYS = {"place_ids"}
+_SOCIAL_GREETING_VALUES = {
+    "buenas",
+    "buenas noches",
+    "buenas tardes",
+    "buenos dias",
+    "hello",
+    "hey",
+    "hola",
+    "hola como estas",
+    "hola que tal",
+    "hola que tal como estas",
+    "holi",
+    "holis",
+    "ola",
+    "ola que tal",
+    "que tal",
+}
+_SOCIAL_THANKS_VALUES = {
+    "gracias",
+    "mil gracias",
+    "muchas gracias",
+    "te lo agradezco",
+}
+_SOCIAL_FAREWELL_VALUES = {
+    "adios",
+    "bye",
+    "hasta luego",
+    "hasta pronto",
+    "nos vemos",
+}
+_SOCIAL_ACKNOWLEDGEMENT_VALUES = {
+    "entendido",
+    "listo",
+    "ok",
+    "okay",
+    "perfecto",
+    "vale",
+}
 _GENERIC_REQUEST_TOKENS = {
     "dame",
     "favor",
@@ -222,6 +261,29 @@ class DeterministicPlaceChatIntentParser:
                 state=state,
                 has_user_location=has_user_location,
             )
+        social_turn = _social_turn(normalized)
+        if social_turn is not None:
+            social_kind, social_message = social_turn
+            if social_kind == "greeting" and state.pending_clarification is not None:
+                repeated = self._clarification(
+                    pending=state.pending_clarification,
+                    unresolved=(state.pending_clarification.kind,),
+                    state=state,
+                    has_user_location=has_user_location,
+                )
+                if repeated.clarification is None:
+                    raise RuntimeError("pending clarification requires public options")
+                prompt = f"¡Hola! {repeated.clarification.prompt}"
+                return replace(
+                    repeated,
+                    clarification=replace(repeated.clarification, prompt=prompt),
+                    clarification_message=prompt,
+                    response_message=prompt,
+                )
+            return self._direct_response(
+                message=social_message,
+                state=state,
+            )
         contextual = self._contextual_signals(message)
         # Token classification is multi-label and a valid frame can still be
         # incomplete.  Strip both model-detected context spans and any remaining
@@ -402,7 +464,7 @@ class DeterministicPlaceChatIntentParser:
             if reference_text
             else inherited_reference
         )
-        hard_filters = dict(state.hard_filters)
+        hard_filters = _persistent_hard_filters(state.hard_filters)
         if state.city and "city" not in hard_filters:
             hard_filters["city"] = state.city
         if state.state and "state" not in hard_filters:
@@ -564,6 +626,34 @@ class DeterministicPlaceChatIntentParser:
             intent_model_version=contextual.intent_model_version,
         )
 
+    def _direct_response(
+        self,
+        message: str,
+        state: ConversationState,
+    ) -> ParsedPlaceChatIntent:
+        hard_filters = _persistent_hard_filters(state.hard_filters)
+        return ParsedPlaceChatIntent(
+            action="no_match",
+            target_category=None,
+            category_values=(),
+            hard_filters=hard_filters,
+            soft_preferences=(),
+            exclusions=(),
+            reference=None,
+            location=LocationIntent(scope="unresolved", source="none"),
+            semantic_query="",
+            confidence=1.0,
+            state_patch=ConversationStatePatch(
+                hard_filters=(
+                    hard_filters if hard_filters != state.hard_filters else None
+                ),
+                taxonomy_version=self._taxonomy.version,
+            ),
+            unresolved=("non_search_input",),
+            response_message=message,
+            intent_model_version=_DETERMINISTIC_INTENT_VERSION,
+        )
+
     def _location_scope_clarification(
         self,
         target_category: str,
@@ -924,7 +1014,7 @@ class DeterministicPlaceChatIntentParser:
             raise ClarificationStateMismatchError(
                 "clarification category must not be empty"
             )
-        hard_filters = dict(state.hard_filters)
+        hard_filters = _persistent_hard_filters(state.hard_filters)
         if state.city and "city" not in hard_filters:
             hard_filters["city"] = state.city
         if state.state and "state" not in hard_filters:
@@ -1192,20 +1282,38 @@ class DeterministicPlaceChatIntentParser:
     ) -> tuple[IntentAlternative, ...]:
         if self._activity_classifier is None:
             return ()
-        rank = getattr(self._activity_classifier, "rank", None)
-        if not callable(rank):
+        rank_supported = getattr(
+            self._activity_classifier,
+            "rank_supported",
+            None,
+        )
+        if not callable(rank_supported):
             return ()
-        matches = rank(normalized, limit=5)
+        matches = rank_supported(normalized, limit=5)
         return tuple(
             IntentAlternative(
                 key=str(match.concept_id),
-                description=str(match.label),
+                description=self._category_display_label(
+                    str(match.concept_id),
+                    str(match.label),
+                ),
                 confidence=max(0.0, min(1.0, (float(match.score) + 1.0) / 2.0)),
+                category_values=tuple(
+                    str(value)
+                    for value in getattr(match, "storage_values", ())
+                    if str(value).strip()
+                ),
             )
             for match in matches
             if getattr(match, "concept_id", None)
         )
 
+    def _category_display_label(self, category: str, fallback: str) -> str:
+        definition = self._taxonomy.category(category)
+        if definition is not None and definition.aliases:
+            return _humanize_category_label(definition.aliases[0])
+        return _humanize_category_label(fallback or category)
+
     @staticmethod
     def _target_clause(normalized: str) -> str:
         target_clause = _REFERENCE_PATTERN.sub(" ", normalized)
@@ -1270,6 +1378,7 @@ class DeterministicPlaceChatIntentParser:
     ) -> ParsedPlaceChatIntent:
         pending = ensure_legacy_pending_options(pending)
         clarification = to_public_clarification(pending)
+        hard_filters = _persistent_hard_filters(state.hard_filters)
         location = (
             LocationIntent(scope="user_current_location", source="user_current")
             if has_user_location
@@ -1279,7 +1388,7 @@ class DeterministicPlaceChatIntentParser:
             action="clarification",
             target_category=state.target_category,
             category_values=(),
-            hard_filters=dict(state.hard_filters),
+            hard_filters=hard_filters,
             soft_preferences=state.soft_preferences,
             exclusions=state.exclusions,
             reference=state.reference,
@@ -1287,8 +1396,11 @@ class DeterministicPlaceChatIntentParser:
             semantic_query="",
             confidence=0.5,
             state_patch=ConversationStatePatch(
+                hard_filters=(
+                    hard_filters if hard_filters != state.hard_filters else None
+                ),
                 pending_clarification=pending,
-                taxonomy_version=self._taxonomy.version
+                taxonomy_version=self._taxonomy.version,
             ),
             category_source=(
                 "conversation_state" if state.target_category else "unresolved"
@@ -1346,6 +1458,47 @@ def load_place_chat_taxonomy() -> PlaceChatTaxonomy:
     )
 
 
+def _social_turn(normalized: str) -> tuple[str, str] | None:
+    standalone = re.sub(r"[^a-z0-9]+", " ", normalized).strip()
+    if standalone in _SOCIAL_GREETING_VALUES:
+        return (
+            "greeting",
+            "¡Hola! Cuéntame qué tipo de lugar o actividad buscas y te ayudo "
+            "a encontrar opciones cerca de ti.",
+        )
+    if standalone in _SOCIAL_THANKS_VALUES:
+        return (
+            "thanks",
+            "¡Con gusto! Cuando quieras, dime qué lugar o plan buscas y seguimos.",
+        )
+    if standalone in _SOCIAL_FAREWELL_VALUES:
+        return (
+            "farewell",
+            "¡Hasta luego! Cuando necesites ideas de lugares, aquí estaré.",
+        )
+    if standalone in _SOCIAL_ACKNOWLEDGEMENT_VALUES:
+        return (
+            "acknowledgement",
+            "Perfecto. Dime qué lugar o actividad te interesa para continuar.",
+        )
+    return None
+
+
+def _persistent_hard_filters(filters: dict[str, Any]) -> dict[str, Any]:
+    return {
+        key: value
+        for key, value in filters.items()
+        if key not in _TRANSIENT_HARD_FILTER_KEYS
+    }
+
+
+def _humanize_category_label(value: str) -> str:
+    label = " ".join(value.replace("_", " ").split()).strip()
+    if not label:
+        return "Lugar"
+    return label[:1].upper() + label[1:]
+
+
 def _contains_phrase(text: str, phrase: str) -> bool:
     return bool(re.search(rf"(?<!\w){re.escape(phrase)}(?!\w)", text))
 

app/modules/places/infrastructure/main_api_place_source.py

@@ -173,11 +173,27 @@ def place_to_source_record(place: dict[str, Any]) -> PlaceSourceRecord | None:
 
     name = str(_first_present(place, "name", "title", default="")).strip()
     category = _first_present(place, "category", "type")
+    category_label = _first_present(place, "category_label", "categoryLabel")
     city = _first_present(place, "city", "municipality")
     state = _first_present(place, "state", default="Chiapas")
     source = _first_present(place, "source")
     price_range = _first_present(place, "price_range", "priceRange")
-    is_active = _first_present(place, "is_active", "isActive", default=True)
+    explicit_is_active = _first_present(place, "is_active", "isActive")
+    is_permanently_closed = _as_bool(
+        _first_present(
+            place,
+            "is_permanently_closed",
+            "isPermanentlyClosed",
+            default=False,
+        ),
+        default=False,
+    )
+    if is_permanently_closed:
+        is_active = False
+    elif explicit_is_active is None:
+        is_active = True
+    else:
+        is_active = _as_bool(explicit_is_active, default=True)
     description = str(_first_present(place, "description", "summary", "about", default=""))
     address = str(_first_present(place, "address", "formatted_address", default=""))
 
@@ -196,11 +212,12 @@ def place_to_source_record(place: dict[str, Any]) -> PlaceSourceRecord | None:
     metadata = {
         "name": name,
         "category": _to_metadata_value(category),
+        "category_label": _to_metadata_value(category_label),
         "city": _to_metadata_value(city),
         "state": _to_metadata_value(state),
         "source": _to_metadata_value(source),
         "price_range": _to_metadata_value(price_range),
-        "is_active": bool(is_active),
+        "is_active": is_active,
         "occasion": ",".join(occasion),
         "tags": ",".join(resolved_tags.names),
         "tag_ids": list(resolved_tags.ids),
@@ -218,7 +235,7 @@ def place_to_source_record(place: dict[str, Any]) -> PlaceSourceRecord | None:
         {
             "document": document,
             "metadata": filtered_metadata,
-            "is_active": bool(is_active),
+            "is_active": is_active,
             "semantic_document_version": PLACE_SEMANTIC_DOCUMENT_VERSION,
         }
     )
@@ -228,7 +245,7 @@ def place_to_source_record(place: dict[str, Any]) -> PlaceSourceRecord | None:
         document=document,
         metadata=filtered_metadata,
         content_hash=content_hash,
-        is_active=bool(is_active),
+        is_active=is_active,
     )
 
 
@@ -254,6 +271,22 @@ def _as_text_list(value: Any) -> list[str]:
     return [str(value).strip()]
 
 
+def _as_bool(value: Any, *, default: bool) -> bool:
+    if value is None:
+        return default
+    if isinstance(value, bool):
+        return value
+    if isinstance(value, int | float):
+        return value != 0
+    if isinstance(value, str):
+        normalized = value.strip().casefold()
+        if normalized in {"true", "1", "yes", "si", "sí"}:
+            return True
+        if normalized in {"false", "0", "no", ""}:
+            return False
+    return bool(value)
+
+
 def _to_metadata_value(value: Any) -> str | int | float | bool | None:
     if value is None or isinstance(value, str | int | float | bool):
         return value

app/modules/places/infrastructure/open_vocabulary_category_classifier.py

@@ -180,6 +180,26 @@ class OpenVocabularyPlaceCategoryClassifier:
             )
         return tuple(matches)
 
+    def rank_supported(
+        self,
+        text: str,
+        limit: int = 3,
+    ) -> tuple[PlaceCategoryMatch, ...]:
+        """Return only hypotheses with enough absolute semantic evidence.
+
+        ``rank`` intentionally exposes diagnostic nearest neighbours even for
+        out-of-distribution text.  Those raw neighbours must not become public
+        clarification buttons.  Ambiguous supported concepts may remain tied;
+        the margin is a requirement for automatic classification, not for
+        asking the user to choose between two genuinely plausible options.
+        """
+
+        return tuple(
+            match
+            for match in self.rank(text, limit=limit)
+            if match.score >= self._minimum_similarity
+        )
+
     def classify(self, text: str) -> PlaceCategoryInference | None:
         """Return the best concept only when its score and margin are sufficient."""
 

app/modules/places/infrastructure/semantic_activity_classifier.py

@@ -54,3 +54,10 @@ class SemanticPlaceActivityClassifier:
 
     def rank(self, text: str, limit: int = 3) -> tuple[PlaceCategoryMatch, ...]:
         return self._delegate.rank(text, limit=limit)
+
+    def rank_supported(
+        self,
+        text: str,
+        limit: int = 3,
+    ) -> tuple[PlaceCategoryMatch, ...]:
+        return self._delegate.rank_supported(text, limit=limit)

app/shared/config/settings.py

@@ -321,6 +321,12 @@ class Settings(BaseSettings):
         le=50_000,
         alias="PLACES_CHAT_DEFAULT_RADIUS_METERS",
     )
+    places_chat_max_auto_radius_meters: int = Field(
+        default=50_000,
+        ge=1,
+        le=50_000,
+        alias="PLACES_CHAT_MAX_AUTO_RADIUS_METERS",
+    )
     places_chat_ranking_version: str = Field(
         default="places-chat-v2",
         min_length=1,
@@ -480,6 +486,14 @@ class Settings(BaseSettings):
                 "PLACES_CHAT_INTENT_PROVIDER debe ser disabled, "
                 "deterministic o bert"
             )
+        if (
+            self.places_chat_max_auto_radius_meters
+            < self.places_chat_default_radius_meters
+        ):
+            raise ValueError(
+                "PLACES_CHAT_MAX_AUTO_RADIUS_METERS debe ser mayor o igual que "
+                "PLACES_CHAT_DEFAULT_RADIUS_METERS"
+            )
         if self.places_chat_bert_model_path is not None:
             self.places_chat_bert_model_path = (
                 self.places_chat_bert_model_path.strip() or None

docs/api_endpoints.md

@@ -388,6 +388,12 @@ scores tecnicos. No devuelve cards, coordenadas ni metadata privada. `clarificat
 hidratar los IDs, revalidar el anchor y aplicar distancia/PostGIS antes de responder a
 la app.
 
+Un turno puramente social se devuelve como `action="no_match"`,
+`unresolved=["non_search_input"]`, `candidates=[]` y
+`metadata.input_kind="non_search"`, con un mensaje conversacional. Esto evita convertir
+saludos como `ola` en categorias cercanas por similitud. Si el mensaje tambien contiene
+una solicitud de lugares, se procesa como busqueda normal.
+
 `state` puede incluir `target_category`, `hard_filters`, `soft_preferences`,
 `exclusions`, `reference`, `explicit_target_location` y `pending_clarification`. Si
 `taxonomy_version` no coincide con la version desplegada, el endpoint responde `409`.
@@ -520,6 +526,20 @@ clasificador exige similitud minima y separacion frente a la segunda categoria;
 frase abierta como `quiero salir` aun solicita aclaracion. Una categoria explicita tiene
 prioridad y una nueva intencion clara elimina un `pending_clarification` obsoleto.
 
+Las opciones de categoria conservan `option.id` y el `value` pendiente como valores
+tecnicos. NLP humaniza la etiqueta fallback y solo publica hipotesis respaldadas por
+candidatos locales con evidencia suficiente. La API principal debe localizar
+`label/message` mediante su catalogo sin alterar IDs, valores, orden ni allowlist.
+
+Cuando hay coordenadas y proveedor nearby, un radio implicito comienza en
+`PLACES_CHAT_DEFAULT_RADIUS_METERS` y puede ampliarse de forma acotada hasta
+`PLACES_CHAT_MAX_AUTO_RADIUS_METERS`. El valor realmente consultado se devuelve en
+`location_directive.radius_meters`. Un radio explicito (`strict_radius=true`) no se
+amplia y los `place_ids` geograficos nunca se guardan en el estado conversacional.
+
+Cambios de integracion fuera de NLP: `docs/cambios_api_principal_chat_lugares.md` y
+`docs/cambios_app_movil_chat_lugares.md`.
+
 ## 3. Publicaciones
 
 ### `POST /posts/recommendations`
@@ -974,6 +994,8 @@ finalizados. Los cursores quedan ligados a query, recursos, filtros, ubicacion,
 | `PLACES_CHAT_MIN_CONTENT_SCORE` | Umbral minimo antes de devolver candidatos |
 | `PLACES_CHAT_INTENT_MIN_CONFIDENCE` | Confianza minima; por debajo se solicita aclaracion |
 | `PLACES_CHAT_AMBIGUITY_DELTA` | Diferencia maxima para considerar ambiguos dos anchors |
+| `PLACES_CHAT_DEFAULT_RADIUS_METERS` | Radio inicial para ubicacion implicita; default `5000` |
+| `PLACES_CHAT_MAX_AUTO_RADIUS_METERS` | Limite de expansion automatica no estricta; default `50000` |
 | `PLACES_CHAT_RANKING_VERSION` | Version observable de la politica de ranking |
 | `PLACES_CHAT_TAXONOMY_VERSION` | Version del parser y del estado conversacional |
 | `MAX_REQUEST_BODY_BYTES` | Debe ser al menos `131072`; valor recomendado `262144` para 500 candidatos |

docs/cambios_api_principal_chat_lugares.md

@@ -0,0 +1,154 @@
+# Cambios requeridos en la API principal para el chat de lugares
+
+> Estado: pendiente fuera de este repositorio. Este documento describe cambios que deben implementarse en la API principal. No se modificó código Go como parte del ajuste del servicio NLP.
+
+## Objetivo
+
+La API principal debe conservar el ranking y las decisiones producidas por `POST /internal/places/chat`, hidratar únicamente recursos vigentes y presentar aclaraciones localizadas sin alterar los identificadores técnicos que protegen el flujo conversacional.
+
+## 1. No volver a aplicar la categoría como filtro duro
+
+NLP trata la categoría como evidencia de ranking, no como una restricción absoluta. Después de recibir los candidatos de NLP, la API principal no debe descartarlos mediante un `categoryMatches` estricto ni exigir que la categoría almacenada coincida literalmente con `target_category`.
+
+La hidratación posterior a NLP puede aplicar estas restricciones duras:
+
+- existencia y vigencia del lugar;
+- permisos y reglas de visibilidad;
+- alcance geográfico explícito y distancia final con PostGIS;
+- cualquier otra regla de negocio que sea independiente de una coincidencia textual de categoría.
+
+Una diferencia de categoría no debe eliminar por sí sola un candidato. Por ejemplo, una intención `cafe` puede recuperar un lugar registrado con una categoría compatible o más específica. NLP ya incorpora categoría, compatibilidad, contenido semántico, evidencia lexical y exclusiones en su puntuación.
+
+Si `categoryMatches` no puede retirarse inmediatamente, debe ejecutarse temporalmente en modo de observación: registrar qué candidatos habría descartado, pero no modificar la respuesta. Su eliminación definitiva debe ocurrir después de comparar esos registros con el ranking de NLP.
+
+## 2. Localizar las opciones de aclaración sin cambiar su identidad
+
+La localización aplica exclusivamente cuando:
+
+```text
+clarification.kind = target_category | intent_category
+```
+
+No debe aplicarse a `location_scope`, `location_anchor`, `reference_entity` ni `reference_location_anchor`, porque sus etiquetas ya describen lugares o acciones concretas.
+
+### Fuente de traducciones
+
+La API principal ya expone:
+
+```http
+GET /api/v1/places/categories?lang=es
+```
+
+El catálogo devuelto contiene pares equivalentes a:
+
+```json
+{
+  "value": "religious_organization",
+  "label": "Organización religiosa"
+}
+```
+
+La API principal debe reutilizar ese catálogo, preferentemente mediante la misma capa de aplicación o repositorio que atiende el endpoint, y puede almacenarlo en caché por idioma. Un error al obtener traducciones no debe hacer fallar el chat.
+
+### Algoritmo de correspondencia
+
+Para cada elemento de `clarification.options`:
+
+1. Buscar por `id` la opción correspondiente en `state_patch.pending_clarification.options`.
+2. Tomar su `value` técnico.
+3. Buscar una entrada del catálogo cuyo `value` coincida exactamente con ese valor.
+4. En el DTO dirigido a la app, reemplazar únicamente `label` y `message` por el `label` localizado.
+5. Conservar el orden original de NLP.
+
+Ejemplo de salida para la app:
+
+```json
+{
+  "id": "religious_organization",
+  "label": "Organización religiosa",
+  "message": "Organización religiosa"
+}
+```
+
+### Invariantes obligatorios
+
+La localización nunca debe modificar:
+
+- `clarification.id`;
+- `clarification.options[].id`;
+- `state_patch.pending_clarification.options[].id`;
+- `state_patch.pending_clarification.options[].value`;
+- el orden de las opciones;
+- la allowlist que se persiste para validar el turno siguiente.
+
+El estado técnico recibido desde NLP debe persistirse y reenviarse sin sustituir IDs o valores por textos traducidos. La traducción pertenece únicamente al DTO de presentación.
+
+Si no existe una traducción, el fallback debe ser el `label` entregado por NLP. Como último recurso puede humanizarse el valor reemplazando guiones bajos por espacios; nunca debe usarse ese texto como `option_id`.
+
+## 3. Selección estructurada
+
+Cuando la app seleccione una opción, la API principal debe reenviar a NLP tanto el estado pendiente original como la selección estructurada:
+
+```json
+{
+  "clarification_choice": {
+    "clarification_id": "22222222-2222-4222-8222-222222222222",
+    "option_id": "religious_organization"
+  }
+}
+```
+
+No debe intentar resolver la selección comparando el texto localizado, la posición del botón o el mensaje visible. Una selección inexistente u obsoleta debe conservar el manejo de conflicto del contrato interno.
+
+## 4. Hidratación y observabilidad
+
+La API principal es responsable de hidratar los IDs técnicos de NLP y de aplicar
+vigencia, permisos y distancia.
+
+El mensaje actual `No encontré lugares vigentes que cumplan con los criterios` se
+construye después de que NLP ya devolvió candidatos y la API principal terminó con una
+lista hidratada vacía. Por tanto, verlo no demuestra que `/nearby` haya encontrado cero
+lugares: también puede significar que `categoryMatches`, vigencia, permisos o distancia
+descartaron todos los IDs. Esta distinción debe conservarse en métricas y logs.
+
+Para poder explicar una respuesta vacía debe emitir un registro estructurado,
+correlacionado por `trace_id`, que incluya al menos:
+
+- `conversation_id` y número de turno;
+- `trace_id` de NLP;
+- cantidad de candidatos recibidos desde NLP;
+- cantidad de IDs encontrados durante la hidratación;
+- cantidad final enviada a la app;
+- conteos de descarte por causa: inexistente, inactivo o eliminado, sin permisos, fuera del radio y error de hidratación;
+- cantidad que el antiguo `categoryMatches` habría descartado durante su periodo de observación.
+
+No deben registrarse coordenadas exactas ni datos privados innecesarios. Los IDs pueden registrarse solo cuando la política operativa lo permita; los conteos y el `trace_id` son obligatorios.
+
+Si NLP devuelve `action="recommendations"` pero ningún candidato sobrevive a las reglas autorizadas, la API principal debe producir un estado de `no_match` coherente para la app y registrar una razón interna como `empty_after_hydration`. No debe atribuir automáticamente el vacío a la categoría ni ocultar la causa operativa.
+
+## 5. Ciclo de vida de lugares
+
+La fuente utilizada para sincronizar Places con NLP y los endpoints de hidratación/nearby deben compartir la misma definición de vigencia.
+
+El contrato de ciclo de vida debe cubrir:
+
+- **snapshot completo:** debe tener un límite consistente, paginación estable y una señal inequívoca de finalización exitosa;
+- **cierre o desactivación:** debe exponer `is_active=false` o un evento equivalente para que NLP deje de recomendar el lugar;
+- **eliminación:** debe producir una baja o tombstone identificable, no limitarse a omitir silenciosamente el registro;
+- **reconciliación:** los lugares ausentes solo pueden marcarse inactivos después de completar correctamente un snapshot total;
+- **fallo o snapshot parcial:** nunca debe provocar una desactivación masiva ni considerarse una reconciliación válida;
+- **consistencia:** `/api/v1/places/nearby`, la hidratación por IDs y el snapshot deben usar el mismo tipo de ID y las mismas reglas de vigencia.
+
+Estos requisitos permiten que el filtro `is_active=true` de NLP represente el estado real y reducen los casos en que Go recibe IDs que ya no puede hidratar.
+
+## Criterios de aceptación
+
+- Un candidato relevante no se elimina solo porque su categoría almacenada no coincide literalmente con `target_category`.
+- `categoryMatches` deja de modificar la lista final; mientras exista en observación, solo genera métricas.
+- Para una opción con `value="religious_organization"`, la app recibe `label="Organización religiosa"` y el mismo `id` técnico.
+- La selección posterior reenvía el `clarification_id` y `option_id` originales, aunque el usuario haya visto un texto traducido.
+- La localización conserva orden, valores y allowlist, y no modifica aclaraciones geográficas o de referencias.
+- Si el catálogo de traducciones no está disponible, el chat continúa con un fallback legible.
+- Cada respuesta vacía después de hidratación puede investigarse mediante `trace_id`, conteos y razones de descarte.
+- Un lugar cerrado o eliminado deja de aparecer después de una sincronización completa exitosa.
+- Un snapshot parcial o fallido no desactiva lugares que siguen vigentes.

docs/cambios_app_movil_chat_lugares.md

@@ -0,0 +1,102 @@
+# Cambios requeridos en la app móvil para el chat de lugares
+
+> Estado: pendiente fuera de este repositorio. Este documento describe cambios que deben implementarse en la app móvil. No se modificó código móvil como parte del ajuste del servicio NLP.
+
+## Objetivo
+
+La app debe presentar aclaraciones con sus textos localizados y conservar la identidad estructurada de cada opción al continuar la conversación. La app consume únicamente el contrato público de la API principal; nunca debe llamar directamente al servicio NLP.
+
+## 1. Renderizado de aclaraciones
+
+Cuando la respuesta incluya `action="clarification"`, la interfaz debe:
+
+- mostrar `clarification.prompt` o el mensaje conversacional definido por la API principal;
+- conservar el orden de `clarification.options`;
+- usar `option.label` como texto visible de cada botón;
+- mantener `option.id` únicamente como dato interno asociado al botón.
+
+La app nunca debe mostrar `option.id` ni `value`, ni construir etiquetas reemplazando guiones bajos. Tampoco debe traducir categorías por su cuenta si la API principal ya entrega `label` y `message` localizados.
+
+Ejemplo esperado:
+
+```json
+{
+  "id": "religious_organization",
+  "label": "Organización religiosa",
+  "message": "Organización religiosa"
+}
+```
+
+El botón debe mostrar `Organización religiosa`, no `religious_organization`.
+
+## 2. Envío de la selección
+
+Al tocar un botón, la app debe conservar la opción seleccionada y enviar a la API principal una elección estructurada:
+
+```json
+{
+  "message": "Organización religiosa",
+  "clarification_choice": {
+    "clarification_id": "22222222-2222-4222-8222-222222222222",
+    "option_id": "religious_organization"
+  }
+}
+```
+
+El texto de la burbuja del usuario puede tomarse de `option.message`, pero la selección se identifica exclusivamente con:
+
+- `clarification.id` como `clarification_id`;
+- `option.id` como `option_id`.
+
+La app no debe:
+
+- enviar el `label` o `message` traducido como `option_id`;
+- resolver una opción por su posición en la lista;
+- inferir la selección comparando texto libre;
+- reconstruir IDs a partir de una etiqueta;
+- reutilizar una opción perteneciente a una aclaración anterior.
+
+La API principal conserva el estado conversacional y la allowlist. La app solo debe mantener los identificadores necesarios para enviar la elección del turno visible.
+
+## 3. Estados de carga y selección
+
+Después de tocar una opción, el botón debe quedar temporalmente deshabilitado para evitar envíos duplicados. Las opciones anteriores deben dejar de ser interactivas cuando llegue el siguiente turno o cuando la API informe que la aclaración es obsoleta.
+
+Si la API principal responde con un conflicto por una selección vencida, la app debe descartar esos botones y mostrar el estado conversacional más reciente; no debe reintentar con el texto o con otro índice.
+
+## 4. Manejo de `no_match`
+
+Cuando la API principal devuelva `action="no_match"`, la app debe:
+
+- mostrar el mensaje recibido;
+- retirar las opciones de aclaración del turno anterior;
+- limpiar cards o recomendaciones anteriores que pudieran confundirse con la respuesta actual;
+- mantener disponible el campo de texto para que el usuario reformule su búsqueda;
+- no fabricar categorías, cards ni mensajes alternativos a partir de IDs previos.
+
+Este comportamiento también permite presentar respuestas amistosas ante saludos o mensajes que todavía no contienen una intención de búsqueda, sin mostrar opciones arbitrarias.
+
+## 5. Responsabilidades que no pertenecen a móvil
+
+La app no debe:
+
+- consumir `POST /internal/places/chat` directamente;
+- consultar `GET /api/v1/places/categories?lang=es` para corregir una respuesta que la API principal ya debe localizar;
+- hidratar IDs de lugares;
+- decidir vigencia, permisos o distancia;
+- volver a filtrar resultados por categoría.
+
+Estas responsabilidades pertenecen a la API principal y a NLP según el contrato de integración.
+
+## Criterios de aceptación
+
+- Ningún botón muestra valores como `ropa_barata` o `religious_organization` cuando existe un `label` localizado.
+- Todos los botones renderizan exactamente `option.label` y conservan el orden recibido.
+- Al seleccionar `Organización religiosa`, la petición envía `option_id="religious_organization"` y el `clarification_id` vigente.
+- Dos opciones con textos iguales siguen siendo distinguibles porque la selección usa su ID, no texto ni posición.
+- Una traducción o cambio de copy no modifica el identificador enviado al backend.
+- Una selección no puede enviarse dos veces mientras el turno está en proceso.
+- Ante una aclaración obsoleta, la app elimina sus botones y no intenta resolverla por texto.
+- Una respuesta `no_match` elimina cards y opciones anteriores y muestra el mensaje actual.
+- La app no llama directamente a NLP ni duplica la lógica de traducción, hidratación o filtrado de la API principal.
+

tests/test_internal_places_chat.py

@@ -88,6 +88,28 @@ def test_internal_chat_recommends_restaurants_for_implicit_food_intent() -> None
     assert payload["candidates"]
 
 
+@pytest.mark.parametrize("message", ("hola", "ola", "¡buenas!"))
+def test_internal_chat_answers_social_greetings_without_recommendations(
+    message: str,
+) -> None:
+    client = TestClient(create_app())
+
+    response = client.post(
+        "/internal/places/chat",
+        json={**BASE_REQUEST, "message": message},
+        headers=AUTHORIZATION,
+    )
+
+    assert response.status_code == 200
+    payload = response.json()
+    assert payload["action"] == "no_match"
+    assert payload["candidates"] == []
+    assert payload["clarification"] is None
+    assert payload["unresolved"] == ["non_search_input"]
+    assert payload["metadata"]["input_kind"] == "non_search"
+    assert "hola" in payload["message"].casefold()
+
+
 @pytest.mark.parametrize(
     ("message", "expected_place_id"),
     (

tests/test_main_api_place_source.py

@@ -31,6 +31,37 @@ def test_place_to_source_record_maps_api_place() -> None:
     assert len(record.content_hash) == 64
 
 
+def test_place_to_source_record_maps_category_label_and_closed_state() -> None:
+    record = place_to_source_record(
+        {
+            "id": "place_closed",
+            "name": "Lugar cerrado",
+            "category": "religious_organization",
+            "categoryLabel": "Organización religiosa",
+            "isActive": True,
+            "isPermanentlyClosed": True,
+        }
+    )
+
+    assert record is not None
+    assert record.metadata["category_label"] == "Organización religiosa"
+    assert record.metadata["is_active"] is False
+    assert record.is_active is False
+
+
+def test_explicit_string_active_state_is_not_coerced_as_truthy() -> None:
+    record = place_to_source_record(
+        {
+            "id": "place_inactive",
+            "name": "Lugar inactivo",
+            "is_active": "false",
+        }
+    )
+
+    assert record is not None
+    assert record.is_active is False
+
+
 def test_place_to_source_record_resolves_tags_without_token_repetition() -> None:
     record = place_to_source_record(
         {

tests/test_open_vocabulary_category_classifier.py

@@ -96,6 +96,45 @@ def test_rank_limit_still_calculates_top_margin_against_runner_up() -> None:
     assert only_match[0].margin > 0.88
 
 
+def test_rank_supported_discards_nearest_neighbors_below_absolute_threshold() -> None:
+    classifier = OpenVocabularyPlaceCategoryClassifier(
+        _concepts(),
+        ControlledEmbeddingProvider(_catalog_vectors()),
+        minimum_similarity=0.5,
+    )
+
+    raw_matches = classifier.rank("algo completamente distinto", limit=2)
+    supported_matches = classifier.rank_supported(
+        "algo completamente distinto",
+        limit=2,
+    )
+
+    assert len(raw_matches) == 2
+    assert all(match.score < 0.5 for match in raw_matches)
+    assert supported_matches == ()
+
+
+def test_rank_supported_keeps_supported_ties_for_clarification() -> None:
+    classifier = OpenVocabularyPlaceCategoryClassifier(
+        _concepts(),
+        ControlledEmbeddingProvider(_catalog_vectors()),
+        minimum_similarity=0.5,
+        minimum_margin=0.05,
+    )
+
+    supported_matches = classifier.rank_supported("quiero salir", limit=2)
+
+    assert classifier.classify("quiero salir") is None
+    assert [match.concept_id for match in supported_matches] == [
+        "sweet_baked_goods",
+        "urban_nature",
+    ]
+    assert supported_matches[0].score == pytest.approx(
+        supported_matches[1].score
+    )
+    assert supported_matches[0].score > 0.5
+
+
 def test_query_and_concept_encoders_can_use_distinct_e5_prefix_roles() -> None:
     vectors = _catalog_vectors()
     query_embeddings = ControlledEmbeddingProvider(

tests/test_place_chat_intent_parser.py

@@ -18,6 +18,98 @@ from app.modules.places.infrastructure.deterministic_intent_parser import (
 )
 
 
+@pytest.mark.parametrize(
+    "message",
+    ("ola", "hola", "holi", "buenas", "¿qué tal?"),
+)
+def test_standalone_greetings_return_a_friendly_non_search_response(
+    message: str,
+) -> None:
+    intent = DeterministicPlaceChatIntentParser().parse(
+        message=message,
+        state=ConversationState(),
+        has_user_location=True,
+    )
+
+    assert intent.action == "no_match"
+    assert intent.unresolved == ("non_search_input",)
+    assert intent.response_message is not None
+    assert "hola" in intent.response_message.casefold()
+    assert "lugar o actividad" in intent.response_message.casefold()
+    assert intent.semantic_query == ""
+    assert intent.alternatives == ()
+
+
+def test_greeting_with_a_place_request_remains_actionable() -> None:
+    intent = DeterministicPlaceChatIntentParser().parse(
+        message="hola, busco una cafeteria tranquila",
+        state=ConversationState(),
+        has_user_location=True,
+    )
+
+    assert intent.action == "recommendations"
+    assert intent.target_category == "cafe"
+    assert "tranquilo" in intent.soft_preferences
+    assert "non_search_input" not in intent.unresolved
+
+
+def test_greeting_repeats_the_same_pending_clarification() -> None:
+    pending = PendingClarification(
+        clarification_id="pending-category-1",
+        kind="intent_category",
+        options=(
+            PendingClarificationOption(
+                option_id="cafe",
+                value="cafe",
+                label="Cafetería",
+            ),
+            PendingClarificationOption(
+                option_id="restaurant",
+                value="restaurant",
+                label="Restaurante",
+            ),
+        ),
+    )
+
+    intent = DeterministicPlaceChatIntentParser().parse(
+        message="hola",
+        state=ConversationState(pending_clarification=pending),
+        has_user_location=True,
+    )
+
+    assert intent.action == "clarification"
+    assert intent.clarification is not None
+    assert intent.clarification.clarification_id == pending.clarification_id
+    assert [option.option_id for option in intent.clarification.options] == [
+        "cafe",
+        "restaurant",
+    ]
+    repeated = intent.state_patch.pending_clarification
+    assert repeated is not None
+    assert repeated.clarification_id == pending.clarification_id
+    assert repeated.options == pending.options
+    assert intent.response_message is not None
+    assert intent.response_message.startswith("¡Hola!")
+
+
+def test_transient_place_ids_are_removed_from_filters_and_state_patch() -> None:
+    intent = DeterministicPlaceChatIntentParser().parse(
+        message="una cafeteria",
+        state=ConversationState(
+            hard_filters={
+                "city": "Puebla",
+                "place_ids": ("stale-nearby-id",),
+            },
+        ),
+        has_user_location=True,
+    )
+
+    assert intent.action == "recommendations"
+    assert intent.hard_filters == {"city": "Puebla"}
+    assert intent.state_patch.hard_filters == {"city": "Puebla"}
+    assert intent.state_patch.as_dict()["hard_filters"] == {"city": "Puebla"}
+
+
 def test_category_is_not_polluted_by_the_location_anchor() -> None:
     intent = DeterministicPlaceChatIntentParser().parse(
         message="Recomiendame alguna cafeteria cerca del Parque Central",

tests/test_place_chat_recommendations_use_case.py

@@ -107,6 +107,33 @@ def test_open_category_buttons_use_safe_ids_and_preserve_raw_values() -> None:
     ]
 
 
+def test_category_buttons_humanize_labels_without_changing_ids() -> None:
+    from app.modules.places.domain.clarifications import new_category_clarification
+
+    pending = new_category_clarification(
+        ("religious_organization", "ropa_barata"),
+        kind="intent_category",
+    )
+    clarification = to_public_clarification(pending)
+
+    assert [option.option_id for option in pending.options] == [
+        "religious_organization",
+        "ropa_barata",
+    ]
+    assert [option.value for option in pending.options] == [
+        "religious_organization",
+        "ropa_barata",
+    ]
+    assert [option.label for option in clarification.options] == [
+        "Religious organization",
+        "Ropa barata",
+    ]
+    assert [option.option_id for option in clarification.options] == [
+        "religious_organization",
+        "ropa_barata",
+    ]
+
+
 @pytest.mark.asyncio
 async def test_llm_cannot_change_action_or_candidates() -> None:
     without_llm = await build_use_case(llm_enabled=False).execute(
@@ -161,23 +188,33 @@ class LowConfidenceIntentParser:
 
 
 class CategoryEvidenceRetriever:
-    def __init__(self) -> None:
+    def __init__(self, categories: tuple[str, ...] = ("bakery",)) -> None:
         self.calls = 0
+        self.intents = []
+        self._categories = categories
 
     async def retrieve(self, intent, limit):
-        del intent, limit
+        del limit
         self.calls += 1
+        self.intents.append(intent)
         return [
             PlaceChatCandidate(
-                place_id="bakery_1",
-                name="Panaderia Local",
-                category="bakery",
-                content_score=0.62,
-                semantic_score=0.64,
+                place_id=f"{category}_1",
+                name=f"Opcion local {category}",
+                category=category,
+                content_score=0.62 - (index * 0.01),
+                semantic_score=0.64 - (index * 0.01),
                 lexical_score=0.20,
                 match_level="broad",
                 matched_reasons=("algo dulce",),
+                metadata={
+                    "retrieval_diagnostics": {
+                        "category_match": "exact",
+                        "meets_minimum_content_score": True,
+                    }
+                },
             )
+            for index, category in enumerate(self._categories)
         ]
 
 
@@ -201,6 +238,7 @@ async def test_low_confidence_uses_dynamic_category_hypotheses() -> None:
     result = await build_use_case(
         llm_enabled=False,
         intent_parser=parser,
+        retriever=CategoryEvidenceRetriever(("bakery", "ice_cream")),
     ).execute(
         message="quiero algo dulce y tranquilo",
         state=ConversationState(),
@@ -228,6 +266,56 @@ async def test_low_confidence_uses_dynamic_category_hypotheses() -> None:
     ] == ["bakery", "ice_cream"]
 
 
+@pytest.mark.asyncio
+async def test_low_confidence_hypotheses_without_local_evidence_are_not_buttons() -> None:
+    parser = LowConfidenceIntentParser(
+        alternatives=(
+            IntentAlternative(
+                key="bakery",
+                description="Panaderias artesanales",
+                confidence=0.68,
+                category_values=("bakery",),
+            ),
+            IntentAlternative(
+                key="ice_cream",
+                description="Postres y heladerias",
+                confidence=0.64,
+                category_values=("ice_cream",),
+            ),
+            IntentAlternative(
+                key="office",
+                description="Oficinas",
+                confidence=0.63,
+                category_values=("office",),
+            ),
+        )
+    )
+
+    result = await build_use_case(
+        llm_enabled=False,
+        intent_parser=parser,
+        retriever=CategoryEvidenceRetriever(("bakery", "ice_cream")),
+    ).execute(
+        message="quiero algo dulce y tranquilo",
+        state=ConversationState(),
+        user_latitude=16.7531,
+        user_longitude=-93.1156,
+        candidate_limit=5,
+        result_limit=3,
+    )
+
+    assert result.action == "clarification"
+    assert result.clarification is not None
+    assert [option.option_id for option in result.clarification.options] == [
+        "bakery",
+        "ice_cream",
+    ]
+    assert "office" not in {
+        option["id"]
+        for option in result.state_patch["pending_clarification"]["options"]
+    }
+
+
 @pytest.mark.asyncio
 async def test_low_confidence_without_top_k_uses_retrieval_evidence_not_fixed_menu() -> None:
     retriever = CategoryEvidenceRetriever()
@@ -324,6 +412,186 @@ async def test_weak_candidates_are_returned_as_reviewable_not_confident() -> Non
     assert "evidencia" in result.message.casefold()
 
 
+class SequencedNearbyProvider:
+    def __init__(self, responses: tuple[set[str], ...]) -> None:
+        self.calls = []
+        self._responses = responses
+
+    async def get_nearby_place_ids(self, latitude, longitude, radius_meters):
+        self.calls.append((latitude, longitude, radius_meters))
+        index = len(self.calls) - 1
+        if index >= len(self._responses):
+            raise AssertionError("nearby provider received an unexpected call")
+        return self._responses[index]
+
+
+class ForbiddenRetriever:
+    def __init__(self) -> None:
+        self.calls = 0
+
+    async def retrieve(self, intent, limit):
+        del intent, limit
+        self.calls += 1
+        raise AssertionError("retriever must not be called")
+
+
+class ForbiddenNearbyProvider:
+    def __init__(self) -> None:
+        self.calls = 0
+
+    async def get_nearby_place_ids(self, latitude, longitude, radius_meters):
+        del latitude, longitude, radius_meters
+        self.calls += 1
+        raise AssertionError("nearby provider must not be called")
+
+
+class UnsupportedCategoryRetriever:
+    def __init__(self) -> None:
+        self.intents = []
+
+    async def retrieve(self, intent, limit):
+        del limit
+        self.intents.append(intent)
+        return [
+            PlaceChatCandidate(
+                place_id=f"park_{len(self.intents)}",
+                name="Parque disponible",
+                category="park",
+                content_score=0.82,
+                semantic_score=0.79,
+                lexical_score=0.20,
+                match_level="broad",
+                matched_reasons=("aire libre",),
+                metadata={
+                    "retrieval_diagnostics": {
+                        "category_match": "none",
+                        "meets_minimum_content_score": True,
+                    }
+                },
+            )
+        ]
+
+
+@pytest.mark.asyncio
+async def test_greeting_does_not_call_retriever_or_nearby_provider() -> None:
+    retriever = ForbiddenRetriever()
+    nearby = ForbiddenNearbyProvider()
+
+    result = await build_use_case(
+        llm_enabled=False,
+        retriever=retriever,
+        nearby_place_provider=nearby,
+    ).execute(
+        message="ola",
+        state=ConversationState(),
+        user_latitude=16.7531,
+        user_longitude=-93.1156,
+        candidate_limit=5,
+        result_limit=3,
+    )
+
+    assert result.action == "no_match"
+    assert result.candidates == ()
+    assert result.unresolved == ("non_search_input",)
+    assert "hola" in result.message.casefold()
+    assert retriever.calls == 0
+    assert nearby.calls == 0
+
+
+@pytest.mark.asyncio
+async def test_empty_implicit_radius_expands_from_five_to_fifty_kilometers() -> None:
+    nearby = SequencedNearbyProvider((set(), set()))
+    retriever = ForbiddenRetriever()
+
+    result = await build_use_case(
+        llm_enabled=False,
+        retriever=retriever,
+        nearby_place_provider=nearby,
+    ).execute(
+        message="una cafeteria",
+        state=ConversationState(),
+        user_latitude=16.7531,
+        user_longitude=-93.1156,
+        candidate_limit=5,
+        result_limit=3,
+    )
+
+    assert result.action == "no_match"
+    assert result.unresolved == ("nearby_catalog_empty",)
+    assert nearby.calls == [
+        (16.7531, -93.1156, 5_000),
+        (16.7531, -93.1156, 50_000),
+    ]
+    assert result.location_directive.radius_meters == 50_000
+    assert result.location_directive.strict_radius is False
+    assert retriever.calls == 0
+
+
+@pytest.mark.asyncio
+async def test_empty_explicit_radius_does_not_expand() -> None:
+    nearby = SequencedNearbyProvider((set(),))
+    retriever = ForbiddenRetriever()
+
+    result = await build_use_case(
+        llm_enabled=False,
+        retriever=retriever,
+        nearby_place_provider=nearby,
+    ).execute(
+        message="una cafeteria a 2 km",
+        state=ConversationState(),
+        user_latitude=16.7531,
+        user_longitude=-93.1156,
+        candidate_limit=5,
+        result_limit=3,
+    )
+
+    assert result.action == "no_match"
+    assert result.unresolved == ("nearby_catalog_empty",)
+    assert nearby.calls == [(16.7531, -93.1156, 2_000)]
+    assert result.location_directive.radius_meters == 2_000
+    assert result.location_directive.strict_radius is True
+    assert retriever.calls == 0
+
+
+@pytest.mark.asyncio
+async def test_unsupported_category_expands_then_returns_category_availability() -> None:
+    nearby = SequencedNearbyProvider(
+        (
+            {"park_near"},
+            {"park_far", "park_near"},
+        )
+    )
+    retriever = UnsupportedCategoryRetriever()
+
+    result = await build_use_case(
+        llm_enabled=False,
+        retriever=retriever,
+        nearby_place_provider=nearby,
+    ).execute(
+        message="una cafeteria",
+        state=ConversationState(),
+        user_latitude=16.7531,
+        user_longitude=-93.1156,
+        candidate_limit=5,
+        result_limit=3,
+    )
+
+    assert result.action == "no_match"
+    assert result.candidates == ()
+    assert result.unresolved == ("category_availability",)
+    assert nearby.calls == [
+        (16.7531, -93.1156, 5_000),
+        (16.7531, -93.1156, 50_000),
+    ]
+    assert len(retriever.intents) == 2
+    assert retriever.intents[0].hard_filters["place_ids"] == ("park_near",)
+    assert retriever.intents[1].hard_filters["place_ids"] == (
+        "park_far",
+        "park_near",
+    )
+    assert result.location_directive.radius_meters == 50_000
+
+
 class RecordingNearbyProvider:
     def __init__(self) -> None:
         self.call = None
@@ -382,6 +650,51 @@ async def test_current_location_ids_are_applied_before_content_retrieval() -> No
     assert retriever.intent.hard_filters["place_ids"] == ("near_1", "near_2")
 
 
+@pytest.mark.asyncio
+async def test_transient_geographic_place_ids_are_not_persisted_in_clarification() -> None:
+    nearby = SequencedNearbyProvider(({"bakery_1", "ice_cream_1"},))
+    retriever = CategoryEvidenceRetriever(("bakery", "ice_cream"))
+    parser = LowConfidenceIntentParser(
+        alternatives=(
+            IntentAlternative(
+                key="bakery",
+                description="Panaderias artesanales",
+                confidence=0.68,
+                category_values=("bakery",),
+            ),
+            IntentAlternative(
+                key="ice_cream",
+                description="Postres y heladerias",
+                confidence=0.64,
+                category_values=("ice_cream",),
+            ),
+        )
+    )
+
+    result = await build_use_case(
+        llm_enabled=False,
+        intent_parser=parser,
+        retriever=retriever,
+        nearby_place_provider=nearby,
+    ).execute(
+        message="quiero algo dulce y tranquilo",
+        state=ConversationState(hard_filters={"city": "Tuxtla"}),
+        user_latitude=16.7531,
+        user_longitude=-93.1156,
+        candidate_limit=5,
+        result_limit=3,
+    )
+
+    assert result.action == "clarification"
+    assert retriever.intents[0].hard_filters["place_ids"] == (
+        "bakery_1",
+        "ice_cream_1",
+    )
+    assert result.state_patch["hard_filters"] == {"city": "Tuxtla"}
+    assert "place_ids" not in result.state_patch["hard_filters"]
+    assert result.location_directive.radius_meters == 5_000
+
+
 class CoordinateAnchorResolver:
     async def resolve(self, text, city, state, limit=3):
         del text, city, state, limit

tests/test_place_embedding_configuration.py

@@ -214,6 +214,29 @@ def test_place_chat_intent_provider_defaults_to_deterministic() -> None:
     assert settings.places_chat_bert_model_path is None
 
 
+def test_place_chat_auto_radius_is_configurable_and_bounded() -> None:
+    settings = Settings(
+        _env_file=None,
+        ENV="local",
+        PLACES_CHAT_DEFAULT_RADIUS_METERS=4_000,
+        PLACES_CHAT_MAX_AUTO_RADIUS_METERS=20_000,
+    )
+
+    assert settings.places_chat_default_radius_meters == 4_000
+    assert settings.places_chat_max_auto_radius_meters == 20_000
+
+    with pytest.raises(
+        ValidationError,
+        match="PLACES_CHAT_MAX_AUTO_RADIUS_METERS",
+    ):
+        Settings(
+            _env_file=None,
+            ENV="local",
+            PLACES_CHAT_DEFAULT_RADIUS_METERS=10_000,
+            PLACES_CHAT_MAX_AUTO_RADIUS_METERS=5_000,
+        )
+
+
 def test_place_chat_bert_provider_is_explicit_and_validated() -> None:
     settings = Settings(
         _env_file=None,