claude-smart 0.2.48 → 0.2.49

package/plugin/vendor/reflexio/reflexio/client/client.py

@@ -445,12 +445,17 @@ class ReflexioClient:
                 explicit retry after reauth or limit reset.
 
         Returns:
-            PublishUserInteractionResponse: Server response. In
-                ``wait_for_response=False`` mode this is a bare
-                acknowledgement ("Interaction queued for processing")
-                without extraction counts; in ``wait_for_response=True``
-                mode it includes request_id, storage routing, and
-                deltas.
+            PublishUserInteractionResponse: Server response.
+
+                In deferred mode (``wait_for_response=False``) the
+                response carries ``learning_status="deferred"`` and a
+                ``request_id``; ``profiles_added``/``playbooks_added`` are
+                0 because extraction has not run yet. Poll
+                ``get_learning_status(request_id)`` for completion.
+
+                In ``wait_for_response=True`` mode the server waits for
+                extraction and the response includes ``request_id``,
+                storage routing, and real profile/playbook deltas.
         """
         if session_id is None or not session_id.strip():
             raise ValueError("session_id is required and cannot be empty")
@@ -481,6 +486,35 @@ class ReflexioClient:
         self._cache.invalidate("get_agent_playbooks")
         return result
 
+    def get_learning_status(self, request_id: str) -> str:
+        """Poll the learning status for a previously published request.
+
+        Call this after a deferred ``publish_interaction`` (where
+        ``wait_for_response=False``).  The response carries
+        ``learning_status="deferred"`` to signal that extraction has been
+        queued; use this method to track progress once the durable queue
+        is active.
+
+        Args:
+            request_id: The ``request_id`` of the published interaction, as
+                returned in ``PublishUserInteractionResponse.request_id``
+                (populated on both the deferred and ``wait_for_response=True``
+                paths) or known by the caller.
+
+        Returns:
+            One of: ``"pending"`` | ``"processing"`` | ``"done"`` | ``"failed"``.
+
+        Raises:
+            requests.HTTPError: 404 when the request_id is not known to the
+                server for this org.
+        """
+        response = self._make_request(
+            "GET",
+            "/api/learning_status",
+            params={"request_id": request_id},
+        )
+        return str(response["status"])
+
     def search_interactions(
         self,
         request: SearchInteractionRequest | dict | None = None,

package/plugin/vendor/reflexio/reflexio/models/api_schema/domain/entities.py

@@ -123,6 +123,7 @@ __all__ = [
     "LineageEvent",
     "LineageContext",
     "RecordRef",
+    "LearningStatusResponse",
 ]
 
 # ===============================
@@ -689,6 +690,23 @@ class PublishUserInteractionResponse(BaseModel):
     profiles_updated: int | None = None
     playbooks_added: int | None = None
     playbooks_updated: int | None = None
+    # Set to "deferred" when the server queued extraction asynchronously.
+    # None on the sync (wait_for_response=True) path. Poll GET
+    # /api/learning_status?request_id=... to track progress once the
+    # durable queue is active.
+    learning_status: str | None = None
+
+
+class LearningStatusResponse(BaseModel):
+    """Response for GET /api/learning_status.
+
+    Attributes:
+        status: One of ``pending | processing | done | failed``.
+            Coverage-based: reflects whether a durable learning job has
+            processed through the request's creation timestamp.
+    """
+
+    status: Literal["pending", "processing", "done", "failed"]
 
 
 # whoami response — caller identity + resolved storage routing (masked)

package/plugin/vendor/reflexio/reflexio/server/api.py

@@ -345,6 +345,9 @@ def create_app(
     )
     from reflexio.server.extensions import AppContext
     from reflexio.server.llm.model_defaults import validate_llm_availability
+    from reflexio.server.services.durable_learning import (
+        maybe_start_durable_learning,
+    )
     from reflexio.server.services.extraction.resume_scheduler import (
         maybe_start_resume_scheduler,
     )
@@ -356,6 +359,7 @@ def create_app(
     async def lifespan(app: FastAPI) -> AsyncIterator[None]:  # noqa: ARG001
         scheduler = None
         gc_scheduler = None
+        durable_learning_scheduler = None
         started_caps: list = []
         if mounts_data_plane:
             log_publish_hardware_capacity()
@@ -376,6 +380,14 @@ def create_app(
                 lambda org_id: RequestContext(org_id=org_id),
                 bootstrap_org_id=bootstrap_org_id,
             )
+            # Durable learning drains the learning_jobs queue per org. Gated on
+            # REFLEXIO_DURABLE_LEARNING_QUEUE; the default provider discovers
+            # orgs-with-work via the bootstrap storage (single-ref). Enterprise
+            # cross-ref fan-out is a deferred follow-up.
+            durable_learning_scheduler = maybe_start_durable_learning(
+                lambda org_id: RequestContext(org_id=org_id),
+                bootstrap_org_id=bootstrap_org_id,
+            )
         try:
             if capabilities is not None:
                 ctx = (
@@ -397,10 +409,9 @@ def create_app(
                         cap,
                         exc_info=True,
                     )
-            if scheduler is not None:
-                scheduler.stop()
-            if gc_scheduler is not None:
-                gc_scheduler.stop()
+            for sched in (scheduler, gc_scheduler, durable_learning_scheduler):
+                if sched is not None:
+                    sched.stop()
             from reflexio.server.services.publish_learning_worker import (
                 stop_publish_learning_worker,
             )

package/plugin/vendor/reflexio/reflexio/server/llm/_litellm_text_generation.py

@@ -523,7 +523,7 @@ class TextGenerationMixin:
 
             # The loop only exits with a drained result (every no-result path
             # above raises); the assert makes that invariant explicit for pyright.
-            assert result is not None
+            assert result is not None  # noqa: S101
             status, payload = result
             # The payload is drained, so the feeder is unblocked and the child can
             # exit. Reap it (terminating if it lingers) to avoid a zombie.

package/plugin/vendor/reflexio/reflexio/server/llm/litellm_client.py

@@ -110,6 +110,7 @@ __all__ = [
     "create_litellm_client",
 ]
 
+
 class LiteLLMClient(TextGenerationMixin, EmbeddingMixin, StructuredOutputMixin):
     """
     Unified LLM client using LiteLLM for multi-provider support.

