claude-smart 0.2.44 → 0.2.46

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

@@ -0,0 +1,148 @@
+"""Provider-safe base class for LLM structured-output Pydantic models.
+
+Every Pydantic model sent to an LLM as a structured-output schema (a
+``response_format`` or a tool's parameter schema) should inherit
+``StrictStructuredOutput``. It carries a ``__get_pydantic_json_schema__`` hook
+(via ``ProviderSafeUnionMixin``) that folds a discriminated union's ``oneOf`` into
+``anyOf`` and drops ``discriminator`` in the *emitted* JSON schema, so strict
+structured-output endpoints (OpenAI, minimax) accept it **by construction** — with
+no provider-detection gate and no post-processing. Only the wire schema is
+rewritten; the core (validation) schema keeps the discriminator, so keyed dispatch
+and precise per-variant errors are preserved.
+
+This module lives under ``models/`` (depending only on pydantic) so both
+``models/api_schema/`` schemas and ``server/services/*`` models can inherit the
+base without a layering inversion (a ``models/`` file importing from
+``server/llm/`` would invert the dependency direction).
+"""
+
+from typing import TYPE_CHECKING, Any
+
+from pydantic import BaseModel, GetJsonSchemaHandler
+from pydantic.json_schema import JsonSchemaValue
+from pydantic_core import CoreSchema
+
+# Keys whose *values* are name→subschema maps: their entries are user-chosen names
+# (field names, $def names), not JSON-Schema keywords. Traversals must recurse into
+# the subschemas but never treat the names themselves as keywords — otherwise a
+# model with a field literally named ``oneOf`` would be mishandled.
+_SCHEMA_NAME_MAP_KEYS = ("properties", "$defs", "definitions", "patternProperties")
+
+
+def _fold_oneof_to_anyof(node: Any) -> None:
+    """Rewrite ``oneOf`` to ``anyOf`` and drop ``discriminator`` in place (recursive).
+
+    Pydantic emits ``oneOf`` + ``discriminator`` for a discriminated union, which
+    strict structured-output endpoints (OpenAI, minimax) reject. Folding into
+    ``anyOf`` keeps the identical variant set so generation stays constrained;
+    Pydantic still enforces the discriminator after parse, so semantics are
+    preserved.
+
+    Structure-aware: under a name→subschema map (``properties``/``$defs``/…) it
+    recurses into the subschemas but does NOT treat a property/``$def`` *name* as a
+    keyword — so a model field literally named ``oneOf``/``discriminator`` is
+    preserved (only keyword-position occurrences are folded). Precondition:
+    ``node`` is a finite acyclic tree, as produced by ``model_json_schema()``
+    (which expresses recursion via ``$ref``/``$defs`` strings, never in-memory
+    cycles) — there is no cycle guard.
+
+    Args:
+        node (Any): A JSON-schema fragment (dict, list, or scalar); mutated in place.
+    """
+    if isinstance(node, dict):
+        one_of = node.pop("oneOf", None)
+        node.pop("discriminator", None)
+        if isinstance(one_of, list):
+            node["anyOf"] = node.get("anyOf", []) + one_of
+        for key, value in node.items():
+            if key in _SCHEMA_NAME_MAP_KEYS and isinstance(value, dict):
+                for sub in value.values():
+                    _fold_oneof_to_anyof(sub)
+            else:
+                _fold_oneof_to_anyof(value)
+    elif isinstance(node, list):
+        for item in node:
+            _fold_oneof_to_anyof(item)
+
+
+# Statically the mixin must appear to derive from ``BaseModel`` so the ``super()``
+# call below type-checks; at runtime it is a bare mixin (``object`` base), and
+# ``super()`` resolves to ``BaseModel.__get_pydantic_json_schema__`` via the MRO
+# of the concrete model (e.g. ``class X(ProviderSafeUnionMixin, BaseModel)``).
+_ProviderSafeUnionBase = BaseModel if TYPE_CHECKING else object
+
+
+class ProviderSafeUnionMixin(_ProviderSafeUnionBase):
+    """Make a model emit a provider-safe JSON schema by construction.
+
+    A model containing a Pydantic discriminated union serializes to JSON Schema
+    with ``oneOf`` + ``discriminator``, which strict structured-output endpoints
+    reject (the Sentry ``PYTHON-FASTAPI-9J`` incident). Mixing this in folds
+    ``oneOf`` into ``anyOf`` (and drops ``discriminator``) at the model boundary,
+    so every caller of ``model_json_schema()`` — litellm, instructor, our own
+    path — gets a provider-safe schema **unconditionally**, without depending on
+    a provider-detection gate (e.g. ``litellm.supports_response_schema``, which
+    under-reports some providers). Only the JSON (wire) schema is rewritten; the
+    core validation schema keeps the discriminator, so keyed dispatch and precise
+    per-variant errors are preserved.
+
+    Prefer inheriting ``StrictStructuredOutput`` (below) on output models rather
+    than mixing this in directly.
+    """
+
+    @classmethod
+    def __get_pydantic_json_schema__(
+        cls, core_schema: CoreSchema, handler: GetJsonSchemaHandler
+    ) -> JsonSchemaValue:
+        # Chain via super() (not handler() directly) so a cooperative base that
+        # also customizes __get_pydantic_json_schema__ is not silently shadowed;
+        # BaseModel's default impl just invokes handler(core_schema).
+        schema = super().__get_pydantic_json_schema__(core_schema, handler)
+        _fold_oneof_to_anyof(schema)
+        return schema
+
+
+class StrictStructuredOutput(ProviderSafeUnionMixin, BaseModel):
+    """Base for every Pydantic model sent to an LLM as a structured-output schema.
+
+    Inherits the provider-safe schema hook from ``ProviderSafeUnionMixin`` so the
+    emitted JSON schema folds any discriminated union (``oneOf``→``anyOf``, drop
+    ``discriminator``) by construction — accepted by strict structured-output
+    providers with no provider gate, including any *future* discriminated union.
+
+    Deliberately adds NO ``model_config``: each model keeps its own ``extra=`` and
+    ``json_schema_extra`` exactly as before. This base unifies the *provider-safety
+    guarantee*, not the per-model config (centralizing config is a separate change —
+    ``extra=`` is not uniform across models, so a blanket dedup would silently shift
+    validation/serialization behavior).
+    """
+
+
+def find_schema_keyword(node: Any, keyword: str) -> bool:
+    """Report whether ``keyword`` appears as a JSON-Schema *keyword* anywhere in ``node``.
+
+    Structure-aware: an occurrence of ``keyword`` as a property/``$defs`` *name*
+    (e.g. a model field literally named ``oneOf``) is NOT a match — only an
+    occurrence in JSON-Schema keyword position counts. Use this (not a blind
+    ``in``-walk) to check a schema for provider-unsafe keywords.
+
+    Args:
+        node (Any): A JSON-schema fragment (dict, list, or scalar).
+        keyword (str): The JSON-Schema keyword to search for (e.g. ``"oneOf"``).
+
+    Returns:
+        bool: True if ``keyword`` appears in keyword position, else False.
+    """
+    if isinstance(node, dict):
+        if keyword in node:
+            return True
+        for key, value in node.items():
+            if key in _SCHEMA_NAME_MAP_KEYS and isinstance(value, dict):
+                if any(find_schema_keyword(sub, keyword) for sub in value.values()):
+                    return True
+            elif find_schema_keyword(value, keyword):
+                return True
+        return False
+    if isinstance(node, list):
+        return any(find_schema_keyword(item, keyword) for item in node)
+    return False

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

