claude-smart 0.2.48 → 0.2.50

package/plugin/vendor/reflexio/reflexio/models/api_schema/eval_overview_schema.py

@@ -11,6 +11,7 @@ from typing import Literal, Self
 
 from pydantic import BaseModel, ConfigDict, Field, model_validator
 
+from reflexio.models.api_schema.domain import CitationKind
 from reflexio.models.api_schema.validators import NonEmptyStr
 from reflexio.models.structured_output import StrictStructuredOutput
 
@@ -79,7 +80,7 @@ class RuleAttributionRow(BaseModel):
     """One row in the "rules that moved the needle" panel."""
 
     rule_id: str
-    kind: Literal["playbook", "profile"]
+    kind: CitationKind
     title: str = ""
     successes_with: int = Field(ge=0)
     failures_with: int = Field(ge=0)
@@ -416,12 +417,17 @@ class GradeOnDemandResponse(BaseModel):
             window. False on a fresh grade.
         skipped_reason (str | None): If grading was skipped, the reason
             (e.g., "NO_REQUESTS"). None on success.
+        retrieved_learning_status (str | None): Outcome of the
+            retrieved-learning evaluation for this session (e.g.
+            "complete", "degraded", "failed", "not_applicable"). None on
+            legacy cache entries and skipped grades.
     """
 
     session_id: str
     result_id: int | None = None
     cached: bool = False
     skipped_reason: str | None = None
+    retrieved_learning_status: str | None = None
 
 
 # ---------------------------------------------------------------------------

package/plugin/vendor/reflexio/reflexio/models/api_schema/internal_schema.py

@@ -6,6 +6,7 @@ from typing import NamedTuple
 
 from pydantic import BaseModel
 
+from .domain import CitationKind
 from .service_schemas import Interaction, Request
 
 
@@ -42,6 +43,6 @@ class SessionCitation(NamedTuple):
 
     user_id: str
     session_id: str
-    kind: str
+    kind: CitationKind
     real_id: str
     title: str

package/plugin/vendor/reflexio/reflexio/models/api_schema/retriever_schema.py

@@ -6,12 +6,15 @@ from typing import Literal, Self
 from pydantic import BaseModel, Field, model_validator
 
 from ..config_schema import SearchMode
+from ..structured_output import StrictStructuredOutput
+from .domain import CitationKind
 from .service_schemas import (
     AgentPlaybook,
     AgentSuccessEvaluationResult,
     Interaction,
     PlaybookStatus,
     Request,
+    RetrievedLearningEvaluationResult,
     Status,
     UserPlaybook,
     UserProfile,
@@ -433,6 +436,26 @@ class GetAgentSuccessEvaluationResultsResponse(BaseModel):
     msg: str | None = None
 
 
+class GetRetrievedLearningEvaluationResultsRequest(BaseModel):
+    """Read per-learning retrieved-learning evaluation verdicts.
+
+    Attributes:
+        user_id (str | None): Filter by session owner.
+        session_id (str | None): Filter by session.
+        limit (int): Maximum rows, ordered by created_at DESC, result_id DESC.
+    """
+
+    user_id: str | None = None
+    session_id: str | None = None
+    limit: int = Field(default=100, ge=1, le=1_000)
+
+
+class GetRetrievedLearningEvaluationResultsResponse(BaseModel):
+    success: bool
+    results: list[RetrievedLearningEvaluationResult] = Field(default_factory=list)
+    msg: str | None = None
+
+
 class GetRequestsRequest(BaseModel):
     user_id: str | None = None
     request_id: str | None = None
@@ -593,8 +616,10 @@ class PlaybookApplicationStat(BaseModel):
         real_id (str): Stable id of the cited item — ``user_playbook_id``,
             ``agent_playbook_id``, or ``profile_id`` (always serialized as a
             string).
-        kind (str): ``"playbook"`` or ``"profile"`` — the citation kind, as
-            recorded on ``Interaction.citations``.
+        kind (CitationKind): Citation kind recorded on
+            ``Interaction.citations``. ``"playbook"`` is the legacy
+            compatibility value; ``"user_playbook"`` is the explicit
+            direct-tuner target.
         title (str): Human-readable label for the rule. Empty string when
             the underlying row has been deleted but old citations remain.
         applied_count (int): Number of interactions in the window whose
@@ -609,7 +634,7 @@ class PlaybookApplicationStat(BaseModel):
     """
 
     real_id: str
