fix(storage): native read transport, governance extraction, and SQLite dataset isolation

reflexio/models/api_schema/domain/__init__.py

@@ -1,4 +1,3 @@
 from ..common import *  # noqa: F401, F403
 from .entities import *  # noqa: F401, F403
 from .enums import *  # noqa: F401, F403
-from .governance import *  # noqa: F401, F403

reflexio/models/api_schema/domain/entities.py

@@ -158,7 +158,6 @@
     "GetOperationStatusResponse",
     "CancelOperationRequest",
     "CancelOperationResponse",
-    "ShareLink",
     "AdminInvalidateCacheRequest",
     "AdminInvalidateCacheResponse",
     "LineageEvent",
@@ -951,30 +950,6 @@ class RecordRef(BaseModel):
     is_purged: bool = False
 
 
-class ShareLink(BaseModel):
-    """A shareable public link that maps a token to a resource within an org.
-
-    Args:
-        id (int): Primary key assigned by the storage layer.
-        org_id (str): The organization that owns the share link.
-        token (str): The share token (unique). Format: shr_<org_id_b64>.<random>.
-        resource_type (str): One of "profile", "request", "session", "user_playbook", "agent_playbook".
-        resource_id (str): The ID of the resource being shared.
-        created_at (int | None): Unix timestamp of creation.
-        expires_at (int | None): Optional Unix timestamp of expiration. None means never expires.
-        created_by_email (str | None): Optional email of the user who created the link.
-    """
-
-    id: int
-    org_id: str
-    token: str
-    resource_type: str
-    resource_id: str
-    created_at: int | None = None
-    expires_at: int | None = None
-    created_by_email: str | None = None
-
-
 # ===============================
 # Request Models
 # ===============================

reflexio/server/api.py

@@ -65,6 +65,7 @@
     search,
     system,
 )
+from reflexio.server.validation_errors import safe_validation_errors
 
 logger = logging.getLogger(__name__)
 
