ha-mcp-dev 8.3.0.dev2387__tar.gz → 8.3.0.dev2393__tar.gz

{ha_mcp_dev-8.3.0.dev2387/src/ha_mcp_dev.egg-info → ha_mcp_dev-8.3.0.dev2393}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ha-mcp-dev
-Version: 8.3.0.dev2387
+Version: 8.3.0.dev2393
 Summary: Home Assistant MCP Server - Complete control of Home Assistant through MCP
 Author-email: Julien <github@qc-h.net>
 License: MIT

{ha_mcp_dev-8.3.0.dev2387 → ha_mcp_dev-8.3.0.dev2393}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "ha-mcp-dev"
-version = "8.3.0.dev2387"
+version = "8.3.0.dev2393"
 description = "Home Assistant MCP Server - Complete control of Home Assistant through MCP"
 readme = "README.md"
 # Upper bound widened to <3.15 so the package installs on Home Assistant's

{ha_mcp_dev-8.3.0.dev2387 → ha_mcp_dev-8.3.0.dev2393}/src/ha_mcp/tools/smart_search/_entities.py

@@ -2,8 +2,10 @@
 
 import asyncio
 import logging
+from collections.abc import Mapping
 from typing import Any
 
+from ...utils.entity_membership import normalize_member_entity_ids
 from ...utils.fuzzy_search import calculate_partial_ratio, calculate_ratio
 from ...visibility.resolver import (
     device_registry_needed_for_visibility,
@@ -21,6 +23,35 @@ logger = logging.getLogger(__name__)
 _GET_ENTRIES_CHUNK_SIZE = 500
 
 
+def _redact_hidden_memberships(
+    entities: list[dict[str, Any]], visibility_hidden: set[str]
+) -> list[dict[str, Any]]:
+    """Mark membership whose direct IDs intersect the visibility deny-set.
+
+    tools_search._add_membership_fields consumes this private sentinel after
+    smart-search projection, preserving is_group while withholding member IDs.
+    """
+    if not visibility_hidden:
+        return entities
+    redacted: list[dict[str, Any]] = []
+    for entity in entities:
+        attributes = entity.get("attributes")
+        members = normalize_member_entity_ids(attributes)
+        if members is not None and visibility_hidden.intersection(members):
+            redacted.append(
+                {
+                    **entity,
+                    "attributes": {
+                        **(attributes if isinstance(attributes, Mapping) else {}),
+                        "_ha_mcp_membership_redacted": True,
+                    },
+                }
+            )
+        else:
+            redacted.append(entity)
+    return redacted
+
+
 class EntitySearchMixin(_SearchBase):
     """``smart_entity_search`` and ``get_entities_by_area`` plus helpers."""
 
@@ -33,6 +64,7 @@ class EntitySearchMixin(_SearchBase):
         domain_filter: str | None = None,
         include_hidden: bool = True,
         *,
+        include_membership: bool = False,
         prefetched_states: list[dict[str, Any]] | None = None,
         prefetched_registry: Any = None,
     ) -> dict[str, Any]:
@@ -49,6 +81,8 @@ class EntitySearchMixin(_SearchBase):
                 set in the entity registry are still returned but receive
                 a score penalty so they sort below comparable visible
                 matches. Pass False to filter them out entirely.
+            include_membership: Whether to retain membership attributes and redaction markers
+                for opt-in search result fields.
             prefetched_states: Pre-fetched ``get_states()`` list shared by the
                 ha_search orchestrator when both search branches run; ``None``
                 means fetch here.
@@ -68,6 +102,7 @@ class EntitySearchMixin(_SearchBase):
             entities, visibility_warnings = await self._fetch_search_entities(
                 domain_filter,
                 include_hidden,
+                include_membership=include_membership,
                 prefetched_states=prefetched_states,
                 prefetched_registry=prefetched_registry,
             )