@@ -23,7 +23,7 @@ Client (SDK/Web)
         -> GenerationService (server/services/)
           ├─> ProfileGenerationService -> ProfileExtractor(s) -> Storage
           ├─> PlaybookGenerationService -> PlaybookExtractor(s) -> Storage
-          └─> GroupEvaluationScheduler (deferred 10 min) -> Evaluator(s) -> Storage
+          └─> agent_success_evaluation/scheduler.py:GroupEvaluationScheduler (deferred 10 min) -> agent_success_evaluation/runner.py:run_group_evaluation -> agent_success_evaluation/service.py -> agent_success_evaluation/components/evaluator.py -> Storage
 ```
 
 ## Prerequisites
@@ -41,7 +41,7 @@ cp .env.example .env                         # Configure environment (set at lea
 uv sync                                      # Install Python dependencies (includes workspace packages)
 npm --prefix src/website install         # Install frontend dependencies
 npm --prefix src/public_docs install     # Install docs dependencies
-./run_services.sh                             # Starts API (8081), Website (8080), Docs (8082)
+./run_services.sh                             # Starts API (8061), Website (8080), Docs (8062)
 ./stop_services.sh                            # Stop all services
 ```
 
@@ -56,7 +56,7 @@ npm --prefix src/public_docs install     # Install docs dependencies
 **Testing:**
 ```python
 import reflexio
-client = reflexio.ReflexioClient(api_key="your-api-key", url_endpoint="http://127.0.0.1:8081/")
+client = reflexio.ReflexioClient(api_key="your-api-key", url_endpoint="http://127.0.0.1:8061/")
 ```
 See `notebooks/reflexio_cookbook.ipynb` and `src/tests/readme.md`
 

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

