claude-smart 0.2.45 → 0.2.47

package/plugin/vendor/reflexio/reflexio/integrations/openclaw/plugin/vitest.config.ts

@@ -0,0 +1,18 @@
+import * as path from "node:path";
+import { defineConfig } from "vitest/config";
+
+export default defineConfig({
+  test: {
+    include: ["tests-ts/**/*.test.ts"],
+  },
+  resolve: {
+    alias: {
+      // The real openclaw plugin SDK ships with the host. Under vitest we
+      // shim only the surface the plugin imports.
+      "openclaw/plugin-sdk/plugin-entry": path.resolve(
+        __dirname,
+        "tests-ts/__mocks__/plugin-entry-stub.ts",
+      ),
+    },
+  },
+});

package/plugin/vendor/reflexio/reflexio/lib/_agent_playbook.py

@@ -1,8 +1,19 @@
+from __future__ import annotations
+
+import logging
+from collections import defaultdict
+from typing import Literal, cast
+
 from reflexio.lib._base import (
     STORAGE_NOT_CONFIGURED_MSG,
     ReflexioBase,
     _require_storage,
 )
+from reflexio.models.api_schema.domain.entities import (
+    PlaybookAggregationChangeLog,
+    agent_playbook_to_snapshot,
+)
+from reflexio.models.api_schema.domain.enums import Status
 from reflexio.models.api_schema.retriever_schema import (
     GetAgentPlaybooksRequest,
     GetAgentPlaybooksResponse,
@@ -24,29 +35,44 @@ from reflexio.models.api_schema.service_schemas import (
     PlaybookAggregationChangeLogResponse,
 )
 from reflexio.models.config_schema import SearchOptions
+from reflexio.server.services.storage.storage_base import BaseStorage
+from reflexio.server.services.storage.storage_base._playbook import (
+    AGGREGATE_REASON_PREFIX,
+)
 from reflexio.server.tracing import profile_step
 
 
 class AgentPlaybookMixin(ReflexioBase):
     def get_playbook_aggregation_change_logs(
-        self, playbook_name: str, agent_version: str
+        self,
+        playbook_name: str,
+        agent_version: str,
     ) -> PlaybookAggregationChangeLogResponse:
-        """Get playbook aggregation change logs.
+        """Get playbook aggregation change logs, served from the lineage reconstruction.
+
+        The change-log view is rebuilt on demand from ``lineage_event`` rows via
+        :func:`reconstruct_playbook_aggregation_change_log`. The legacy
+        ``playbook_aggregation_change_logs`` table is no longer read. Results are
+        filtered to entries matching ``playbook_name`` and ``agent_version``.
+        ``updated_agent_playbooks`` is always ``[]`` (tolerated parity delta — Decision 3).
 
         Args:
-            playbook_name (str): Playbook name to filter by
-            agent_version (str): Agent version to filter by
+            playbook_name (str): Filter — only logs for this playbook name are returned.
+            agent_version (str): Filter — only logs for this agent version are returned.
 
         Returns:
-            PlaybookAggregationChangeLogResponse: Response containing change logs
+            PlaybookAggregationChangeLogResponse: Response containing the reconstructed
+                change logs filtered by playbook_name and agent_version.
         """
         if not self._is_storage_configured():
             return PlaybookAggregationChangeLogResponse(success=True, change_logs=[])
-        change_logs = self._get_storage().get_playbook_aggregation_change_logs(
-            playbook_name=playbook_name, agent_version=agent_version
-        )
-        return PlaybookAggregationChangeLogResponse(
-            success=True, change_logs=change_logs
+        # Legacy table no longer read; served by reconstruction filtered by
+        # playbook_name + agent_version. updated_agent_playbooks is always []
+        # (tolerated parity delta).
+        return reconstruct_playbook_aggregation_change_log(
+            self._get_storage(),
+            playbook_name=playbook_name,
+            agent_version=agent_version,
         )
 
     @_require_storage(DeleteAgentPlaybookResponse)
@@ -187,12 +213,21 @@ class AgentPlaybookMixin(ReflexioBase):
         try:
             agent_playbooks = self._get_storage().get_agent_playbooks(
                 limit=request.limit or 100,
+                agent_playbook_id=request.agent_playbook_id,
+                query=request.query,
                 playbook_name=request.playbook_name,
                 agent_version=request.agent_version,
+                start_time=(
+                    int(request.start_time.timestamp()) if request.start_time else None
+                ),
+                end_time=(
+                    int(request.end_time.timestamp()) if request.end_time else None
+                ),
                 status_filter=request.status_filter,
                 playbook_status_filter=[request.playbook_status_filter]
                 if request.playbook_status_filter
                 else None,
+                tags=request.tags,
             )
             return GetAgentPlaybooksResponse(
                 success=True,
@@ -308,3 +343,204 @@ class AgentPlaybookMixin(ReflexioBase):
         return UpdateAgentPlaybookResponse(
             success=True, msg="Agent playbook updated successfully"
         )
+
+
+# ---------------------------------------------------------------------------
+# Standalone read-side reconstruction (Phase B3b Task 2)
+# ---------------------------------------------------------------------------
+
+logger = logging.getLogger(__name__)
+
+# Prefix for aggregate lineage event reasons — single source of truth in
+# AGGREGATE_REASON_PREFIX (storage_base/_playbook.py); imported here for the parser.
+_PREFIX = AGGREGATE_REASON_PREFIX
+
+
+def reconstruct_playbook_aggregation_change_log(
+    storage: BaseStorage,
+    *,
+    limit: int = 100,
+    playbook_name: str | None = None,
+    agent_version: str | None = None,
+) -> PlaybookAggregationChangeLogResponse:
+    """Rebuild the PlaybookAggregationChangeLog view from lineage events.
+
+    Uses two immutable / stable signals to classify every aggregation run:
+
+    * **added(R)** — entity_ids of ``aggregate`` lineage events with
+      ``request_id == R``.  Each ``aggregate`` event records one playbook
+      saved in the run.  The ``reason`` field encodes the run mode:
+      ``"aggregate:full_archive"`` or ``"aggregate:incremental"``; any other
+      value defaults to ``"incremental"``.
+
+    * **removed(R)** — entity_ids of ``status_change`` lineage events with
+      ``to_status == "superseded"`` and ``request_id == R``.  This is the
+      exact signature emitted by ``supersede_agent_playbooks_by_ids`` and
+      ``supersede_agent_playbooks_by_playbook_name`` (the soft-delete paths).
+      APPROVED playbooks are skipped by those helpers, so they have no removal
+      signal and are correctly absent from reconstruction.removed.
+
+    Groups are formed over the union of request_ids from both signals.
+    Request_id ``""`` is skipped — it would merge unrelated runs.
+    A row is emitted only when ``added or removed`` is non-empty.
+
+    When a removed playbook's tombstone has been physically purged (GC),
+    it is silently omitted from ``removed_agent_playbooks`` rather than crashing.
+
+    ``updated_agent_playbooks = []`` (Decision 3 — tolerated delta; updates
+    are folded into added/removed in the B3b reconstruction model).
+
+    An agent_playbook *added* in run R is included in R's
+    ``added_agent_playbooks`` even if a later run superseded (tombstoned) it
+    (resolved with ``include_tombstones=True``) — so R is not dropped from the
+    change log, matching the legacy table and ``reconstruct_profile_change_log``.
+    As with the removed side, once a tombstone is physically purged (GC) the
+    snapshot resolves to ``None`` and is silently omitted.
+
+    Version-semantics note (E1): for remove-only runs with mixed agent_version
+    across the superseded set, ``agent_version`` is that of the first resolved
+    removed snapshot.  This is a query-VISIBILITY loss — version-filtered
+    queries will omit those removals — not just a label ambiguity.
+
+    Run-scalars (``playbook_name``, ``agent_version``) are read from the
+    reconstructed content: ``added[0]`` is preferred, else ``removed[0]``.
+    For a remove-only run whose superseded playbooks span multiple versions,
+    ``agent_version`` is that of the first resolved removed snapshot — a
+    tolerated, documented ambiguity (the aggregate event carries no version
+    since remove-only runs emit no aggregate event).
+
+    Args:
+        storage (BaseStorage): Storage instance to query.
+        limit (int): Maximum number of reconstructed entries to return.
+            Defaults to 100.
+        playbook_name (str | None): When provided, only logs whose
+            ``playbook_name`` matches are returned. Defaults to ``None``
+            (no filter).
+        agent_version (str | None): When provided, only logs whose
+            ``agent_version`` matches are returned. Defaults to ``None``
+            (no filter).
+
+    Returns:
+        PlaybookAggregationChangeLogResponse: ``success=True`` with
+            reconstructed rows ordered most-recent-first (by max event
+            ``created_at`` in each request_id group), filtered by
+            ``playbook_name``/``agent_version`` when supplied, and capped
+            at ``limit``.
+    """
+    if limit <= 0:
+        return PlaybookAggregationChangeLogResponse(success=True, change_logs=[])
+
+    all_events = storage.get_lineage_events(
+        entity_type="agent_playbook", org_id=storage.org_id
+    )
+
+    added_by_req: dict[str, list[str]] = defaultdict(list)
+    removed_by_req: dict[str, list[str]] = defaultdict(list)
+    run_mode_by_req: dict[str, Literal["full_archive", "incremental"]] = {}
+    sort_key: dict[str, tuple[int, int]] = {}
+
+    for evt in all_events:
+        req = evt.request_id
+        if not req:
+            continue  # skip empty — never merge unrelated runs
+        cur = sort_key.get(req, (0, 0))
+        if (evt.created_at, evt.event_id) > cur:
+            sort_key[req] = (evt.created_at, evt.event_id)
+        if evt.op == "aggregate":
+            added_by_req[req].append(evt.entity_id)
+            if req not in run_mode_by_req:
+                reason = evt.reason or ""
+                if reason.startswith(_PREFIX):
+                    suffix = reason[len(_PREFIX) :]
+                    run_mode_by_req[req] = cast(
+                        Literal["full_archive", "incremental"],
+                        suffix
+                        if suffix in ("full_archive", "incremental")
+                        else "incremental",
+                    )
+                else:
+                    run_mode_by_req[req] = "incremental"
+        elif evt.op == "status_change" and evt.to_status == Status.SUPERSEDED.value:
+            removed_by_req[req].append(evt.entity_id)
+
+    candidate_reqs = set(added_by_req) | set(removed_by_req)
+    sorted_reqs = sorted(
+        candidate_reqs,
+        key=lambda r: sort_key.get(r, (0, 0)),
+        reverse=True,
+    )
+
+    logs: list[PlaybookAggregationChangeLog] = []
+    # PERFORMANCE NOTE (M3): as of Track B retirement this serves the live
+    # ``/api/playbook_aggregation_change_logs`` endpoint (the legacy table is no
+    # longer read), so it IS on the request path. Two bounds keep it from scaling
+    # with full org history: (1) the lineage-event read is paginated in the
+    # Supabase backend (``get_lineage_events`` loops ``.range()`` windows), so
+    # PostgREST ``max_rows`` can no longer silently truncate to the oldest rows;
+    # (2) name/version filtering AND the ``limit`` are applied INSIDE this loop and
+    # we ``break`` once ``limit`` matches are collected, so the per-entity
+    # ``get_agent_playbook_by_id`` (N+1) resolution stops at the requested page
+    # instead of resolving every run in the org. ``sorted_reqs`` is most-recent
+    # first, so breaking after ``limit`` matches yields the ``limit`` most-recent
+    # matches. Remaining follow-up (tracked, NOT done here): a batch ``*_by_ids``
+    # fetch shared with ``reconstruct_profile_change_log``.
+    for req in sorted_reqs:
+        added = []
+        for eid in added_by_req[req]:
+            try:
+                # include_tombstones: a playbook added in this run but later
+                # superseded must still appear in this run's added side (so the
+                # run is not dropped) — mirrors the removed-side resolve below.
+                pb = storage.get_agent_playbook_by_id(int(eid), include_tombstones=True)
+            except (ValueError, TypeError):
+                logger.warning(
+                    "reconstruct: malformed entity_id %r in added_by_req, skipping", eid
+                )
+                continue
+            if pb is not None:
+                added.append(agent_playbook_to_snapshot(pb))
+
+        removed = []
+        for eid in removed_by_req[req]:
+            try:
+                pb = storage.get_agent_playbook_by_id(int(eid), include_tombstones=True)
+            except (ValueError, TypeError):
+                logger.warning(
+                    "reconstruct: malformed entity_id %r in removed_by_req, skipping",
+                    eid,
+                )
+                continue
+            if pb is not None:
+                removed.append(agent_playbook_to_snapshot(pb))
+
+        if not added and not removed:
+            continue
+
+        # agent_version is the run's REPRESENTATIVE snapshot version (added[0], else
+        # removed[0]). For a remove-only run whose superseded playbooks span multiple
+        # versions, the label is that of the first resolved removed snapshot — a
+        # tolerated, documented ambiguity (the aggregate event carries no version).
+        first = added[0] if added else removed[0]
+        # Filter INSIDE the loop so the ``limit`` is applied to the post-filter
+        # set (not a pre-filter slice) AND we can stop once the page is full.
+        if playbook_name is not None and first.playbook_name != playbook_name:
+            continue
+        if agent_version is not None and first.agent_version != agent_version:
+            continue
+
+        ts, _ = sort_key.get(req, (0, 0))
+        logs.append(
+            PlaybookAggregationChangeLog(
+                playbook_name=first.playbook_name,
+                agent_version=first.agent_version,
+                run_mode=run_mode_by_req.get(req, "incremental"),
+                added_agent_playbooks=added,
+                removed_agent_playbooks=removed,
+                updated_agent_playbooks=[],
+                created_at=ts,
+            )
+        )
+        if len(logs) >= limit:  # limit > 0 guaranteed above
+            break
+
+    return PlaybookAggregationChangeLogResponse(success=True, change_logs=logs)

package/plugin/vendor/reflexio/reflexio/lib/_base.py

@@ -127,6 +127,21 @@ class ReflexioBase:
             raise RuntimeError(STORAGE_NOT_CONFIGURED_MSG)
         return storage
 
+    def get_storage(self) -> BaseStorage:
+        """Return the configured storage backend.
+
+        Public accessor for consumers (including enterprise) that need the
+        underlying ``BaseStorage``. Prefer ``request_context.storage`` inside
+        OSS pipeline code; this exists for callers that hold a ``Reflexio``.
+
+        Returns:
+            BaseStorage: The configured storage backend.
+
+        Raises:
+            RuntimeError: If storage is not configured.
+        """
+        return self._get_storage()
+
     def _get_query_reformulator(self) -> QueryReformulator:
         """Lazily create and cache a QueryReformulator instance.
 

package/plugin/vendor/reflexio/reflexio/lib/_config.py

@@ -2,7 +2,7 @@ from typing import Any
 
 from reflexio.lib._base import ReflexioBase
 from reflexio.models.api_schema.retriever_schema import SetConfigResponse
-from reflexio.models.config_schema import Config
+from reflexio.models.config_schema import Config, StorageConfigManagedSupabase
 
 
 class ConfigMixin(ReflexioBase):
@@ -22,10 +22,17 @@ class ConfigMixin(ReflexioBase):
                 config = Config(**config)
 
             # Validate storage connection before setting config.
-            # If no storage_config provided, preserve the existing one (callers
-            # like get_config() don't expose storage_config for security).
+            # If no storage_config provided, or the caller round-tripped the
+            # redacted platform-managed marker that get_config() emits in place
+            # of real credentials, preserve the existing storage configuration
+            # (callers like get_config() don't expose storage_config for
+            # security). Without this, the marker reaches the readiness check as
+            # an unfillable StorageConfigManagedSupabase and fails with
+            # "Storage configuration is incomplete".
             storage_config = config.storage_config
-            if storage_config is None:
+            if storage_config is None or isinstance(
+                storage_config, StorageConfigManagedSupabase
+            ):
                 storage_config = configurator.get_current_storage_configuration()
                 config.storage_config = storage_config
 

package/plugin/vendor/reflexio/reflexio/lib/_generation.py

@@ -38,17 +38,29 @@ class GenerationMixin(ReflexioBase):
         """
         if not self._is_storage_configured():
             raise ValueError(STORAGE_NOT_CONFIGURED_MSG)
-        from reflexio.server.services.playbook.playbook_aggregator import (
+        from reflexio.server.extensions import get_service
+        from reflexio.server.services.playbook.aggregation_prompt_processing import (
+            AGGREGATION_PROMPT_PROCESSOR,
+        )
+        from reflexio.server.services.playbook.components.aggregator import (
             PlaybookAggregator,
         )
         from reflexio.server.services.playbook.playbook_service_utils import (
             PlaybookAggregatorRequest,
         )
 
+        aggregation_prompt_processor = get_service(AGGREGATION_PROMPT_PROCESSOR)
+        aggregator_kwargs = {}
+        if aggregation_prompt_processor is not None:
+            aggregator_kwargs["aggregation_prompt_processor"] = (
+                aggregation_prompt_processor
+            )
+
         playbook_aggregator = PlaybookAggregator(
             llm_client=self.llm_client,
             request_context=self.request_context,
             agent_version=agent_version,
+            **aggregator_kwargs,
         )
         aggregator_request = PlaybookAggregatorRequest(
             agent_version=agent_version,
@@ -88,7 +100,7 @@ class GenerationMixin(ReflexioBase):
         Returns:
             RerunProfileGenerationResponse: Response containing success status, message, and count of profiles generated
         """
-        from reflexio.server.services.profile.profile_generation_service import (
+        from reflexio.server.services.profile.service import (
             ProfileGenerationService,
         )
 
@@ -113,7 +125,7 @@ class GenerationMixin(ReflexioBase):
         Returns:
             ManualProfileGenerationResponse: Response containing success status, message, and count of profiles generated
         """
-        from reflexio.server.services.profile.profile_generation_service import (
+        from reflexio.server.services.profile.service import (
             ProfileGenerationService,
         )
 
@@ -138,7 +150,7 @@ class GenerationMixin(ReflexioBase):
         Returns:
             RerunPlaybookGenerationResponse: Response containing success status, message, and count of playbooks generated
         """
-        from reflexio.server.services.playbook.playbook_generation_service import (
+        from reflexio.server.services.playbook.service import (
             PlaybookGenerationService,
         )
 
@@ -163,7 +175,7 @@ class GenerationMixin(ReflexioBase):
         Returns:
             ManualPlaybookGenerationResponse: Response containing success status, message, and count of playbooks generated
         """
-        from reflexio.server.services.playbook.playbook_generation_service import (
+        from reflexio.server.services.playbook.service import (
             PlaybookGenerationService,
         )
 

package/plugin/vendor/reflexio/reflexio/lib/_lineage_parity_readers.py

@@ -0,0 +1,187 @@
+"""Read-only PostgREST storage reader for change-log reconstruction.
+
+``RestStorageReader`` exposes only the read methods that
+``reconstruct_profile_change_log`` calls (the ``ChangeLogReadStorage``
+protocol), sourced from Supabase **PostgREST GETs**. It is deliberately NOT a
+``BaseStorage`` subclass and performs **no writes** — so it can be pointed at a
+production data ref to run the reconstruction without the side effects of
+constructing the real ``SupabaseStorage`` (whose ``__init__`` can mutate
+PostgREST schema config).
+
+The HTTP layer is injectable (``fetch``) so the reconstruction pipeline can be
+unit-tested with canned rows and no network.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Callable
+from urllib.parse import urlparse
+
+from reflexio.models.api_schema.domain.entities import (
+    LineageEvent,
+    UserProfile,
+)
+
+# Page size for unbounded reads. A read returning a full page may be truncated,
+# which would silently skew the reconstruction — so reaching it flips
+# ``truncated`` and callers can surface the run as untrustworthy.
+_FETCH_CAP = 10_000
+
+_LINEAGE_EVENT_FIELDS = set(LineageEvent.model_fields)
+_USER_PROFILE_FIELDS = set(UserProfile.model_fields)
+
+# Explicit column list for profiles — avoids pulling the embedding/FTS columns.
+_PROFILE_COLUMNS = (
+    "profile_id,user_id,content,last_modified_timestamp,"
+    "generated_from_request_id,status,superseded_by,merged_into,source"
+)
+
+Fetch = Callable[[str, dict], list[dict]]
+
+
+def _model[M](cls: type[M], fields: set[str], row: dict) -> M:
+    """Build a Pydantic model from a row, ignoring columns it does not declare."""
+    return cls(**{k: v for k, v in row.items() if k in fields})
+
+
+class RestStorageReader:
+    """Read-only PostgREST reader implementing the parity-check read surface."""
+
+    def __init__(
+        self,
+        base_url: str,
+        api_key: str,
+        *,
+        org_id: str,
+        schema: str = "public",
+        fetch: Fetch | None = None,
+    ) -> None:
+        # The api_key is a service_role credential (RLS-bypassing). Refuse to
+        # attach it to anything but an https Supabase host, so a typo'd or
+        # hostile --supabase-url cannot exfiltrate it.
+        host = urlparse(base_url).hostname or ""
+        if urlparse(base_url).scheme != "https" or not host.endswith(".supabase.co"):
+            raise ValueError(
+                f"base_url must be an https://<ref>.supabase.co URL; got {base_url!r}"
+            )
+        self.org_id = org_id
+        self._base = base_url.rstrip("/")
+        self._key = api_key
+        self._schema = schema
+        self._fetch: Fetch = fetch or self._http_fetch
+        # Set when any unbounded read returns a full _FETCH_CAP page: the
+        # reconstruction inputs may be truncated, so the verdict is untrustworthy.
+        self.truncated = False
+
+    def _http_fetch(self, table: str, params: dict) -> list[dict]:
+        import requests  # noqa: PLC0415 — only needed on the live path
+
+        headers = {"apikey": self._key, "Authorization": f"Bearer {self._key}"}
+        # Non-public schemas (the shared org_<id> cohort) are selected per-request
+        # via Accept-Profile; dedicated refs keep data in public.
+        if self._schema and self._schema != "public":
+            headers["Accept-Profile"] = self._schema
+        resp = requests.get(
+            f"{self._base}/rest/v1/{table}",
+            headers=headers,
+            params=params,
+            timeout=30,
+            allow_redirects=False,  # never forward the service_role key on a 3xx
+        )
+        if resp.is_redirect:
+            raise RuntimeError(
+                f"PostgREST returned a redirect for {table!r} — refusing to follow it "
+                "and forward credentials. Check --supabase-url."
+            )
+        if resp.status_code in (401, 403):
+            raise RuntimeError(
+                f"PostgREST {resp.status_code} for {table!r}: the service_role key is "
+                "not valid for this data ref (keys are per-ref / per-server)."
+            )
+        if resp.status_code in (404, 406):
+            raise RuntimeError(
+                f"PostgREST {resp.status_code} for {table!r}: table/schema not exposed "
+                f"— check --schema (got {self._schema!r}; use org_<id> for the shared cohort)."
+            )
+        resp.raise_for_status()
+        return resp.json()
+
+    def _note_page(self, rows: list[dict]) -> list[dict]:
+        """Flag a possibly-truncated read (a full page may have more behind it)."""
+        if len(rows) >= _FETCH_CAP:
+            self.truncated = True
+        return rows
+
+    def get_lineage_events(
+        self,
+        *,
+        entity_type: str | None = None,
+        entity_id: str | None = None,
+        org_id: str | None = None,
+        request_id: str | None = None,
+    ) -> list[LineageEvent]:
+        params: dict = {"select": "*", "order": "event_id.asc", "limit": _FETCH_CAP}
+        if entity_type:
+            params["entity_type"] = f"eq.{entity_type}"
+        if entity_id:
+            params["entity_id"] = f"eq.{entity_id}"
+        if request_id:
+            params["request_id"] = f"eq.{request_id}"
+        if org_id:
+            params["org_id"] = f"eq.{org_id}"
+        rows = self._note_page(self._fetch("lineage_event", params))
+        return [_model(LineageEvent, _LINEAGE_EVENT_FIELDS, r) for r in rows]
+
+    def get_distinct_generated_from_request_ids(self) -> list[str]:
+        rows = self._note_page(
+            self._fetch(
+                "profiles",
+                {"select": "generated_from_request_id", "limit": _FETCH_CAP},
+            )
+        )
+        return sorted(
+            {
+                r["generated_from_request_id"]
+                for r in rows
+                if r.get("generated_from_request_id")
+            }
+        )
+
+    def get_profiles_by_generated_from_request_id(
+        self, request_id: str
+    ) -> list[UserProfile]:
+        rows = self._note_page(
+            self._fetch(
+                "profiles",
+                {
+                    "select": _PROFILE_COLUMNS,
+                    "generated_from_request_id": f"eq.{request_id}",
+                    "limit": _FETCH_CAP,
+                },
+            )
+        )
+        return [_model(UserProfile, _USER_PROFILE_FIELDS, r) for r in rows]
+
+    def get_all_generated_profiles(self) -> list[UserProfile]:
+        # Fetch all profiles in one page and filter non-empty gfr client-side
+        # (mirrors get_distinct; avoids PostgREST empty-string operator ambiguity).
+        rows = self._note_page(
+            self._fetch("profiles", {"select": _PROFILE_COLUMNS, "limit": _FETCH_CAP})
+        )
+        return [
+            _model(UserProfile, _USER_PROFILE_FIELDS, r)
+            for r in rows
+            if r.get("generated_from_request_id")
+        ]
+
+    def get_profile_by_id(
+        self,
+        profile_id: str,
+        *,
+        include_tombstones: bool = False,  # noqa: ARG002 — id lookup always returns tombstones
+    ) -> UserProfile | None:
+        rows = self._fetch(
+            "profiles",
+            {"select": _PROFILE_COLUMNS, "profile_id": f"eq.{profile_id}", "limit": 1},
+        )
+        return _model(UserProfile, _USER_PROFILE_FIELDS, rows[0]) if rows else None