@@ -156,11 +157,9 @@ async def _safe_request_validation_exception_handler(
     errors = exc.errors()
     if not any(_contains_non_finite_number(error.get("input")) for error in errors):
         return await request_validation_exception_handler(request, exc)
-    safe_errors = [
-        {key: value for key, value in error.items() if key not in {"input", "ctx"}}
-        for error in errors
-    ]
-    return JSONResponse(status_code=422, content={"detail": safe_errors})
+    return JSONResponse(
+        status_code=422, content={"detail": safe_validation_errors(errors)}
+    )
 
 
 def _add_openapi_security(app: FastAPI) -> None:

reflexio/server/callback_executor.py

@@ -20,6 +20,7 @@
 from typing import NamedTuple
 
 from reflexio.server.error_reporting import capture_anomaly
+from reflexio.server.work_scope import WorkScopeError
 
 logger = logging.getLogger(__name__)
 
@@ -152,6 +153,24 @@ def _worker_loop(self) -> None:
                 self._active += 1
             try:
                 fn()
+            except WorkScopeError:
+                # A scope/attribution failure is NOT an operational error, so it
+                # does not belong in the blanket branch below where it would be
+                # one more indistinguishable log line. It gets its own event and
+                # is escalated through the error-reporting seam.
+                #
+                # Escalated, NOT propagated: this is the top frame of a daemon
+                # worker: an exception let out here kills the thread, and after
+                # 16 of them the pool is gone and ALL deferred work stops
+                # silently. Reporting is strictly more observable than dying.
+                logger.exception(
+                    "event=callback_executor_work_scope_failed name=%s", name
+                )
+                capture_anomaly(
+                    "callback_executor.work_scope_failed",
+                    level="error",
+                    callback=name,
+                )
             except BaseException:  # noqa: BLE001 — daemon worker threads must
                 # survive anything a callback raises (including a callback
                 # that itself raises SystemExit); KeyboardInterrupt is only

reflexio/server/routes/config.py

@@ -34,6 +34,7 @@
 from reflexio.server.services.configurator.config_storage import (
     ConfigWriteConflictError,
 )
+from reflexio.server.validation_errors import safe_validation_errors
 
 logger = logging.getLogger(__name__)
 router = APIRouter()
@@ -123,15 +124,15 @@ def set_config(
     reflexio = reflexio_cache.get_reflexio(org_id=org_id)
     configurator = reflexio.request_context.configurator
     config = _reject_direct_experiment_mutation(
-        config, configurator.get_config(), preserve_missing=True
+        config, configurator.get_org_config(), preserve_missing=True
     )
     try:
         normalized_config = configurator.normalize_config_payload(config)
         Config.model_validate(normalized_config)
     except ValidationError as exc:
         raise HTTPException(
             status_code=status.HTTP_422_UNPROCESSABLE_CONTENT,
-            detail=exc.errors(),
+            detail=safe_validation_errors(exc.errors()),
         ) from exc
 
     # Set the config using Reflexio's set_config method
@@ -199,7 +200,7 @@ def update_config(
 
     reflexio = reflexio_cache.get_reflexio(org_id=org_id)
     configurator = reflexio.request_context.configurator
-    existing_config = configurator.get_config()
+    existing_config = configurator.get_org_config()
     partial = _reject_direct_experiment_mutation(
         partial, existing_config, preserve_missing=False
     )
@@ -222,7 +223,7 @@ def update_config(
                     "/api/get_config, edit, and POST it back via "
                     "/api/set_config."
                 ),
-                "validation_errors": exc.errors(),
+                "validation_errors": safe_validation_errors(exc.errors()),
             },
         ) from exc
     partial_uses_only_shared_fields = (

reflexio/server/services/agent_success_evaluation/scheduler.py

@@ -16,7 +16,9 @@
 from functools import partial
 
 from reflexio.server.callback_executor import submit_callback
+from reflexio.server.error_reporting import capture_anomaly
 from reflexio.server.services.agent_success_evaluation import _eval_health
+from reflexio.server.work_scope import WorkScope, WorkScopeError, bind_work_scope
 
 logger = logging.getLogger(__name__)
 
@@ -34,8 +36,14 @@
 IS_TEST_ENV = os.environ.get("IS_TEST_ENV", "false").strip() == "true"
 _EFFECTIVE_DELAY_SECONDS = 30 if IS_TEST_ENV else GROUP_EVALUATION_DELAY_SECONDS
 
-# Type alias for the scheduling key
-GroupKey = tuple[str, str, str]  # (org_id, user_id, session_id)
+# Type alias for the scheduling key.
+# (org_id, project_id, user_id, session_id)
+#
+# ``project_id`` is part of the DEBOUNCE IDENTITY, not decoration. Two projects
+# in one org evaluating the same user/session inside one inactivity window would
+# otherwise collapse into a single evaluation attributed to whichever request
+# won the race. ``None`` in OSS, where projects do not exist.
+GroupKey = tuple[str, str | None, str, str]
 
 
 class GroupEvaluationScheduler:
@@ -138,7 +146,8 @@ def _scheduler_loop(self) -> None:
                         del self._scheduled[key]
 
                         submit_callback(
-                            f"group-eval-{key[2][:20]}",
+                            # key[3] is session_id — key[1] is the nullable project.
+                            f"group-eval-{key[3][:20]}",
                             partial(self._run_callback, key, callback),
                         )
 
@@ -157,6 +166,19 @@ def _run_callback(key: GroupKey, callback: Callable) -> None:
         """
         try:
             logger.info("Firing group evaluation for key=%s", key)
-            callback()
+            with bind_work_scope(WorkScope(org_id=key[0], project_id=key[1])):
+                callback()
+        except WorkScopeError:
+            # NOT an operational failure: the evaluation could not be attributed
+            # to a project, so tolerating it would write it under the wrong one.
+            # Escalated rather than propagated — see WorkScopeError.
+            logger.exception("Group evaluation scope binding failed for key=%s", key)
+            capture_anomaly(
+                "agent_success_evaluation.work_scope_failed",
+                level="error",
+                org_id=key[0],
+                project_id=key[1],
+                user_id=key[2],
+            )
         except Exception:
             logger.exception("Group evaluation callback failed for key=%s", key)

reflexio/server/services/configurator/base_configurator.py

@@ -72,6 +72,24 @@ def _select_config_storage(
     # ==========================
 
     def get_config(self) -> Config:
+        """Return the config callers should read.
+
+        In OSS this is simply the org's persisted config. Enterprise overrides
+        it to layer the bound project's overrides on top, which is why every
+        caller that is about to write config back must use
+        :meth:`get_org_config` instead -- see that method.
+        """
+        return self.config
+
+    def get_org_config(self) -> Config:
+        """Return the org's persisted config, with no per-caller overlay.
+
+        Identical to :meth:`get_config` here, and deliberately a separate
+        method anyway: a subclass may make ``get_config`` context-dependent, and
+        a read whose result is about to be persisted back to the org document
+        must not pick up a narrower scope's overrides. Reading through this
+        method is what states which of the two a call site meant.
+        """
         return self.config
 
     def get_config_for_response(self) -> dict[str, Any]:
@@ -90,7 +108,7 @@ def prepare_config_patch(self, partial: dict[str, Any]) -> Config:
         The shared behavior is intentionally shallow: nested config objects are
         replaced wholesale by the caller's partial.
         """
-        existing = self.get_config().model_dump(mode="python")
+        existing = self.get_org_config().model_dump(mode="python")
         normalized = self.normalize_config_payload({**existing, **partial})
         return (
             normalized

reflexio/server/services/configurator/configurator.py

@@ -2,7 +2,6 @@
 
 import logging
 from collections.abc import Callable
-from pathlib import Path
 from typing import Any
 
 from reflexio.models.config_schema import (
@@ -15,6 +14,9 @@
     LocalFileConfigStorage,
 )
 from reflexio.server.services.storage.sqlite_storage import SQLiteStorage
+from reflexio.server.services.storage.sqlite_storage._dataset_path import (
+    resolve_sqlite_db_path,
+)
 from reflexio.server.services.storage.storage_base import BaseStorage
 
 logger = logging.getLogger(__name__)
@@ -36,11 +38,16 @@ def _create_sqlite_storage(
         full_config.enable_document_expansion if full_config else False
     )
     # When base_dir is explicitly provided (e.g. tests with temp dirs)
-    # and no db_path is configured, use base_dir for the SQLite DB
-    # so the storage is isolated from the shared default database.
+    # and no db_path is configured, resolve the SQLite DB under base_dir so the
+    # storage is isolated from the shared default database.
+    #
+    # Resolved by identity, not by base_dir alone: two orgs sharing one base_dir
+    # would otherwise land on one file and read each other's rows -- the same defect
+    # the default path had. Mirrors the config layer beside it, which already writes
+    # ``config_<org_id>.json``.
     db_path = config.db_path
     if db_path is None and configurator.base_dir:
-        db_path = str(Path(configurator.base_dir) / "reflexio.db")
+        db_path = resolve_sqlite_db_path(configurator.base_dir, configurator.org_id)
     return SQLiteStorage(
         org_id=configurator.org_id,
         db_path=db_path,