package/plugin/vendor/reflexio/reflexio/server/llm/providers/local_embedding_provider.py

@@ -18,9 +18,23 @@ from __future__ import annotations
 import importlib.util
 import logging
 import os
+import shutil
 import threading
+from collections.abc import Iterator
+from contextlib import contextmanager
+from pathlib import Path
 from typing import Any
 
+try:
+    import fcntl
+except ImportError:  # pragma: no cover - Windows only
+    fcntl = None  # type: ignore[assignment]
+
+try:
+    import msvcrt
+except ImportError:  # pragma: no cover - POSIX only
+    msvcrt = None  # type: ignore[assignment]
+
 _LOGGER = logging.getLogger(__name__)
 
 _ENV_ENABLE = "CLAUDE_SMART_USE_LOCAL_EMBEDDING"
@@ -36,6 +50,17 @@ _TARGET_DIM = 512
 # ValueError that ONNXMiniLM_L6_V2 throws on over-length input.
 _MAX_CHARS = 800
 
+# Chroma keeps this file list private inside ONNXMiniLM_L6_V2's download helper.
+# Keep this in sync with chromadb's all-MiniLM-L6-v2 extracted archive layout.
+_MINILM_EXPECTED_FILES = (
+    "config.json",
+    "model.onnx",
+    "special_tokens_map.json",
+    "tokenizer_config.json",
+    "tokenizer.json",
+    "vocab.txt",
+)
+
 
 class LocalEmbedderError(RuntimeError):
     """Raised when the local embedder is called without chromadb installed."""