@@ -19,6 +19,7 @@ Description: FastAPI backend server that processes user interactions to generate
   - [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)
+  - [Lineage](#lineage)
   - [Query Reformulator](#query-reformulator)
   - [Unified Search Service](#unified-search-service)
   - [Storage](#storage)
@@ -182,10 +183,11 @@ python -m reflexio.server.scripts.manage_invitation_codes list --show-used
 - **Publish pipeline**: `generation_service.py` coordinates interaction persistence, profile generation, playbook generation, reflection, and deferred evaluation scheduling.
 - **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/`, `shadow_comparison/`, and `evaluation_overview/` handle session grading, per-turn shadow verdicts, regeneration jobs, and dashboard-facing rollups.
+- **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.
 - **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.
 - **Persistence/config**: `storage/`, `configurator/`, and `operation_state_utils.py` provide storage abstractions, config loading, locks, bookmarks, progress, and cancellation.
 
 ### Orchestrator
@@ -221,7 +223,7 @@ Called by API endpoints via `Reflexio`
 - `extractor_config_utils.py`: Shared utility for filtering extractor configs by source, `allow_manual_trigger`, and extractor names
 - `extractor_interaction_utils.py`: Per-extractor utilities for stride_size checking and source filtering
 - `operation_state_utils.py`: Centralized `OperationStateManager` for all `_operation_state` table interactions (progress tracking, concurrency locks, extractor/aggregator bookmarks, simple locks)
-- `deduplication_utils.py`: Shared utilities for LLM-based deduplication (used by ProfileDeduplicator and PlaybookConsolidator)
+- `deduplication_utils.py`: Shared utilities for LLM-based deduplication (used by ProfileConsolidator and PlaybookConsolidator)
 - `service_utils.py`: Utilities (`construct_messages_from_interactions()`, `format_interactions_to_history_string()` (prepends tool usage info when `tools_used` is present), `extract_json_from_string()`, `log_model_response()` for colored LLM response logging)
 
 **Operation State Management** (via `OperationStateManager` in `operation_state_utils.py`):
@@ -242,12 +244,11 @@ Called by API endpoints via `Reflexio`
 **Directory**: `services/profile/`
 
 Key files:
-- `profile_generation_service.py`: Service orchestrator
-- `profile_extractor.py`: Extractor that generates profile updates
-- `profile_updater.py`: Applies updates (add/delete/mention) to storage
-- `profile_deduplicator.py`: Deduplicates newly extracted profiles against existing DB profiles using LLM
+- `service.py`: Service orchestrator and profile persistence/finalization
+- `components/extractor.py`: Extractor that generates profile updates
+- `components/consolidator.py`: Consolidates newly extracted profiles against existing DB profiles using LLM
 
-**Flow**: Interactions → ProfileExtractor (extraction-only) → ProfileDeduplicator (deduplicates new vs existing DB profiles) → ProfileUpdater → Storage
+**Flow**: Interactions → ProfileExtractor (extraction-only) → ProfileConsolidator (deduplicates new vs existing DB profiles) → ProfileGenerationService → Storage
 
 **Generation Modes** (detailed comparison):
 
@@ -308,10 +309,10 @@ Users can regenerate and manage profile versions using a four-state system:
 **Detailed Documentation**: See [`services/playbook/README.md`](services/playbook/README.md) for detailed component documentation.
 
 Key files:
-- `playbook_generation_service.py`: Service orchestrator
-- `playbook_extractor.py`: Extractor that extracts user playbooks
-- `playbook_aggregator.py`: Aggregates similar user playbooks (with cluster-level change detection to skip unchanged clusters)
-- `playbook_consolidator.py`: Reconciles newly extracted playbooks against existing DB playbooks using LLM
+- `service.py`: Service orchestrator
+- `components/extractor.py`: Extractor that extracts user playbooks
+- `components/aggregator.py`: Aggregates similar user playbooks (with cluster-level change detection to skip unchanged clusters)
+- `components/consolidator.py`: Reconciles newly extracted playbooks against existing DB playbooks using LLM
 
 **Flow**:
 - Interactions → PlaybookExtractor (extraction-only) → PlaybookConsolidator (consolidates new vs existing DB playbooks) → UserPlaybook (with optional `blocking_issue`) → Storage
@@ -321,7 +322,7 @@ Key files:
 
 **Rerun Behavior**: Groups interactions by `user_id` for per-user playbook extraction (fetches all users, then processes each user's interactions together)
 
-**Playbook Aggregation with Cluster Change Detection** (`playbook_aggregator.py`):
+**Playbook Aggregation with Cluster Change Detection** (`components/aggregator.py`):
 
 Aggregation clusters user playbooks by embedding similarity, then calls LLM per cluster to produce aggregated agent playbooks. Cluster-level change detection avoids redundant LLM calls on subsequent runs:
 
@@ -339,7 +340,7 @@ Aggregation clusters user playbooks by embedding similarity, then calls LLM per
 | No changes | Logs skip message, updates bookmark, returns early |
 | Error during save | Restores only selectively archived playbooks |
 
-**Change Log Tracking**: After each aggregation run, a `PlaybookAggregationChangeLog` is saved with before/after snapshots of added, removed, and updated playbooks. Viewable via `GET /api/playbook_aggregation_change_logs`. Change log saving is best-effort (failures are logged but don't block aggregation).
+**Change Log Tracking**: The legacy `playbook_aggregation_change_logs` table is retired (Track B, 2026-06-24) — the aggregator no longer writes it. The change-log view served by `GET /api/playbook_aggregation_change_logs` is reconstructed on demand from `lineage_event` rows via `reconstruct_playbook_aggregation_change_log` (`lib/_agent_playbook.py`): each run's `op=aggregate` events form the "added" side and its `status_change→superseded` events form the "removed" side, grouped by `request_id`. Per-row `updated` pairing is not reconstructed (`updated_agent_playbooks=[]`, a tolerated parity delta).
 
 **Generation Modes** (detailed comparison):
 
@@ -381,16 +382,16 @@ Similar to profiles, user playbooks support versioning:
 **Directory**: `services/agent_success_evaluation/`
 
 Key files:
-- `agent_success_evaluation_service.py`: Service orchestrator (tracks run outcome flags: `last_run_result_count`, `has_run_failures()`)
-- `agent_success_evaluator.py`: Evaluates success at session level (all interactions as one group)
+- `service.py`: `AgentSuccessEvaluationService`, the request-path service orchestrator (tracks run outcome flags: `last_run_result_count`, `has_run_failures()`)
+- `components/evaluator.py`: `AgentSuccessEvaluator`, evaluates success at session level (all interactions as one group)
 - `agent_success_evaluation_constants.py`: Output schema (`AgentSuccessEvaluationOutput`)
 - `agent_success_evaluation_utils.py`: Message construction utilities
-- `delayed_group_evaluator.py`: `GroupEvaluationScheduler` singleton - min-heap priority queue with daemon thread, defers evaluation until 10 min after last request in session
-- `group_evaluation_runner.py`: `run_group_evaluation()` - fetches all requests/interactions for a session, builds `RequestInteractionDataModel` list, runs evaluation
+- `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`
 
-**Flow**: Interactions → (deferred 10 min) → GroupEvaluationScheduler → run_group_evaluation → AgentSuccessEvaluator → AgentSuccessEvaluationResult → Storage
+**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
 
-**Session-Level Evaluation**: Evaluator treats all `request_interaction_data_models` in a session as a single conversation. Sampling rate checked once per session (not per-request). Result keyed by `session_id` (not `request_id`).
+**Session-Level Evaluation**: Evaluator treats one user's `request_interaction_data_models` in a session as a single conversation. Sampling rate checked once per session (not per-request). Results are keyed by `(user_id, session_id, evaluation_name)` so reused session IDs across users do not clobber each other.
 
 **Tool Context**: Reads `tool_can_use` from root `Config` level (shared with playbook extraction).
 
@@ -401,14 +402,14 @@ Key files:
 **Directories**: `services/reflection/`, `services/extraction/`
 
 Key files:
-- `reflection/reflection_service.py`: Post-horizon reflection orchestration for synthesizing longer-range memory artifacts
-- `reflection/reflection_extractor.py`: LLM extractor used by the reflection service
+- `reflection/service.py`: Post-horizon reflection orchestration for synthesizing longer-range memory artifacts
+- `reflection/components/extractor.py`: LLM extractor used by the reflection service
 - `extraction/resumable_agent.py`: Resumable extraction agent runtime
 - `extraction/resume_scheduler.py` and `extraction/resume_worker.py`: Background scheduling/worker loop for paused extraction runs
-- `extraction/tools.py` and `extraction/prior_answer_search.py`: Tool surface for async extraction agents
+- `extraction/pending_tool_call_dispatch.py` and `extraction/prior_answer_search.py`: Tool surface and prior-answer context for async extraction agents
 - `extraction/agent_run_records.py`: Persistence helpers for extraction-agent run state
 
-**Pattern**: Synchronous profile/playbook/evaluation services still follow `BaseGenerationService`; async extraction uses resumable agent-run records and worker scheduling so long-running or tool-mediated extraction can continue outside the request path.
+**Pattern**: Synchronous profile/playbook/evaluation services still follow `BaseGenerationService`; async extraction is a shared runtime package that uses resumable agent-run records and worker scheduling so long-running or tool-mediated extraction can continue outside the request path.
 
 ### Shadow Comparison and Evaluation Overview
 
@@ -418,7 +419,8 @@ Key files:
 - `shadow_comparison/judge.py`: Per-turn regular-vs-shadow judge that writes shadow verdicts through storage
 - `shadow_comparison/outcome.py`: Verdict outcome model helpers
 - `evaluation_overview/service.py`: Aggregates evaluation-page metrics
-- `evaluation_overview/hero_state.py`, `distribution.py`, `group_aggregation.py`, `rule_attribution.py`, `shadow_aggregation.py`: Focused aggregation helpers
+- `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
+- `evaluation_overview/eval_sampler.py`: Evaluation sampling helpers that remain root-level
 
 **Pattern**: Session-level agent success evaluation remains in `agent_success_evaluation/`; dashboard-facing rollups and per-turn shadow verdict analysis live in these companion directories.
 
@@ -435,6 +437,17 @@ Key files:
 
 **Pattern**: These are evaluation/optimization integrations around the core playbook pipeline. Keep production extraction changes in `services/playbook/`; use optimizer/Braintrust modules for experiments, rollouts, and external eval sync.
 
+### Lineage
+
+**Directory**: `services/lineage/`
+
+| File | Purpose |
+|------|---------|
+| `resolve.py` | Helpers for resolving current records across supersede chains and status transitions. |
+| `gc_scheduler.py` | Tombstone garbage-collection scheduler for lineage-aware storage cleanup. |
+
+**Pattern**: profile/playbook update paths preserve lineage metadata in storage; service code asks lineage helpers to find current records rather than walking superseded chains ad hoc.
+
 ### Query Reformulator
 
 **File**: `services/pre_retrieval/_query_reformulator.py` - `QueryReformulator`
@@ -464,8 +477,8 @@ Pre-computed embeddings passed to storage methods via `query_embedding` paramete
 
 | File | Purpose |
 |------|---------|
-| `storage_base/` | BaseStorage interface split by domain (`_profiles.py`, `_playbook.py`, `_requests.py`, `_operations.py`, `_agent_run.py`, `_shadow_verdicts.py`, `_stall_state.py`, `_share_links.py`) |
-| `sqlite_storage/` | SQLite-backed implementation split across the same domains |
+| `storage_base/` | BaseStorage interface split by domain (`_profiles.py`, `_playbook.py`, `_requests.py`, `_operations.py`, `_agent_run.py`, `_lineage.py`, `_shadow_verdicts.py`, `_stall_state.py`, `_share_links.py`) |
+| `sqlite_storage/` | SQLite-backed implementation split across the same domains, including lineage/tombstone support in `_lineage.py` |
 | `retention.py`, `retention_mixin.py` | Data retention and cleanup helpers |
 | `constants.py`, `error.py` | Storage constants and shared errors |
 
@@ -513,7 +526,7 @@ API Request (api.py)
         -> GenerationService
           ├─> ProfileGenerationService → Storage
           ├─> PlaybookGenerationService → Storage
-          └─> GroupEvaluationScheduler (deferred 10 min) → run_group_evaluation → Storage
+          └─> agent_success_evaluation/scheduler.py:GroupEvaluationScheduler (deferred 10 min) → agent_success_evaluation/runner.py:run_group_evaluation → agent_success_evaluation/service.py → Storage
 ```
 
 ```mermaid
@@ -529,9 +542,9 @@ flowchart TB
     subgraph ProfileService["ProfileGenerationService"]
         E --> F1[ProfileExtractor 1]
         E --> F2[ProfileExtractor N]
-        F1 --> PD[ProfileDeduplicator]
-        F2 --> PD
-        PD --> PU[ProfileUpdater]
+        F1 --> PC[ProfileConsolidator]
+        F2 --> PC
+        PC --> PU[ProfileUpdater]
     end
 
     subgraph PlaybookService["PlaybookGenerationService"]
@@ -542,7 +555,7 @@ flowchart TB
     end
 
     subgraph EvalService["AgentSuccessEvaluationService"]
-        E -.->|deferred 10 min| SCH[GroupEvaluationScheduler]
+        E -.->|deferred 10 min| SCH[agent_success_evaluation/scheduler.py<br/>GroupEvaluationScheduler]
         SCH --> H1[AgentSuccessEvaluator 1]
         SCH --> H2[AgentSuccessEvaluator N]
     end
@@ -561,7 +574,7 @@ flowchart TB
     J -.-> F1
     J -.-> G1
     J -.-> H1
-    J -.-> PD
+    J -.-> PC
     J -.-> FD
     K -.-> F1
     K -.-> G1

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

@@ -38,9 +38,6 @@ LOCAL_STORAGE_PATH = (
 INTERACTION_CLEANUP_THRESHOLD = int(
     os.environ.get("INTERACTION_CLEANUP_THRESHOLD", "250000")
 )
-INTERACTION_CLEANUP_DELETE_COUNT = int(
-    os.environ.get("INTERACTION_CLEANUP_DELETE_COUNT", "50000")
-)
 
 # Logging
 
@@ -131,10 +128,37 @@ class _LLMIOFormatter(_TZAwareFormatter):
         )
 
 
-DEBUG_LOG_TO_CONSOLE = os.environ.get("DEBUG_LOG_TO_CONSOLE", "").strip().lower()
+def _truthy_env(name: str) -> bool:
+    """Return whether an environment variable is explicitly truthy."""
+    raw = os.environ.get(name, "").strip().lower()
+    return raw in ("true", "yes", "1", "on")
+
+
+def _is_production_environment() -> bool:
+    """Return whether this process is running in a production deployment."""
+    return os.environ.get("ENVIRONMENT", "").strip().lower() in ("prod", "production")
+
+
+def _debug_log_to_console_enabled() -> bool:
+    """Return whether verbose console logging should be enabled.
+
+    ``DEBUG_LOG_TO_CONSOLE`` is a local/dev switch. Deployments with
+    ``ENVIRONMENT=production`` must stay quiet by default even if a copied local
+    env file accidentally sets it;
+    use ``REFLEXIO_ALLOW_PRODUCTION_DEBUG_LOGS=true`` for a deliberate incident
+    override.
+    """
+    if not _truthy_env("DEBUG_LOG_TO_CONSOLE"):
+        return False
+    return not _is_production_environment() or _truthy_env(
+        "REFLEXIO_ALLOW_PRODUCTION_DEBUG_LOGS"
+    )
+
+
+DEBUG_LOG_TO_CONSOLE = _debug_log_to_console_enabled()
 root_logger = logging.getLogger()
 
-if DEBUG_LOG_TO_CONSOLE and DEBUG_LOG_TO_CONSOLE not in ("false", "0", "no"):
+if DEBUG_LOG_TO_CONSOLE:
     # Correlation ID filter — injects %(correlation_id)s into every record
     from reflexio.server.correlation import CorrelationIdFilter
 

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

@@ -3,10 +3,10 @@
 Run the FastAPI backend with Reflexio's uvicorn log config applied upfront::
 
     # Dev mode (autoreload, single process):
-    python -m reflexio.server --port 8081 --reload
+    python -m reflexio.server --port 8061 --reload
 
     # Daemon mode (multi-worker with recycling):
-    python -m reflexio.server --port 8081 --workers 2 --max-requests 10000
+    python -m reflexio.server --port 8061 --workers 2 --max-requests 10000
 
 Flags mirror the subset of ``uvicorn`` CLI options that
 :func:`reflexio.cli.run_services.build_backend_service` uses.

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

@@ -9,17 +9,80 @@ import graph acyclic.
 
 from __future__ import annotations
 
+from collections.abc import Callable
+from functools import cache
+
 DEFAULT_ORG_ID = "self-host-org"
 
 
 def default_get_org_id() -> str:
     """Return the default organization ID for local hosting.
 
-    Enterprise deployments override this via
+    Reads ``REFLEXIO_DEFAULT_ORG_ID`` (unset/blank falls back to
+    :data:`DEFAULT_ORG_ID`) so a no-auth deployment can run under a distinct
+    org id without colliding with another local backend that shares
+    ``~/.reflexio/configs/``. claude-smart and the self-host backend otherwise
+    both default to ``self-host-org`` and fight over the same
+    ``config_self-host-org.json``.
+
+    Enterprise deployments never reach this: they override the dependency via
     ``app.dependency_overrides[default_get_org_id] = <bearer_auth_resolver>``
     inside :func:`reflexio.server.api.create_app`.
 
     Returns:
         str: The default org identifier used for self-hosted deployments.
     """
-    return DEFAULT_ORG_ID
+    # Lazy import keeps this deliberately cycle-free module independent of the
+    # ``reflexio.server`` package init (see module docstring).
+    from reflexio.server.env_utils import env_str
+
+    return env_str("REFLEXIO_DEFAULT_ORG_ID", DEFAULT_ORG_ID)
+
+
+def default_get_caller_type() -> str:
+    """Return the default caller type for local / self-hosted deployments.
+
+    Every call is treated as ``"internal"`` (no billing discrimination) in the
+    OSS build.  Enterprise deployments override this via
+    ``app.dependency_overrides[default_get_caller_type] = <classifier>``
+    inside :func:`reflexio.server.api.create_app`, exactly like
+    :func:`default_get_org_id`.
+
+    Returns:
+        str: The literal ``"internal"`` — equals ``BillingCallerType.INTERNAL.value``
+            (kept as a plain string here so OSS stays free of reflexio_ext imports).
+    """
+    return "internal"  # == BillingCallerType.INTERNAL.value; literal keeps OSS clean
+
+
+@cache
+def default_billing_gate(line: str) -> Callable[..., None]:  # noqa: ARG001
+    """Return a stable no-op FastAPI dependency for the billing gate.
+
+    OSS / self-hosted deployments run without enforcement — this factory
+    always returns a dependency that does nothing.  Enterprise deployments
+    supply a real gate factory via the ``get_billing_gate`` parameter of
+    :func:`reflexio.server.api.create_app`, exactly mirroring how
+    ``get_caller_type`` overrides :func:`default_get_caller_type`.
+
+    ``lru_cache`` ensures the **same callable object** is returned for the
+    same ``line`` value.  FastAPI uses callable identity for
+    ``dependency_overrides``, so caching is essential: without it, each
+    ``Depends(default_billing_gate("application"))`` would create a fresh
+    closure and overrides would silently never fire.
+
+    OSS code must never import from ``reflexio_ext`` — the gate wiring is
+    purely additive and backwards-compatible.
+
+    Args:
+        line (str): Billing line (e.g. ``"application"``, ``"learnings_generated"``).
+            Accepted but unused in the default no-op implementation.
+
+    Returns:
+        Callable[..., None]: A FastAPI dependency that always passes through.
+    """
+
+    def _noop() -> None:
+        """No-op billing gate for OSS / self-hosted deployments."""
+
+    return _noop