@@ -261,6 +296,7 @@ class EntitySearchMixin(_SearchBase):
         domain_filter: str | None,
         include_hidden: bool,
         *,
+        include_membership: bool = False,
         prefetched_states: list[dict[str, Any]] | None = None,
         prefetched_registry: Any = None,
     ) -> tuple[list[dict[str, Any]], list[str]]:
@@ -334,6 +370,17 @@ class EntitySearchMixin(_SearchBase):
             registry_result, states_result, self.client, device_result
         )
         registry_slim = self._build_registry_slim(registry_result)
+        if include_membership:
+            denied_member_ids = visibility_hidden | (
+                {
+                    entity_id
+                    for entity_id, entry in registry_slim.items()
+                    if entry.get("hidden_by") is not None
+                }
+                if not include_hidden
+                else set()
+            )
+            entities = _redact_hidden_memberships(entities, denied_member_ids)
         survivor_ids, survivor_states = self._filter_hidden_entities(
             entities, registry_slim, include_hidden, visibility_hidden
         )
@@ -401,6 +448,8 @@ class EntitySearchMixin(_SearchBase):
         area_query: str,
         group_by_domain: bool = True,
         include_hidden: bool = True,
+        *,
+        include_membership: bool = False,
     ) -> dict[str, Any]:
         """
         Get entities grouped by area/room using the HA registries for accurate area resolution.
@@ -417,6 +466,8 @@ class EntitySearchMixin(_SearchBase):
                 set in the entity registry are still grouped under their
                 area but receive a score penalty when ranked. Pass False
                 to filter them out entirely.
+            include_membership: Whether to retain membership attributes and redaction markers
+                for opt-in search result fields.
 
         Returns:
             Dictionary with area-grouped entities
@@ -509,6 +560,17 @@ class EntitySearchMixin(_SearchBase):
             entity_area_resolved, hidden_entity_ids = self._resolve_entity_areas(
                 entity_reg_map, device_area_map, include_hidden, visibility_hidden
             )
+            if include_membership:
+                denied_member_ids = visibility_hidden | (
+                    {
+                        entity_id
+                        for entity_id, entry in entity_reg_map.items()
+                        if entry.get("hidden_by") is not None
+                    }
+                    if not include_hidden
+                    else set()
+                )
+                entities = _redact_hidden_memberships(entities, denied_member_ids)
             state_map = self._build_state_map(entities)
             formatted_areas, total_entities = self._format_area_entities(
                 matched_area_ids,
@@ -870,6 +932,7 @@ class EntitySearchMixin(_SearchBase):
             ),
             "state": state_info.get("state", "unknown"),
             "_hidden_by": "hidden" if entity_id in hidden_entity_ids else None,
+            "_attributes": state_info.get("attributes", {}),
         }
         if include_domain:
             record["domain"] = entity_id.split(".", maxsplit=1)[0]

{ha_mcp_dev-8.3.0.dev2387 → ha_mcp_dev-8.3.0.dev2393}/src/ha_mcp/tools/tools_search.py

@@ -6,6 +6,7 @@ This module provides entity search, system overview, deep search, and state retr
 
 import asyncio
 import logging
+from collections.abc import Mapping
 from dataclasses import dataclass
 from typing import Annotated, Any, Literal, cast
 
@@ -24,6 +25,7 @@ from ..client.websocket_client import get_websocket_client
 from ..config import get_global_settings
 from ..errors import create_validation_error
 from ..transforms.categorized_search import DEFAULT_PINNED_TOOLS
+from ..utils.entity_membership import normalize_member_entity_ids
 from ..utils.fuzzy_search import apply_hidden_penalty
 from ..visibility.resolver import (
     device_registry_needed_for_visibility,
@@ -596,12 +598,22 @@ def _apply_by_domain_grouping(
         by_domain = {d: ents[:per_domain_limit_int] for d, ents in by_domain.items()}
     if parsed_result_fields is not None:
         by_domain = {
-            d: _project_records(ents, parsed_result_fields)
+            d: _project_records(ents, _effective_result_fields(parsed_result_fields))
             for d, ents in by_domain.items()
         }
     data["by_domain"] = by_domain
 
 
+def _effective_result_fields(parsed_result_fields: list[str]) -> list[str]:
+    """Retain is_group whenever member_entity_ids is projected."""
+    if (
+        "member_entity_ids" in parsed_result_fields
+        and "is_group" not in parsed_result_fields
+    ):
+        return [*parsed_result_fields, "is_group"]
+    return parsed_result_fields
+
+
 def _apply_result_fields_to_response(
     data: dict[str, Any],
     parsed_result_fields: list[str] | None,
@@ -610,8 +622,17 @@ def _apply_result_fields_to_response(
     if parsed_result_fields is None or "results" not in data:
         return
     orig = data["results"]
-    data["results"] = _project_records(orig, parsed_result_fields)
-    _warn = _result_fields_warning(orig, data["results"], parsed_result_fields)
+    data["results"] = _project_records(
+        orig, _effective_result_fields(parsed_result_fields)
+    )
+    warning_fields = [
+        field for field in parsed_result_fields if field != "member_entity_ids"
+    ]
+    _warn = (
+        _result_fields_warning(orig, data["results"], warning_fields)
+        if warning_fields
+        else None
+    )
     if _warn:
         data.setdefault("warnings", []).append(_warn)
 
@@ -738,12 +759,15 @@ _ENTITY_RECORD_KEYS = (
 # (SearchTools._fetch_entity_enrichment). Ordered so a projected record lists them
 # consistently regardless of the caller's result_fields order.
 _ENRICHMENT_FIELDS: tuple[str, ...] = ("area", "floor", "labels", "aliases")
-
-# Every field name result_fields= accepts — base record keys plus the opt-in
-# enrichment keys. A requested name outside this set is rejected up front with the
-# standard validation error rather than silently projecting to empty records.
-_ALLOWED_RESULT_FIELDS: frozenset[str] = frozenset(_ENTITY_RECORD_KEYS) | frozenset(
-    _ENRICHMENT_FIELDS
+_MEMBERSHIP_FIELDS: tuple[str, ...] = ("is_group", "member_entity_ids")
+
+# Every field name result_fields= accepts — base record keys plus opt-in
+# enrichment and membership keys. Unknown names are rejected up front rather
+# than silently projecting to empty records.
+_ALLOWED_RESULT_FIELDS: frozenset[str] = (
+    frozenset(_ENTITY_RECORD_KEYS)
+    | frozenset(_ENRICHMENT_FIELDS)
+    | frozenset(_MEMBERSHIP_FIELDS)
 )
 
 
@@ -790,6 +814,50 @@ def _requested_enrichment(parsed_result_fields: list[str] | None) -> tuple[str,
     return tuple(f for f in _ENRICHMENT_FIELDS if f in requested)
 
 
+def _requested_membership(parsed_result_fields: list[str] | None) -> tuple[str, ...]:
+    """Return requested membership fields, retaining the group discriminator.
+
+    A member-only projection still includes is_group so a redacted group,
+    an empty group, and a leaf entity remain distinguishable.
+    """
+    if not parsed_result_fields:
+        return ()
+    requested = set(parsed_result_fields)
+    if "member_entity_ids" in requested:
+        requested.add("is_group")
+    return tuple(field for field in _MEMBERSHIP_FIELDS if field in requested)
+
+
+def _add_membership_fields(
+    record: dict[str, Any],
+    attributes: Any,
+    requested: tuple[str, ...],
+    *,
+    denied_member_ids: set[str],
+) -> None:
+    """Add requested generic membership metadata to one search record.
+
+    Smart-search paths may mark attributes in _redact_hidden_memberships before
+    this final projection. Callers that consume that sentinel pass an explicit
+    empty denied set.
+    """
+    if not requested:
+        return
+    members = normalize_member_entity_ids(attributes)
+    redacted = bool(
+        isinstance(attributes, Mapping)
+        and attributes.get("_ha_mcp_membership_redacted")
+    ) or bool(
+        members is not None
+        and denied_member_ids
+        and denied_member_ids.intersection(members)
+    )
+    if "is_group" in requested:
+        record["is_group"] = members is not None
+    if "member_entity_ids" in requested and members is not None and not redacted:
+        record["member_entity_ids"] = members
+
+
 def _ws_result_map(resp: Any) -> dict[str, dict[str, Any]]:
     """The ``{entity_id: entry}`` map from a ``config/entity_registry/get_entries`` reply."""
     if isinstance(resp, dict) and resp.get("success"):
@@ -974,6 +1042,11 @@ def _build_component_search_request(req: _ResolvedSearch) -> dict[str, Any]:
         "limit": req.limit,
         "offset": req.offset,
     }
+    membership_fields = _requested_membership(
+        _parse_component_result_fields(req.result_fields)
+    )
+    if membership_fields:
+        request["result_fields"] = list(membership_fields)
     if req.query_text:
         request["query"] = req.query_text
     domain_filter = _normalized_domain_filter(req.domain_filter)
@@ -1061,18 +1134,22 @@ def _shape_component_search_response(
 
     if req.registry_eligible:
         parsed_result_fields = _parse_component_result_fields(req.result_fields)
-        # Base record is the six documented keys. result_fields may additionally
-        # request enrichment fields (area/floor/labels/aliases) that the component
-        # already computed per hit via its registry join — retain exactly those
-        # requested keys before the result_fields projection so the enrichment
-        # survives it, while a search that requests none still emits the default
-        # six-key shape (parity with the legacy path).
+        # Base records contain the six documented keys. Requested enrichment
+        # fields retain the component's area/floor/labels/aliases registry join;
+        # requested membership fields append its opt-in state-derived metadata.
+        # With neither class requested, the default six-key shape is unchanged.
         record_keys = (
             *_ENTITY_RECORD_KEYS,
             *_requested_enrichment(parsed_result_fields),
+            *_requested_membership(parsed_result_fields),
         )
+        conditional_keys = set(_requested_membership(parsed_result_fields))
         entities = [
-            {key: rec.get(key) for key in record_keys}
+            {
+                key: rec[key] if key in conditional_keys else rec.get(key)
+                for key in record_keys
+                if key not in conditional_keys or key in rec
+            }
             for rec in _as_record_list(component_result.get("entities"))
         ]
         entity_has_more = bool(component_result.get("entity_has_more", False))
@@ -1310,7 +1387,7 @@ def _build_domain_only_by_domain(
     """Build the by_domain dict for domain-listing mode (all results are one domain)."""
     items = results[:per_domain_limit] if per_domain_limit is not None else results
     if parsed_result_fields is not None:
-        items = _project_records(items, parsed_result_fields)
+        items = _project_records(items, _effective_result_fields(parsed_result_fields))
     return {domain: items}
 
 
@@ -1491,6 +1568,9 @@ def _match_exact_search_entity(
     visibility_hidden: set[str],
     hidden_ids: set[str],
     include_hidden: bool,
+    *,
+    membership_fields: tuple[str, ...] = (),
+    denied_member_ids: set[str],
 ) -> dict[str, Any] | None:
     """Score a single entity for ``_exact_match_search``, or None if it's excluded/no match."""
     entity_id = entity.get("entity_id", "")