-    kind: Literal["playbook", "profile"]
+    kind: CitationKind
     title: str = ""
     applied_count: int = Field(ge=0)
     last_applied_at: int | None = None
@@ -659,15 +684,36 @@ class ConversationTurn(BaseModel):
     content: NonEmptyStr
 
 
-class ReformulationResult(BaseModel):
+class ReformulationResult(StrictStructuredOutput):
     """Output of the query reformulation pipeline.
 
+    Besides the rewritten query, carries the query's TEMPORAL SIGNALS so the
+    search pipeline can be time-sensitive without any additional LLM call
+    (the reformulation call already runs before retrieval when
+    ``enable_reformulation`` is set). Time windows are relative day offsets
+    (never absolute dates) so results don't rot with calendar time.
+
     Args:
         standalone_query (str): Clean, normalized natural language query with
             conversation context resolved, abbreviations expanded, grammar fixed.
+        start_days_ago (float, optional): Older bound of a query time window
+            ("in the last 7 days" → 7).
+        end_days_ago (float, optional): Newer bound ("before this month" →
+            ~30, with no start bound).
+        recency_dominant (bool): The query asks for the CURRENT/LATEST value —
+            final ordering becomes timestamp-based.
+        wants_current (bool): Present-tense question about a mutable
+            fact/policy — near-duplicate competing facts collapse to the
+            freshest, while relevance ordering is otherwise preserved.
+            (Superseded/TTL-expired rows never reach results: storage search
+            excludes tombstone statuses and expired profiles at SQL level.)
     """
 
     standalone_query: str
+    start_days_ago: float | None = Field(default=None, ge=0)
+    end_days_ago: float | None = Field(default=None, ge=0)
+    recency_dominant: bool = False
+    wants_current: bool = False
 
 
 # ===============================
@@ -712,6 +758,9 @@ class UnifiedSearchRequest(BaseModel):
     search_mode: SearchMode = SearchMode.HYBRID
     # Caller correlation IDs for billing attribution on the Application line.
     # Optional; consumed by _meter_applied_learnings in server/api.py.
+    # ``session_id`` additionally enables session-scoped result dedup: items
+    # already served to the same (org, session) are skipped and the next-best
+    # matches backfilled (see server/services/retrieval/session_dedup.py).
     request_id: str | None = None
     session_id: str | None = None
     interaction_id: int | None = Field(default=None, gt=0)
@@ -729,6 +778,14 @@ class UnifiedSearchResponse(BaseModel):
         msg (str, optional): Additional message
         agent_answer (str, optional): LLM-synthesised answer populated by the agentic backend;
             None for classic backend.