@@ -98,9 +123,54 @@ class LocalEmbedder:
         """
         ef = self._load()
         safe_inputs = [(text or "")[:_MAX_CHARS] for text in texts]
-        raw = ef(safe_inputs)
+        try:
+            raw = ef(safe_inputs)
+        except Exception as exc:  # noqa: BLE001 - Chroma raises varied cache errors.
+            raw = self._retry_embed_after_cache_clear(ef, exc, safe_inputs)
         return [_pad(vec) for vec in raw]
 
+    def _retry_embed_after_cache_clear(
+        self, failed_ef: Any, exc: Exception, safe_inputs: list[str]
+    ) -> Any:
+        with self._ef_lock:
+            if self._ef is not None and self._ef is not failed_ef:
+                return self._ef(safe_inputs)
+
+            embedding_cls = type(failed_ef)
+            recovery = _recoverable_minilm_cache(embedding_cls, exc)
+            if recovery is None:
+                raise exc
+            cache_path, cache_was_complete = recovery
+
+            with _exclusive_file_lock(_minilm_cache_lock_path(cache_path)):
+                if _should_clear_minilm_cache(
+                    embedding_cls, cache_path, exc, cache_was_complete
+                ):
+                    shutil.rmtree(cache_path, ignore_errors=True)
+                    recovery_action = "clearing"
+                    _LOGGER.warning(
+                        "Failed to use local MiniLM embedder; cleared cache %s "
+                        "and retrying once",
+                        cache_path,
+                        exc_info=True,
+                    )
+                else:
+                    recovery_action = "waiting for another process to refresh"
+                    _LOGGER.info(
+                        "MiniLM cache %s was refreshed by another process; retrying",
+                        cache_path,
+                    )
+                try:
+                    fresh_ef = embedding_cls()
+                    self._ef = fresh_ef
+                    return fresh_ef(safe_inputs)
+                except Exception as retry_exc:
+                    raise LocalEmbedderError(
+                        "Local MiniLM cache recovery failed after "
+                        f"{recovery_action} {cache_path}. Delete this cache "
+                        "directory, restart Reflexio, and retry local embedding."
+                    ) from retry_exc
+
 
 def _pad(vec: Any) -> list[float]:
     """Zero-pad a 384-dim vector to ``_TARGET_DIM`` as a plain list[float]."""
@@ -113,6 +183,118 @@ def _pad(vec: Any) -> list[float]:
     return floats + [0.0] * (_TARGET_DIM - len(floats))
 
 
+def _recoverable_minilm_cache(
+    embedding_cls: Any, exc: Exception
+) -> tuple[Path, bool] | None:
+    cache_path = _minilm_cache_path(embedding_cls)
+    if cache_path is None:
+        return None
+    cache_was_complete = _minilm_cache_complete(embedding_cls, cache_path)
+    if cache_was_complete and not _complete_minilm_cache_error_identifies_cache(
+        embedding_cls, cache_path, exc
+    ):
+        return None
+
+    return cache_path, cache_was_complete
+
+
+def _minilm_cache_path(embedding_cls: Any) -> Path | None:
+    download_path = getattr(embedding_cls, "DOWNLOAD_PATH", None)
+    if not download_path:
+        return None
+
+    model_name = getattr(embedding_cls, "MODEL_NAME", None)
+    cache_path = Path(str(download_path)).expanduser()
+    if not model_name or cache_path.name != model_name:
+        return None
+
+    return cache_path
+
+
+def _minilm_cache_lock_path(cache_path: Path) -> Path:
+    return cache_path.parent / f".{cache_path.name}.lock"
+
+
+@contextmanager
+def _exclusive_file_lock(lock_path: Path) -> Iterator[None]:
+    lock_path.parent.mkdir(parents=True, exist_ok=True)
+    with lock_path.open("a+b") as lock_file:
+        lock_file.seek(0)
+        if lock_file.read(1) == b"":
+            lock_file.write(b"\0")
+            lock_file.flush()
+        lock_file.seek(0)
+
+        if fcntl is not None:
+            fcntl.flock(lock_file.fileno(), fcntl.LOCK_EX)
+            try:
+                yield
+            finally:
+                fcntl.flock(lock_file.fileno(), fcntl.LOCK_UN)
+        elif msvcrt is not None:
+            msvcrt.locking(  # type: ignore[reportAttributeAccessIssue]
+                lock_file.fileno(),
+                msvcrt.LK_LOCK,  # type: ignore[reportAttributeAccessIssue]
+                1,
+            )
+            try:
+                yield
+            finally:
+                lock_file.seek(0)
+                msvcrt.locking(  # type: ignore[reportAttributeAccessIssue]
+                    lock_file.fileno(),
+                    msvcrt.LK_UNLCK,  # type: ignore[reportAttributeAccessIssue]
+                    1,
+                )
+        else:
+            yield
+
+
+def _should_clear_minilm_cache(
+    embedding_cls: Any, cache_path: Path, exc: Exception, cache_was_complete: bool
+) -> bool:
+    cache_is_complete = _minilm_cache_complete(embedding_cls, cache_path)
+    if not cache_is_complete:
+        return True
+
+    if not cache_was_complete:
+        return False
+
+    return _complete_minilm_cache_error_identifies_cache(embedding_cls, cache_path, exc)
+
+
+def _complete_minilm_cache_error_identifies_cache(
+    embedding_cls: Any, cache_path: Path, exc: Exception
+) -> bool:
+    chain = _exception_chain(exc)
+    archive_name = str(getattr(embedding_cls, "ARCHIVE_FILENAME", ""))
+    messages = "\n".join(str(chain_exc) for chain_exc in chain)
+    return (
+        str(cache_path) in messages
+        or bool(archive_name and archive_name in messages)
+        or "does not match expected SHA256" in messages
+    )
+
+
+def _minilm_cache_complete(embedding_cls: Any, cache_path: Path) -> bool:
+    extracted_folder = str(getattr(embedding_cls, "EXTRACTED_FOLDER_NAME", "onnx"))
+    return all(
+        (cache_path / extracted_folder / file_name).exists()
+        for file_name in _MINILM_EXPECTED_FILES
+    )
+
+
+def _exception_chain(exc: Exception) -> list[BaseException]:
+    chain: list[BaseException] = []
+    seen: set[int] = set()
+    current: BaseException | None = exc
+    while current is not None and id(current) not in seen:
+        seen.add(id(current))
+        chain.append(current)
+        current = current.__cause__ or current.__context__
+    return chain
+
+
 _REGISTERED = False
 
 

package/plugin/vendor/reflexio/reflexio/server/routes/interactions.py

@@ -1,6 +1,7 @@
 """Interaction route handlers (extracted from api.py, Tier3 A2)."""
 
 import logging
+import uuid
 from typing import TYPE_CHECKING
 
 if TYPE_CHECKING:
@@ -10,6 +11,7 @@ from fastapi import (
     APIRouter,
     BackgroundTasks,
     Depends,
+    HTTPException,
     Request,
 )
 
@@ -30,6 +32,7 @@ from reflexio.models.api_schema.service_schemas import (
     DeleteSessionResponse,
     DeleteUserInteractionRequest,
     DeleteUserInteractionResponse,
+    LearningStatusResponse,
     PublishUserInteractionRequest,
     PublishUserInteractionResponse,
 )
@@ -79,6 +82,14 @@ def publish_user_interaction(
             ),
         )
 
+    # Resolve the request_id BEFORE backgrounding so we can return it to the
+    # caller for polling. GenerationService uses a caller-supplied request_id
+    # verbatim (and generates one only when absent), so pinning it on the
+    # payload guarantees the background task stores its status under the same
+    # id we hand back here.
+    request_id = payload.request_id or str(uuid.uuid4())
+    payload.request_id = request_id
+
     def _publish_task() -> None:
         try:
             publisher_api.add_user_interaction(
@@ -89,10 +100,16 @@ def publish_user_interaction(
         except Exception:
             logger.exception("Background publish failed for org %s", org_id)
 
-    # Run in background — caller gets immediate acknowledgement
+    # Run in background — caller gets immediate acknowledgement.
+    # learning_status="deferred" tells the caller that extraction has not yet
+    # run; they can poll GET /api/learning_status?request_id=... (using the
+    # request_id returned here) to track it.
     background_tasks.add_task(_publish_task)
     return PublishUserInteractionResponse(
-        success=True, message="Interaction queued for processing"
+        success=True,
+        message="Interaction queued for processing",
+        request_id=request_id,
+        learning_status="deferred",
     )
 
 
@@ -257,3 +274,47 @@ def get_requests_endpoint(
         has_more=internal_response.has_more,
         msg=internal_response.msg,
     )
+
+
+@router.get(
+    "/api/learning_status",
+    response_model=LearningStatusResponse,
+    response_model_exclude_none=True,
+)
+@limiter.limit("120/minute")
+def get_learning_status(
+    request: Request,
+    request_id: str,
+    org_id: str = Depends(default_get_org_id),
+) -> LearningStatusResponse:
+    """Return the coverage-based learning status for a published request.
+
+    The status reflects whether a durable learning job has processed through
+    the request's creation timestamp:
+
+    - ``pending``: not yet picked up.
+    - ``processing``: a worker currently holds the job.
+    - ``done``: at least one completed job covers this request.
+    - ``failed``: a dead job covers this request and no done job does.
+
+    Note: this endpoint reads ``learning_jobs`` rows written by the durable
+    queue. When the durable queue is OFF (in-memory deferred path) it returns
+    absence-based status (``pending`` for recent requests, ``done`` for old
+    ones) — acceptable for v1; the poll contract is tied to the durable queue.
+
+    Raises:
+        HTTPException: 404 when ``request_id`` is not found for this org.
+            Never reports ``done`` for a request that never existed.
+    """
+    reflexio = reflexio_cache.get_reflexio(org_id=org_id)
+    storage = reflexio.request_context.storage
+    if storage is None:
+        raise HTTPException(status_code=503, detail="Storage not configured")
+    req = storage.get_request(request_id)
+    if req is None:
+        raise HTTPException(status_code=404, detail="request not found")
+    status = storage.get_learning_status_for_request(
+        user_id=req.user_id,
+        request_created_at=float(req.created_at),
+    )
+    return LearningStatusResponse(status=status)

package/plugin/vendor/reflexio/reflexio/server/services/durable_learning/__init__.py

@@ -0,0 +1,13 @@
+"""Durable learning worker: claim → process in commit_scope → fenced completion."""
+
+from reflexio.server.services.durable_learning.scheduler import (
+    DurableLearningScheduler,
+    maybe_start_durable_learning,
+)
+from reflexio.server.services.durable_learning.worker import DurableLearningWorker
+
+__all__ = [
+    "DurableLearningScheduler",
+    "DurableLearningWorker",
+    "maybe_start_durable_learning",
+]

package/plugin/vendor/reflexio/reflexio/server/services/durable_learning/scheduler.py

@@ -0,0 +1,142 @@
+"""Process-local scheduler for the durable learning-job queue (Task 6).
+
+Each tick discovers the orgs with actionable learning jobs (via an injected
+``org_ids_provider``) and drains each through a :class:`DurableLearningWorker`.
+The worker's claims are org-scoped and the fenced complete/fail transitions make
+the drain exactly-once, so racing scheduler instances across processes are safe.
+
+Gating: startup is gated on ``REFLEXIO_DURABLE_LEARNING_QUEUE`` (a rollout flag,
+scalability design 2026-07-04 §8 stage 2). When off, :meth:`start` is a no-op.
+
+Multi-ref capability (design §3.1, per-ref polling): the mechanism supports
+per-data-ref fan-out — inject an ``org_ids_provider`` that yields orgs across
+refs plus a ``request_context_factory`` that routes each org to its ref's
+storage. The default provider (single-ref: bootstrap-storage discovery) is wired
+in :func:`maybe_start_durable_learning`; the enterprise cross-ref enumerator is a
+deferred follow-up (tracked with the pre-Task-8 gates).
+"""
+
+from __future__ import annotations
+
+import logging
+from collections.abc import Callable, Iterable
+
+from reflexio.server.api_endpoints.request_context import RequestContext
+from reflexio.server.env_utils import env_str, env_truthy
+from reflexio.server.scheduling import ThreadedScheduler
+from reflexio.server.services.durable_learning.worker import DurableLearningWorker
+
+logger = logging.getLogger(__name__)
+
+
+class DurableLearningScheduler(ThreadedScheduler):
+    """Polling daemon that drains the durable learning queue per org.
+
+    Args:
+        request_context_factory: Builds an org-scoped :class:`RequestContext`.
+            Passed straight to the worker; a multi-ref deployment routes each org
+            to its data ref's storage here.
+        org_ids_provider: Called once per tick; yields the org_ids to drain. The
+            single-ref default (see :func:`maybe_start_durable_learning`) reads
+            them from the bootstrap storage's cross-org discovery query.
+        instance_id: Stable label written to ``claimed_by`` on each claim.
+    """
+
+    def __init__(
+        self,
+        *,
+        request_context_factory: Callable[[str], RequestContext],
+        org_ids_provider: Callable[[], Iterable[str]],
+        instance_id: str | None = None,
+    ) -> None:
+        super().__init__(thread_name="reflexio-durable-learning-scheduler")
+        self._worker = DurableLearningWorker(
+            request_context_factory, instance_id=instance_id
+        )
+        self._org_ids_provider = org_ids_provider
+        # Read env INSIDE __init__ so tests can set the values before construction.
+        self._poll = float(env_str("REFLEXIO_DURABLE_LEARNING_POLL_SECONDS", "2.0"))
+        self._batch = int(env_str("REFLEXIO_DURABLE_LEARNING_BATCH", "16"))
+        self._lease = int(env_str("REFLEXIO_DURABLE_LEARNING_LEASE_SECONDS", "300"))
+
+    def _should_start(self) -> bool:
+        if env_truthy(env_str("REFLEXIO_DURABLE_LEARNING_QUEUE", "false")):
+            return True
+        logger.info(
+            "event=durable_learning_scheduler_disabled "
+            "REFLEXIO_DURABLE_LEARNING_QUEUE not set — not starting"
+        )
+        return False
+
+    def _on_started(self) -> None:
+        logger.info("event=durable_learning_scheduler_started")
+
+    def _on_stopped(self) -> None:
+        logger.info("event=durable_learning_scheduler_stopped")
+
+    def _run_once(self) -> float:
+        """Drain every discovered org once; per-org error isolation.
+
+        A single org raising never aborts the tick, and a failure to enumerate
+        orgs never kills the daemon thread. Returns the poll interval.
+        """
+        try:
+            for org_id in self._org_ids_provider():
+                if self._stop_event.is_set():
+                    break
+                try:
+                    self._worker.drain_org(org_id, self._batch, self._lease)
+                except Exception:
+                    logger.exception(
+                        "event=durable_learning_drain_failed org_id=%s", org_id
+                    )
+        except Exception:
+            logger.exception("event=durable_learning_tick_failed")
+        return self._poll
+
+
+def maybe_start_durable_learning(
+    request_context_factory: Callable[[str], RequestContext],
+    *,
+    bootstrap_org_id: str,
+    org_ids_provider: Callable[[], Iterable[str]] | None = None,
+) -> DurableLearningScheduler | None:
+    """Start the durable-learning scheduler when the rollout flag is on.
+
+    Returns ``None`` when ``REFLEXIO_DURABLE_LEARNING_QUEUE`` is off (mirrors
+    ``maybe_start_resume_scheduler``). The default ``org_ids_provider`` performs
+    single-ref discovery: it queries the bootstrap org's storage for every org
+    with actionable work (covers OSS/local and the shared managed DATA ref). The
+    enterprise cross-ref enumerator is a deferred follow-up.
+
+    Args:
+        request_context_factory: Builds an org-scoped :class:`RequestContext`.
+        bootstrap_org_id: Org used to reach a storage for cross-org discovery.
+        org_ids_provider: Optional explicit provider (e.g. a future enterprise
+            cross-ref enumerator); when ``None`` the single-ref default is used.
+    """
+    if not env_truthy(env_str("REFLEXIO_DURABLE_LEARNING_QUEUE", "false")):
+        return None
+
+    def _default_provider() -> list[str]:
+        try:
+            ctx = request_context_factory(bootstrap_org_id)
+            storage = getattr(ctx, "storage", None)
+            if storage is None:
+                return []
+            return list(storage.list_org_ids_with_pending_learning_jobs())
+        except NotImplementedError:
+            return []
+        except Exception:
+            logger.exception(
+                "event=durable_learning_discovery_failed bootstrap_org_id=%s",
+                bootstrap_org_id,
+            )
+            return []
+
+    scheduler = DurableLearningScheduler(
+        request_context_factory=request_context_factory,
+        org_ids_provider=org_ids_provider or _default_provider,
+    )
+    scheduler.start()
+    return scheduler