@@ -1518,7 +1598,7 @@ def _match_exact_search_entity(
     score = 100 if is_exact else 80
     if is_hidden:
         score = apply_hidden_penalty(score, "_hidden")
-    return {
+    record = {
         "entity_id": entity_id,
         "friendly_name": friendly_name,
         "domain": domain,
@@ -1526,6 +1606,13 @@ def _match_exact_search_entity(
         "score": score,
         "match_type": "exact_match",
     }
+    _add_membership_fields(
+        record,
+        attributes,
+        membership_fields,
+        denied_member_ids=denied_member_ids,
+    )
+    return record
 
 
 async def _exact_match_search(
@@ -1539,6 +1626,7 @@ async def _exact_match_search(
     *,
     prefetched_states: list[dict[str, Any]] | None = None,
     prefetched_registry: Any = None,
+    membership_fields: tuple[str, ...] = (),
 ) -> dict[str, Any]:
     """
     Search entities by substring on entity_id + friendly_name.
@@ -1607,6 +1695,9 @@ async def _exact_match_search(
     )
 
     query_lower = query.lower().strip()
+    denied_member_ids = visibility_hidden | (
+        hidden_ids if not include_hidden else set()
+    )
 
     results = []
     for entity in all_entities:
@@ -1617,6 +1708,8 @@ async def _exact_match_search(
             visibility_hidden,
             hidden_ids,
             include_hidden,
+            membership_fields=membership_fields,
+            denied_member_ids=denied_member_ids,
         )
         if match is not None:
             results.append(match)
@@ -1808,8 +1901,15 @@ class SearchTools:
                     "Project each entity-registry record to only the specified "
                     'keys (e.g. ["entity_id", "state"]). None = full records. '
                     "Base keys: entity_id, friendly_name, domain, state, score, "
-                    "match_type. Opt-in enrichment keys (joined on request): "
-                    "area, floor, labels, aliases. An unknown key is rejected."
+                    "match_type. Opt-in enrichment/membership keys (computed on request): "
+                    "area, floor, labels, aliases, is_group, member_entity_ids. "
+                    "Membership is recognized only when HA explicitly exposes a "
+                    "valid group_entities or legacy entity_id collection; "
+                    "member IDs are sorted, direct (not recursively expanded), "
+                    "and omitted if visibility/include_hidden excludes a member. "
+                    "is_group remains true when member IDs are withheld; requesting "
+                    "member_entity_ids also retains is_group. "
+                    "An unknown key is rejected."
                 ),
             ),
         ] = None,
@@ -1871,6 +1971,13 @@ class SearchTools:
         Use this whenever you need to find something in HA without deciding
         entity-name vs config-body search up front.
 
+        For control requests with exclusions such as "except", "excluding", or
+        "but not", include `is_group` and `member_entity_ids` in `result_fields`.
+        Do not control an aggregate whose members include an excluded entity;
+        prefer leaf entities when the exception cannot be verified safely.
+        A withheld member list still returns is_group=true; absence of
+        member_entity_ids must not be interpreted as a leaf entity.
+
         When NOT to use:
           - To read a known entity_id's state: use `ha_get_state` (cheaper).
           - To inspect one automation/script/scene config by id: use the
@@ -1901,6 +2008,10 @@ class SearchTools:
         Examples:
             - List sensors in an area: ha_search(domain_filter="sensor", area_filter="Living Room")
             - Find a light by name: ha_search("kitchen", domain_filter="light")
+            - Find lights safely before an "all except one" control request:
+              ha_search("living room", domain_filter="light",
+              result_fields=["entity_id", "friendly_name", "is_group",
+              "member_entity_ids"])
             - Which automations use an entity: ha_search("light.bed_light")
             - Scenes touching a light: ha_search("light.kitchen", search_types=["scene"])
             - Narrow the response to the entity bucket: ha_search("kitchen", fields=["entities"])
@@ -2016,7 +2127,10 @@ class SearchTools:
             and _component_serves_search_types(req)
         ):
             caps = await get_component_caps(self._client)
-            if component_supports(caps, "search"):
+            if component_supports(caps, "search") and (
+                not _requested_membership(parsed_result_fields)
+                or component_supports(caps, "search_entity_membership")
+            ):
                 (
                     route_component,
                     visibility,
@@ -2356,7 +2470,7 @@ class SearchTools:
                     'E.g. ["entity_id", "state"] returns slim entity records. '
                     "None = full records (default). "
                     "Base keys: entity_id, friendly_name, domain, state, score, match_type. "
-                    "Opt-in enrichment keys (joined on request): area, floor, labels, aliases. "
+                    "Opt-in enrichment/membership keys (computed on request): area, floor, labels, aliases, is_group, member_entity_ids. "
                     "An unknown key is rejected."
                 ),
             ),
@@ -2402,6 +2516,11 @@ class SearchTools:
                     area_filter,
                     group_by_domain=True,
                     include_hidden=include_hidden_bool,
+                    **(
+                        {"include_membership": True}
+                        if _requested_membership(parsed_result_fields)
+                        else {}
+                    ),
                 )
                 if query and query.strip():
                     area_search = await self._search_area_with_query(
@@ -2754,7 +2873,7 @@ class SearchTools:
         entities_for_search = [
             {
                 "entity_id": entity.get("entity_id", ""),
-                "attributes": {"friendly_name": entity.get("friendly_name", "")},
+                "attributes": entity.get("_attributes", {}),
                 "state": entity.get("state", "unknown"),
                 "_aliases": aliases_map.get(entity.get("entity_id", ""), []),
                 "_hidden_by": entity.get("_hidden_by"),
@@ -2780,6 +2899,21 @@ class SearchTools:
             for match in matches
         ]
 
+        membership_fields = _requested_membership(parsed_result_fields)
+        attributes_by_id = {
+            entity.get("entity_id"): entity.get("_attributes")
+            for entity in all_area_entities
+        }
+        for record in results:
+            # smart_entity_search already applied visibility redaction and
+            # preserved its sentinel on the private attributes payload.
+            _add_membership_fields(
+                record,
+                attributes_by_id.get(record["entity_id"]),
+                membership_fields,
+                denied_member_ids=set(),
+            )
+
         if state_filter:
             results = [r for r in results if _state_matches(r, state_filter)]
 
@@ -2856,10 +2990,21 @@ class SearchTools:
                         "domain": domain,
                         "score": apply_hidden_penalty(100, entity.get("_hidden_by")),
                         "match_type": "area_match",
+                        "attributes": entity.get("_attributes"),
                     }
                     for entity in entities
                 )
 
+        membership_fields = _requested_membership(parsed_result_fields)
+        for record in all_results:
+            # search_entities_by_area already applied visibility redaction and
+            # preserved its sentinel on the private attributes payload.
+            _add_membership_fields(
+                record,
+                record.pop("attributes", None),
+                membership_fields,
+                denied_member_ids=set(),
+            )
         all_results.sort(key=lambda x: (-x["score"], x["entity_id"]))
         if state_filter:
             all_results = [r for r in all_results if _state_matches(r, state_filter)]
@@ -3033,6 +3178,10 @@ class SearchTools:
             and eid not in visibility_hidden
             and (include_hidden_bool or eid not in hidden_ids)
         ]
+        membership_fields = _requested_membership(parsed_result_fields)
+        denied_member_ids = visibility_hidden | (
+            hidden_ids if not include_hidden_bool else set()
+        )
 
         # Score: 100 baseline for domain membership (exact, not fuzzy);
         # penalised for hidden entries so they sort below visible peers.
@@ -3043,16 +3192,21 @@ class SearchTools:
             score = apply_hidden_penalty(
                 100, "_hidden" if entity_id in hidden_ids else None
             )
-            scored_entities.append(
-                {
-                    "entity_id": entity_id,
-                    "friendly_name": attributes.get("friendly_name", entity_id),
-                    "domain": domain_filter,
-                    "state": entity.get("state", "unknown"),
-                    "score": score,
-                    "match_type": "domain_listing",
-                }
+            record = {
+                "entity_id": entity_id,
+                "friendly_name": attributes.get("friendly_name", entity_id),
+                "domain": domain_filter,
+                "state": entity.get("state", "unknown"),
+                "score": score,
+                "match_type": "domain_listing",
+            }
+            _add_membership_fields(
+                record,
+                attributes,
+                membership_fields,
+                denied_member_ids=denied_member_ids,
             )
+            scored_entities.append(record)
         scored_entities.sort(key=lambda x: (-x["score"], x["entity_id"]))
         if state_filter:
             scored_entities = [
@@ -3122,6 +3276,10 @@ class SearchTools:
             and _state_matches(e, state_filter)
             and (include_hidden_bool or eid not in hidden_ids)
         ]
+        membership_fields = _requested_membership(parsed_result_fields)
+        denied_member_ids = visibility_hidden | (
+            hidden_ids if not include_hidden_bool else set()
+        )
 
         # Score: 100 baseline for state membership (exact, not fuzzy); penalised
         # for hidden entries so they sort below visible peers. ``domain`` is
@@ -3133,16 +3291,21 @@ class SearchTools:
             score = apply_hidden_penalty(
                 100, "_hidden" if entity_id in hidden_ids else None
             )
-            scored_entities.append(
-                {
-                    "entity_id": entity_id,
-                    "friendly_name": attributes.get("friendly_name", entity_id),
-                    "domain": entity_id.split(".")[0],
-                    "state": entity.get("state", "unknown"),
-                    "score": score,
-                    "match_type": "state_listing",
-                }
+            record = {
+                "entity_id": entity_id,
+                "friendly_name": attributes.get("friendly_name", entity_id),
+                "domain": entity_id.split(".")[0],
+                "state": entity.get("state", "unknown"),
+                "score": score,
+                "match_type": "state_listing",
+            }
+            _add_membership_fields(
+                record,
+                attributes,
+                membership_fields,
+                denied_member_ids=denied_member_ids,
             )
+            scored_entities.append(record)
         scored_entities.sort(key=lambda x: (-x["score"], x["entity_id"]))
         results = scored_entities[offset : offset + limit]
 
@@ -3216,6 +3379,7 @@ class SearchTools:
                 state_filter=state_filter,
                 prefetched_states=prefetched_states,
                 prefetched_registry=prefetched_registry,
+                membership_fields=_requested_membership(parsed_result_fields),
             )
         else:
             # Fuzzy mode: BM25 → substring fallback on exception only.
@@ -3226,6 +3390,14 @@ class SearchTools:
                     offset=offset,
                     domain_filter=domain_filter,
                     include_hidden=include_hidden_bool,
+                    include_attributes=bool(
+                        _requested_membership(parsed_result_fields)
+                    ),
+                    **(
+                        {"include_membership": True}
+                        if _requested_membership(parsed_result_fields)
+                        else {}
+                    ),
                     prefetched_states=prefetched_states,
                     prefetched_registry=prefetched_registry,
                 )
@@ -3251,6 +3423,7 @@ class SearchTools:
                     state_filter=state_filter,
                     prefetched_states=prefetched_states,
                     prefetched_registry=prefetched_registry,
+                    membership_fields=_requested_membership(parsed_result_fields),
                 )
                 warning = "Fuzzy search unavailable, using substring match"
                 search_type = "exact_match"
@@ -3258,6 +3431,17 @@ class SearchTools:
         _normalize_regular_search_result(
             result, search_type, domain_filter, offset, limit
         )
+        if search_type == "fuzzy_search":
+            membership_fields = _requested_membership(parsed_result_fields)
+            for record in result.get("results", []):
+                # smart_entity_search already applied visibility redaction and
+                # preserved its sentinel on the private attributes payload.
+                _add_membership_fields(
+                    record,
+                    record.pop("attributes", None),
+                    membership_fields,
+                    denied_member_ids=set(),
+                )
 
         # Apply state_filter to fuzzy results BEFORE grouping so by_domain
         # stays consistent with results[]. For fuzzy_search, state_filter is