+        degraded (bool): True when the search silently fell back from the
+            requested vector/hybrid mode to full-text search because query
+            embedding generation failed. Results are still returned (via FTS),
+            but relevance may be lower than a healthy vector/hybrid run.
+            Defaults to False.
+        search_mode_effective (str, optional): The search mode actually used
+            when it differs from the requested mode — currently ``"fts"`` on
+            the degrade path. None when the requested mode was honored.
     """
 
     success: bool
@@ -740,6 +797,8 @@ class UnifiedSearchResponse(BaseModel):
     agent_answer: str | None = None
     agent_trace: str | None = None
     rehydrated_text: str | None = None
+    degraded: bool = False
+    search_mode_effective: str | None = None
 
 
 # ===============================

package/plugin/vendor/reflexio/reflexio/models/api_schema/ui/converters.py

@@ -53,6 +53,7 @@ def to_interaction_view(interaction: Interaction) -> InteractionView:
         shadow_content=interaction.shadow_content,
         expert_content=interaction.expert_content,
         tools_used=interaction.tools_used,
+        retrieved_learnings=interaction.retrieved_learnings,
     )
 
 

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

@@ -5,6 +5,7 @@ from datetime import UTC, datetime
 from pydantic import BaseModel, Field, field_validator
 
 from ..common import NEVER_EXPIRES_TIMESTAMP, ToolUsed
+from ..domain.entities import RetrievedLearning
 from ..validators import _validate_image_url
 from .enums import (
     PlaybookStatus,
@@ -29,7 +30,12 @@ __all__ = [
 
 
 class InteractionView(BaseModel):
-    """User-facing Interaction — excludes embedding and image_encoding."""
+    """User-facing Interaction — excludes embedding and image_encoding.
+
+    ``retrieved_learnings`` (caller-supplied at publish) is exposed so callers
+    can round-trip what they attached; ``citations`` (agent-claimed influence,
+    server-side signal) is deliberately NOT exposed on this view.
+    """
 
     interaction_id: int = 0
     user_id: str
@@ -43,6 +49,7 @@ class InteractionView(BaseModel):
     shadow_content: str = ""
     expert_content: str = ""
     tools_used: list[ToolUsed] = Field(default_factory=list)
+    retrieved_learnings: list[RetrievedLearning] = Field(default_factory=list)
 
     @field_validator("interacted_image_url", mode="after")
     @classmethod

package/plugin/vendor/reflexio/reflexio/models/config_schema.py

@@ -914,7 +914,7 @@ class Config(BaseModel):
         ),
     )
     shadow_comparison_judge_prompt_version: NonEmptyStr = Field(
-        default="v1.0.0",
+        default="v1.1.0",
         description=(
             "F1: pinned judge prompt version for per-turn shadow comparison. "
             "Verdicts are stored with the version that produced them; the "

package/plugin/vendor/reflexio/reflexio/server/README.md

@@ -17,6 +17,7 @@ Description: FastAPI backend server that processes user interactions to generate
   - [Profile Generation](#profile-generation)
   - [Playbook Extraction](#playbook-extraction)
   - [Agent Success Evaluation](#agent-success-evaluation)
+  - [Durable Learning Queue](#durable-learning-queue)
   - [Reflection and Async Extraction](#reflection-and-async-extraction)
   - [Shadow Comparison and Evaluation Overview](#shadow-comparison-and-evaluation-overview)
   - [Playbook Optimizer and Braintrust](#playbook-optimizer-and-braintrust)
@@ -38,6 +39,7 @@ Description: FastAPI backend server that processes user interactions to generate
 - **Endpoint Helpers**: `api_endpoints/` - Shared handlers/helpers plus `RequestContext` used by route modules
 - **Extension Registry**: `extensions.py` - Capability and service registry for optional OSS/enterprise integrations
 - **Core Service**: `services/generation_service.py` - Main orchestrator
+- **Durable Learning**: `services/durable_learning/` - background queue worker for deferred post-publish extraction
 
 ## Cache
 
@@ -86,7 +88,7 @@ Description: FastAPI backend server that processes user interactions to generate
 - **Health/version**: `GET /`, `GET /health`, `GET /healthz`, `GET /healthz/eval`, `GET /meta/version`
 - **Identity/config**: `GET /api/whoami`, `GET /api/my_config`, `GET /api/get_config`, `POST /api/set_config`, `POST /api/update_config`
 - **Publish/direct writes**: `POST /api/publish_interaction`, `POST /api/add_user_profile`, `POST /api/add_user_playbook`, `POST /api/add_agent_playbook`
-- **Retrieval**: `POST /api/get_requests`, `POST /api/get_interactions`, `GET /api/get_all_interactions`, `POST /api/get_profiles`, `GET /api/get_all_profiles`, `POST /api/get_user_playbooks`, `POST /api/get_agent_playbooks`, `POST /api/get_agent_success_evaluation_results`
+- **Retrieval**: `POST /api/get_requests`, `POST /api/get_interactions`, `GET /api/get_all_interactions`, `GET /api/learning_status`, `POST /api/get_profiles`, `GET /api/get_all_profiles`, `POST /api/get_user_playbooks`, `POST /api/get_agent_playbooks`, `POST /api/get_agent_success_evaluation_results`, `POST /api/get_retrieved_learning_evaluation_results`
 - **Search/stats**: `POST /api/search`, `POST /api/search_profiles`, `POST /api/rerank_user_profiles`, `POST /api/search_interactions`, `POST /api/search_user_playbooks`, `POST /api/search_agent_playbooks`, `GET /api/storage_stats`, `GET /api/get_profile_statistics`, `POST /api/get_dashboard_stats`, `POST /api/get_playbook_application_stats`
 - **Profile lifecycle**: `POST /api/rerun_profile_generation`, `POST /api/manual_profile_generation`, `POST /api/upgrade_all_profiles`, `POST /api/downgrade_all_profiles`, `GET /api/profile_change_log`, `PUT /api/update_user_profile`, `DELETE /api/delete_profile`, `DELETE /api/delete_profiles_by_ids`, `DELETE /api/delete_all_profiles`
 - **Playbook lifecycle**: `POST /api/rerun_playbook_generation`, `POST /api/manual_playbook_generation`, `POST /api/run_playbook_aggregation`, `GET /api/playbook_aggregation_change_logs`, `POST /api/upgrade_all_user_playbooks`, `POST /api/downgrade_all_user_playbooks`, `PUT /api/update_agent_playbook_status`, `PUT /api/update_agent_playbook`, `PUT /api/update_user_playbook`, `DELETE /api/delete_agent_playbook`, `DELETE /api/delete_user_playbook`, `DELETE /api/delete_agent_playbooks_by_ids`, `DELETE /api/delete_user_playbooks_by_ids`, `DELETE /api/delete_all_playbooks`, `DELETE /api/delete_all_user_playbooks`, `DELETE /api/delete_all_agent_playbooks`
@@ -210,12 +212,14 @@ python -m reflexio.server.scripts.manage_invitation_codes list --show-used
 - **Profile memory**: `profile/` extracts, deduplicates, and applies user profile updates.
 - **Playbook memory**: `playbook/` extracts user playbooks, consolidates them against existing rows, aggregates them into agent playbooks, and tracks aggregation change logs.
 - **Evaluation**: `agent_success_evaluation/service.py`, `agent_success_evaluation/runner.py`, `agent_success_evaluation/scheduler.py`, `agent_success_evaluation/components/evaluator.py`, `shadow_comparison/`, and `evaluation_overview/` handle session grading, per-turn shadow verdicts, regeneration jobs, and dashboard-facing rollups.
+- **Durable learning queue**: `durable_learning/scheduler.py` and `durable_learning/worker.py` drain `learning_jobs` after deferred publishes and report coverage through `GET /api/learning_status`.
 - **Async clarification**: `extraction/` and `reflection/` manage resumable agent runs, pending tool calls, prior-answer search, and long-horizon reflection updates.
 - **Search preparation**: `pre_retrieval/` and `unified_search_service.py` handle query reformulation, document expansion, embeddings, and cross-entity search orchestration.
 - **Optimization/integrations**: `playbook_optimizer/` and `braintrust/` run candidate playbook optimization, rollout support, and Braintrust export/sync.
 - **Lineage**: `lineage/` resolves active records across superseded chains and schedules tombstone garbage collection for profile/playbook storage.
 - **Governance**: `governance/` defines subject-reference contracts and retention/barrier policy helpers used by storage and lineage paths.
 - **Persistence/config**: `storage/`, `configurator/`, and `operation_state_utils.py` provide storage abstractions, config loading, locks, bookmarks, progress, and cancellation.
+- **Usage metering**: `billing_meter.py` converts learning/search signals into optional `usage_events` without importing enterprise types.
 
 ### Orchestrator
 
@@ -415,7 +419,9 @@ Key files:
 - `agent_success_evaluation_constants.py`: Output schema (`AgentSuccessEvaluationOutput`)
 - `agent_success_evaluation_utils.py`: Message construction utilities
 - `scheduler.py`: `GroupEvaluationScheduler` singleton - min-heap priority queue with daemon thread, defers evaluation until 10 min after last request in session
-- `runner.py`: `run_group_evaluation()` - fetches all requests/interactions for a session, builds `RequestInteractionDataModel` list, runs `service.py`
+- `runner.py`: `run_group_evaluation()` - fetches all requests/interactions for a session, builds `RequestInteractionDataModel` list, runs `service.py`, then the retrieved-learning phase; returns `GroupEvaluationOutcome` (per-family statuses)
+- `components/retrieved_learning_evaluator.py`: `RetrievedLearningEvaluator` - per-learning relevance/impact judges over `Interaction.retrieved_learnings`; results replace the session's `retrieved_learning_evaluation` snapshot atomically (generation + session-fingerprint fenced, see `services/storage/storage_base/retrieved_learning_state.py`)
+- `services/storage/storage_base/evaluation_state_keys.py`: single source of truth for the three evaluation `_operation_state` key formats (agent-success marker, grade-on-demand cache, retrieved-learning state) shared by producers and governance erasure
 
 **Flow**: Interactions → `agent_success_evaluation/scheduler.py` → `agent_success_evaluation/runner.py` → `agent_success_evaluation/service.py` → `agent_success_evaluation/components/evaluator.py` → `AgentSuccessEvaluationResult` → Storage
 
@@ -423,7 +429,18 @@ Key files:
 
 **Tool Context**: Reads `tool_can_use` from root `Config` level (shared with playbook extraction).
 
-**Shadow Comparison**: Session-level shadow comparison was retracted in F1 because multi-turn shadow content suffers from trajectory contamination (turn 2+ user messages react to the regular response, not the shadow). The `regular_vs_shadow` field on `AgentSuccessEvaluationResult` is preserved as a nullable historical column but is always `None` on newly produced rows. Per-turn shadow comparison lives in a dedicated `services/shadow_comparison/` judge that writes its verdicts to a separate table — see the F1 spec.
+**Shadow Comparison**: Session-level shadow comparison was retracted in F1 because multi-turn shadow content suffers from trajectory contamination (turn 2+ user messages react to the regular response, not the shadow). The `regular_vs_shadow` field on `AgentSuccessEvaluationResult` is preserved as a nullable historical column but is always `None` on newly produced rows. Per-turn shadow comparison is scheduled from the publish path whenever an assistant interaction carries `shadow_content`; it lives in a dedicated `services/shadow_comparison/` judge that writes verdicts to a separate table, independent of session-level evaluation sampling.
+
+### Durable Learning Queue
+
+**Directory**: `services/durable_learning/`
+
+Key files:
+- `scheduler.py`: `DurableLearningScheduler` plus `maybe_start_durable_learning()`; starts only when `REFLEXIO_DURABLE_LEARNING_QUEUE` is truthy and polls orgs with actionable queue rows.
+- `worker.py`: `DurableLearningWorker`; claims leased jobs, reloads the persisted request, then splits each job into `compute_deferred_learning()` (LLM extraction + dedup + embeddings, **no** writer transaction held) → `persist_deferred_learning()` + fenced `complete_learning_job()` inside one short `storage.commit_scope()` → `emit_deferred_learning_side_effects()` post-commit (billing / telemetry / tagging / lock release).
+- `services/storage/storage_base/_learning_jobs.py`: `LearningJobStoreABC`, queue status types, coverage-based request status, and the direct-storage contract implemented by each backend.
+
+**Pattern**: `POST /api/publish_interaction` returns immediately when `wait_for_response=false`; callers use the returned `request_id` with `GET /api/learning_status`. Queue workers run the LLM compute **outside** any writer transaction; only the persist half + the fenced `complete_learning_job()` run inside `storage.commit_scope()`, and must raise/rollback if `complete_learning_job()` returns 0 because another worker stole the lease.
 
 ### Reflection and Async Extraction
 
@@ -444,7 +461,8 @@ Key files:
 **Directories**: `services/shadow_comparison/`, `services/evaluation_overview/`
 
 Key files:
-- `shadow_comparison/judge.py`: Per-turn regular-vs-shadow judge that writes shadow verdicts through storage
+- `shadow_comparison/judge.py`: Per-turn regular-vs-shadow judge
+- `shadow_comparison/dispatcher.py` and `shadow_comparison/worker.py`: Publish-time dispatch and bounded background execution for shadow verdict writes
 - `shadow_comparison/outcome.py`: Verdict outcome model helpers
 - `evaluation_overview/service.py`: Aggregates evaluation-page metrics
 - `evaluation_overview/components/hero_state.py`, `evaluation_overview/components/distribution.py`, `evaluation_overview/components/rule_attribution.py`, `evaluation_overview/components/shadow_aggregation.py`: Focused aggregation helpers

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

@@ -230,13 +230,16 @@ if DEBUG_LOG_TO_CONSOLE:
         logging.ERROR
     )
 else:
-    # Production (DEBUG_LOG_TO_CONSOLE off): emit INFO+ app logs to stdout so the
-    # container log driver (e.g. CloudWatch awslogs) captures business-logic audit
-    # lines — billing/webhook/enforcement, etc. Without an explicit handler the
-    # stdlib "handler of last resort" emits only WARNING+ to stderr, so INFO logs
-    # were silently dropped in production. Plain formatter (no colors/files/dedup)
-    # keeps this lean and log-driver friendly — none of the DEBUG-branch overhead.
-    root_logger.setLevel(logging.INFO)
+    # Production (DEBUG_LOG_TO_CONSOLE off): default the root logger to WARNING.
+    # App-wide INFO on a busy server drove ~3x log volume and grew memory to the
+    # container ceiling over a few hours (prod incident 2026-07-04) — so INFO is
+    # OPT-IN per subsystem, not global. A stdout StreamHandler is still attached at
+    # INFO so that any logger explicitly raised to INFO reaches the container log
+    # driver (e.g. CloudWatch awslogs); everything else stays WARNING+ and cheap.
+    #
+    # REFLEXIO_INFO_LOGGERS: comma-separated logger-name prefixes to surface at INFO
+    # (e.g. the billing money-path). Empty/unset => WARNING-only (the safe default).
+    root_logger.setLevel(logging.WARNING)
     if not any(isinstance(h, logging.StreamHandler) for h in root_logger.handlers):
         prod_console_handler = logging.StreamHandler(sys.stdout)
         prod_console_handler.setLevel(logging.INFO)
@@ -245,7 +248,14 @@ else:
         )
         root_logger.addHandler(prod_console_handler)
 
-    # Keep noisy loggers quiet even at INFO (mirror the debug branch's suppression).
+    for _info_logger in (
+        name.strip()
+        for name in os.getenv("REFLEXIO_INFO_LOGGERS", "").split(",")
+        if name.strip()
+    ):
+        logging.getLogger(_info_logger).setLevel(logging.INFO)
+
+    # Keep noisy loggers quiet regardless of the above (mirror the debug branch).
     for _noisy in ("litellm", "LiteLLM", "httpx", "httpcore", "openai", "urllib3"):
         logging.getLogger(_noisy).setLevel(logging.WARNING)
     logging.getLogger("reflexio.server.site_var.site_var_manager").setLevel(

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

@@ -15,6 +15,7 @@ Flags mirror the subset of ``uvicorn`` CLI options that
 from __future__ import annotations
 
 import argparse
+import os
 import sys
 
 import uvicorn
@@ -100,6 +101,11 @@ def main(argv: list[str] | None = None) -> None:
         )
         raise SystemExit(2)
 
+    # Record the configured worker count so per-worker startup guards can read
+    # it (uvicorn exposes no worker-count env inside a worker process). See
+    # ``embedder_warmup._detected_worker_count``.
+    os.environ["REFLEXIO_SERVER_WORKERS"] = str(1 if args.reload else args.workers)
+
     if args.reload:
         uvicorn.run(
             args.app,

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

@@ -16,7 +16,7 @@ iterates (e.g. the QPS billable-endpoint scan over ``core_router.routes``).
 
 import inspect
 import logging
-from collections.abc import Callable
+from collections.abc import Callable, Iterable
 from typing import TYPE_CHECKING
 
 if TYPE_CHECKING:
@@ -77,6 +77,34 @@ __all__ = [
     "limiter",
 ]
 
+
+def _log_multi_worker_daemons() -> None:
+    """Warn once at startup when multiple worker processes will run daemons.
+
+    ``--workers N`` (N>1) runs the full daemon set in every worker process
+    (duplicate ticking). Safe by the concurrent-tick invariant — every daemon
+    tick is concurrent-safe — but worth one visible line (design D3).
+
+    Reuses ``embedder_warmup._detected_worker_count`` (checks
+    ``REFLEXIO_SERVER_WORKERS`` then falls back to ``WEB_CONCURRENCY``)
+    instead of re-implementing a narrower env read here. When the count is
+    undetectable (``None``), this logs nothing — it cannot verify the count,
+    so it must not assume a single worker.
+    """
+    from reflexio.server.llm.providers.embedder_warmup import (
+        _detected_worker_count,
+    )
+
+    workers = _detected_worker_count()
+    if workers is not None and workers > 1:
+        logger.warning(
+            "event=multi_worker_daemons workers=%d — background daemons tick in "
+            "every worker process (duplicate ticking; safe: ticks are "
+            "concurrent-safe by design)",
+            workers,
+        )
+
+
 # ``core_router`` stays an aggregator: it ``include_router``s every domain
 # sub-router so ``core_router.routes`` still enumerates all data-plane handlers
 # (enterprise QPS enforcement iterates this list). The include order is
@@ -269,6 +297,7 @@ def create_app(
     capabilities: "CapabilityRegistry | None" = None,
     app_context_factory: "Callable[[], AppContext] | None" = None,
     profile: "DeploymentProfile | None" = None,
+    durable_org_ids_provider: Callable[[], Iterable[str]] | None = None,
 ) -> FastAPI:
     """Factory to create a FastAPI app.
 
@@ -310,6 +339,16 @@ def create_app(
             provided it is the single source for router-group mounting, auth, and
             data-plane lifespan gating (the legacy knobs still populate the derived
             profile, so callers may pass either — they express the same thing).
+        durable_org_ids_provider: Optional zero-arg callable returning the org_ids
+            with actionable durable-learning work, threaded straight through to
+            ``maybe_start_durable_learning(org_ids_provider=...)``. When None
+            (default) the single-ref bootstrap default is used, so behaviour is
+            byte-identical to before this parameter existed. It is a plain
+            injectable seam so a deployment (e.g. enterprise cross-ref fan-out) can
+            supply its own discovery WITHOUT this factory importing deployment
+            logic. It is only consulted when ``REFLEXIO_DURABLE_LEARNING_QUEUE`` is
+            on — when the flag is off ``maybe_start_durable_learning`` returns None
+            without ever calling the provider.
 
     Returns:
         Configured FastAPI application.
@@ -345,19 +384,40 @@ 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,
     )
     from reflexio.server.services.lineage.gc_scheduler import (
         maybe_start_lineage_gc,
     )
+    from reflexio.server.services.lineage.vector_backfill_sweep import (
+        install_missing_vector_backfill_sweep,
+    )
 
     @asynccontextmanager
     async def lifespan(app: FastAPI) -> AsyncIterator[None]:  # noqa: ARG001
         scheduler = None
         gc_scheduler = None
+        durable_learning_scheduler = None
         started_caps: list = []
+        # D8 config guards + D5 warm-before-ready. Both are dormant unless the
+        # deployment has flipped to the in-process local embedder
+        # (REFLEXIO_EMBEDDING_PROVIDER=inprocess + local/* default); pre-flip
+        # this is a no-op and /health stays byte-for-byte unchanged. Run before
+        # the data-plane block so a gated deployment warms regardless of the
+        # mount profile (otherwise /health could 503 forever).
+        from reflexio.server.llm.providers.embedder_warmup import (
+            maybe_start_embedder_warmup,
+            run_startup_config_guards,
+        )
+
+        run_startup_config_guards()
+        maybe_start_embedder_warmup()
         if mounts_data_plane:
+            _log_multi_worker_daemons()
             log_publish_hardware_capacity()
             validate_llm_availability()
             from reflexio.server.llm.rerank import prewarm as _prewarm_cross_encoder
@@ -372,10 +432,25 @@ def create_app(
                 lambda org_id: RequestContext(org_id=org_id),
                 bootstrap_org_id=bootstrap_org_id,
             )
+            # Register the missing-vector backfill sweep (opt-in via
+            # REFLEXIO_MISSING_VECTOR_BACKFILL_ENABLED) BEFORE starting the GC
+            # scheduler, so its per-org hook is visible when maybe_start_lineage_gc
+            # evaluates its start conditions. No-op when the flag is off.
+            install_missing_vector_backfill_sweep()
             gc_scheduler = maybe_start_lineage_gc(
                 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). A deployment
+            # may inject its own discovery via ``durable_org_ids_provider`` (e.g.
+            # enterprise cross-ref fan-out); when None the single-ref default runs.
+            durable_learning_scheduler = maybe_start_durable_learning(
+                lambda org_id: RequestContext(org_id=org_id),
+                bootstrap_org_id=bootstrap_org_id,
+                org_ids_provider=durable_org_ids_provider,
+            )
         try:
             if capabilities is not None:
                 ctx = (
@@ -397,10 +472,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,
             )