superlocalmemory 4.1.13 → 4.1.14

package/src/superlocalmemory/server/__init__.py

@@ -1 +0,0 @@
-# Server package — API and UI servers

package/src/superlocalmemory/server/api.py

@@ -1,310 +0,0 @@
-#!/usr/bin/env python3
-# Copyright (c) 2026 Varun Pratap Bhardwaj / Qualixar
-# Licensed under AGPL-3.0-or-later - see LICENSE file
-# Part of SuperLocalMemory V3 | https://qualixar.com | https://varunpratap.com
-"""
-SuperLocalMemory V3 - FastAPI API Server
-Provides REST endpoints for memory visualization and exploration.
-Uses V3 MemoryEngine for all operations.
-
-v3.7.8 (WS3 F4): ``create_app()`` in this module is a standalone/legacy app
-factory. The running daemon serves ``superlocalmemory.server.unified_daemon:
-create_app`` (see ``unified_daemon.py``'s uvicorn config); THIS factory is
-reachable only via direct ``python -m superlocalmemory.server.api`` /
-programmatic use and the tests that exercise it directly
-(``tests/test_api/test_api_lifespan_contract.py``,
-``tests/test_security/test_rate_limit_e2e.py``). Its ``auth_middleware``
-below intentionally keeps the older, simpler ``check_api_key``-only gate
-(unconditional per-write check, no daemon-capability / install-token
-identity layer) because it predates and is independent of the unified
-daemon's richer ``write_identity.require_http_mutation_actor`` boundary and
-the ``SLM_REQUIRE_API_KEY_LOOPBACK`` opt-in (see
-``infra/auth_middleware.py``). Do not treat this module's auth posture as
-the production write boundary -- that is ``unified_daemon.py``'s
-``auth_middleware``. ``UI_DIR`` below is still imported by
-``unified_daemon.py`` and must not be removed.
-"""
-
-import json
-import logging
-from pathlib import Path
-from contextlib import asynccontextmanager
-from typing import Optional
-
-from fastapi import FastAPI, HTTPException, Query, Request
-from fastapi.staticfiles import StaticFiles
-from fastapi.responses import HTMLResponse
-from fastapi.middleware.cors import CORSMiddleware
-from fastapi.middleware.gzip import GZipMiddleware
-from pydantic import BaseModel
-import uvicorn
-
-from superlocalmemory.core.config import CANONICAL_RECALL_LIMIT
-from superlocalmemory.server.security_middleware import SecurityHeadersMiddleware
-from superlocalmemory.server.routes.helpers import SLM_VERSION
-from superlocalmemory.infra.data_root import DynamicStatePath
-
-logger = logging.getLogger("superlocalmemory.api_server")
-
-# V3 paths
-MEMORY_DIR = DynamicStatePath()
-DB_PATH = DynamicStatePath("memory.db")
-# V3.3.21+: the dashboard ships inside the package (superlocalmemory/ui) for
-# every install path. The legacy repo-root ui/ dev fallback was retired in
-# v3.8.0 when that copy was deleted; the packaged directory is authoritative.
-UI_DIR = Path(__file__).resolve().parent.parent / "ui"
-
-
-# ============================================================================
-# Request/Response Models
-# ============================================================================
-
-class SearchRequest(BaseModel):
-    query: str
-    limit: int = CANONICAL_RECALL_LIMIT
-    min_score: float = 0.3
-
-
-class MemoryFilter(BaseModel):
-    category: Optional[str] = None
-    project_name: Optional[str] = None
-    cluster_id: Optional[int] = None
-    min_importance: Optional[int] = None
-
-
-# ============================================================================
-# V3 Engine Initialization (lifespan context)
-# ============================================================================
-
-@asynccontextmanager
-async def lifespan(application: FastAPI):
-    """Initialize V3 engine on startup, cleanup on shutdown."""
-    try:
-        from superlocalmemory.core.config import SLMConfig
-        from superlocalmemory.core.engine import MemoryEngine
-
-        config = SLMConfig.load()
-        engine = MemoryEngine(config)
-        engine.initialize()
-        application.state.engine = engine
-        application.state.config = config
-        logger.info("V3 MemoryEngine initialized: mode=%s", config.mode.value)
-    except Exception as exc:
-        logger.warning("V3 engine init failed (API will use fallback): %s", exc)
-        application.state.engine = None
-        application.state.config = None
-
-    # Event fan-out belongs to the same application lifecycle as the engine.
-    # Registering it through FastAPI.on_event created a second, deprecated
-    # startup path and made TestClient initialization emit warnings.
-    from superlocalmemory.server.routes.events import register_event_listener
-
-    register_event_listener()
-    yield
-
-    # Cleanup
-    if hasattr(application.state, 'engine') and application.state.engine:
-        application.state.engine.close()
-
-
-def create_app() -> FastAPI:
-    """Create and configure the FastAPI application."""
-    application = FastAPI(
-        title="SuperLocalMemory V4 API",
-        description="V4 Memory Engine REST API",
-        version=SLM_VERSION,
-        lifespan=lifespan,
-    )
-
-    # Middleware
-    application.add_middleware(SecurityHeadersMiddleware)
-    application.add_middleware(GZipMiddleware, minimum_size=1000)
-    application.add_middleware(
-        CORSMiddleware,
-        allow_origins=[
-            "http://localhost:8765", "http://127.0.0.1:8765",
-            "http://localhost:8417", "http://127.0.0.1:8417",
-        ],
-        allow_credentials=True,
-        allow_methods=["GET", "POST", "PUT", "DELETE", "PATCH", "OPTIONS"],
-        allow_headers=["Content-Type", "Authorization", "X-SLM-API-Key"],
-    )
-
-    # Rate limiting (graceful)
-    try:
-        from superlocalmemory.infra.rate_limiter import RateLimiter
-        from superlocalmemory.core.remote_mode import (
-            rate_limit_config,
-            is_rate_limit_exempt,
-        )
-        # v3.6.12 (issue #40): env-tunable thresholds (defaults unchanged).
-        _rl_write, _rl_read, _rl_window = rate_limit_config()
-        _write_limiter = RateLimiter(max_requests=_rl_write, window_seconds=_rl_window)
-        _read_limiter = RateLimiter(max_requests=_rl_read, window_seconds=_rl_window)
-
-        @application.middleware("http")
-        async def rate_limit_middleware(request, call_next):
-            client_ip = request.client.host if request.client else "unknown"
-            if is_rate_limit_exempt(client_ip):
-                return await call_next(request)
-            is_write = request.method in ("POST", "PUT", "DELETE", "PATCH")
-            limiter = _write_limiter if is_write else _read_limiter
-            allowed, remaining = limiter.is_allowed(client_ip)
-            if not allowed:
-                from fastapi.responses import JSONResponse
-                return JSONResponse(
-                    status_code=429,
-                    content={"error": "Too many requests."},
-                    headers={"Retry-After": str(limiter.window)},
-                )
-            response = await call_next(request)
-            response.headers["X-RateLimit-Remaining"] = str(remaining)
-            return response
-    except (ImportError, Exception):
-        pass
-
-    # Auth middleware (graceful)
-    try:
-        from superlocalmemory.infra.auth_middleware import check_api_key
-
-        @application.middleware("http")
-        async def auth_middleware(request, call_next):
-            is_write = request.method in ("POST", "PUT", "DELETE", "PATCH")
-            headers = dict(request.headers)
-            if not check_api_key(headers, is_write=is_write):
-                from fastapi.responses import JSONResponse
-                return JSONResponse(
-                    status_code=401,
-                    content={"error": "Invalid or missing API key."},
-                )
-            response = await call_next(request)
-            return response
-    except (ImportError, Exception):
-        pass
-
-    # Mount static files
-    UI_DIR.mkdir(exist_ok=True)
-    application.mount("/static", StaticFiles(directory=str(UI_DIR)), name="static")
-
-    # ========================================================================
-    # Register Route Modules
-    # ========================================================================
-    from superlocalmemory.server.routes.memories import router as memories_router
-    from superlocalmemory.server.routes.stats import router as stats_router
-    from superlocalmemory.server.routes.profiles import router as profiles_router
-    from superlocalmemory.server.routes.backup import router as backup_router
-    from superlocalmemory.server.routes.data_io import router as data_io_router
-    from superlocalmemory.server.routes.events import router as events_router
-    from superlocalmemory.server.routes.agents import router as agents_router
-    from superlocalmemory.server.routes.ws import router as ws_router, manager as ws_manager
-    from superlocalmemory.server.routes.v3_api import router as v3_router
-
-    application.include_router(memories_router)
-    application.include_router(stats_router)
-    application.include_router(profiles_router)
-    application.include_router(backup_router)
-    application.include_router(data_io_router)
-    application.include_router(events_router)
-    application.include_router(agents_router)
-    application.include_router(ws_router)
-    application.include_router(v3_router)
-
-    # v3.4.1: Chat SSE endpoint
-    for _module_name_v341 in ("chat",):
-        try:
-            _mod_v341 = __import__(f"superlocalmemory.server.routes.{_module_name_v341}", fromlist=["router"])
-            application.include_router(_mod_v341.router)
-        except (ImportError, Exception):
-            pass
-
-    # Graceful optional routers
-    for _module_name in ("learning", "lifecycle", "behavioral", "compliance", "insights", "timeline"):
-        try:
-            _mod = __import__(f"superlocalmemory.server.routes.{_module_name}", fromlist=["router"])
-            application.include_router(_mod.router)
-        except (ImportError, Exception):
-            pass
-
-    # Wire WebSocket manager
-    import superlocalmemory.server.routes.profiles as _profiles_mod
-    import superlocalmemory.server.routes.data_io as _data_io_mod
-    _profiles_mod.ws_manager = ws_manager
-    _data_io_mod.ws_manager = ws_manager
-
-    # ========================================================================
-    # Basic Routes
-    # ========================================================================
-
-    @application.get("/", response_class=HTMLResponse)
-    async def root():
-        """Serve main UI page."""
-        index_path = UI_DIR / "index.html"
-        if not index_path.exists():
-            return (
-                "<html><head><title>SuperLocalMemory V4</title></head>"
-                "<body style='font-family:Arial;padding:40px'>"
-                "<h1>SuperLocalMemory V4 API Server Running</h1>"
-                "<p><a href='/docs'>API Documentation</a></p>"
-                "</body></html>"
-            )
-        from superlocalmemory import __version__ as _v
-
-        # __SLM_VERSION__ was substituted only by the unified daemon, so the
-        # dashboard's upgrade detector did nothing when served from here.
-        # Asset versioning is cosmetic. It must never be why this page 500s.
-        #
-        # The import is deferred (house style, keeps startup lean), which means
-        # it resolves at REQUEST time — so when `pip install -e .` replaced the
-        # installed package underneath a running daemon, this route began
-        # answering "Internal Server Error" on the dashboard while every other
-        # endpoint was fine. A stale hand-written version string is a trifle; a
-        # blank page is not. Fall back to the file as written.
-        try:
-            from superlocalmemory.server.asset_versions import render_index
-
-            return render_index(
-                index_path, UI_DIR, substitutions={"__SLM_VERSION__": _v},
-            )
-        except Exception as exc:  # noqa: BLE001 — serve the page regardless
-            logger.warning(
-                "asset version rewrite unavailable, serving index.html as "
-                "written: %s: %s", type(exc).__name__, exc,
-            )
-            return index_path.read_text().replace("__SLM_VERSION__", _v)
-
-    @application.get("/health")
-    async def health_check():
-        """Health check."""
-        from datetime import datetime, timezone
-        engine = application.state.engine
-        return {
-            "status": "healthy",
-            "version": SLM_VERSION,
-            "engine": "initialized" if engine else "unavailable",
-            "database": "connected" if DB_PATH.exists() else "missing",
-            "timestamp": datetime.now(timezone.utc).isoformat(),
-        }
-
-    return application
-
-
-# v3.4.3: Module-level app removed to prevent duplicate MemoryEngine.
-# The unified daemon (server/unified_daemon.py) imports routes from this
-# module via _register_dashboard_routes(). Do NOT create app here.
-# For standalone use: python -m superlocalmemory.server.api
-
-if __name__ == "__main__":
-    app = create_app()
-    print("=" * 60)
-    print("SuperLocalMemory V4 - API Server (standalone mode)")
-    print("=" * 60)
-    print(f"Database: {DB_PATH}")
-    print(f"UI Directory: {UI_DIR}")
-    print("=" * 60)
-    print("\nStarting server on http://localhost:8000")
-    print("API Documentation: http://localhost:8000/docs")
-    print("\nPress Ctrl+C to stop\n")
-
-    uvicorn.run(
-        app, host="127.0.0.1", port=8000, log_level="info",
-    )

package/src/superlocalmemory/server/asset_versions.py

@@ -1,171 +0,0 @@
-# Copyright (c) 2026 Varun Pratap Bhardwaj / Qualixar
-# Licensed under AGPL-3.0-or-later - see LICENSE file
-
-"""Derive the dashboard's asset cache-busters from the files themselves.
-
-``index.html`` referenced 64 static assets. 35 carried a hand-written
-``?v=`` literal and 29 carried nothing, and not one of them was derived from the
-file it pointed at. So the version strings looked like cache-busting and were
-not: editing a JS or CSS file left its ``?v=`` reading whatever the last person
-typed, which during 4.0.10 was ``022ff653`` on a file that had changed.
-
-WHAT THIS DOES AND DOES NOT FIX
--------------------------------
-It does not fix a live user-facing bug, and it would be dishonest to claim it
-does. Three mechanisms already stop a stale asset reaching a browser on this
-server, and the first was verified against the running daemon rather than read:
-
-  * ``/static/*`` is served ``Cache-Control: no-cache, must-revalidate`` with an
-    ETag (``server/security_middleware.py``), so a browser must revalidate and
-    cannot serve a cached copy without asking.
-  * The unified daemon copies the whole UI tree into the data directory on every
-    start (``unified_daemon.py``, ``state_path("ui")``), so an upgrade refreshes
-    the files it serves.
-  * ``index.html`` itself is ``no-cache``, so the page is always re-read.
-
-What it fixes is a **trap**, and unblocks a real improvement:
-
-  * 64 references, none tracking content. Anyone reading them concludes
-    cache-busting is handled here, which is how the 4.0.10 change shipped with a
-    stale literal and how the next one would too. A number that is maintained by
-    hand and consulted by nobody is worse than no number.
-  * The revalidation policy is the only thing making that safe, and it costs a
-    conditional request per asset on every page load — 64 of them. The obvious
-    optimisation is ``max-age`` with a long life, and today that change would
-    turn every hand-typed literal into an immediate live bug. With versions
-    derived from content it becomes safe to make. That policy change is NOT
-    made here; it needs its own measurement.
-  * A proxy or CDN that ignores ``no-cache`` is defeated by a URL that changes,
-    not by a header.
-
-DESIGN
-------
-Rewrite at serve time rather than at build time, because there is no build step:
-the UI ships as source files and is copied into place. The hash is computed from
-file bytes and cached on ``(size, mtime_ns)``, so a warm daemon does one ``stat``
-per asset per page load and no reads. Unresolvable references keep whatever the
-HTML said, so a missing file or an odd path degrades to today's behaviour rather
-than breaking the page.
-"""
-
-from __future__ import annotations
-
-import hashlib
-import logging
-import re
-from pathlib import Path
-
-logger = logging.getLogger(__name__)
-
-__all__ = ["render_index", "asset_version", "rewrite_asset_versions"]
-
-#: Characters of hex digest used in a URL. Eight is what the existing literals
-#: used and is ample: these identify one file's revisions, not a global
-#: namespace, so a collision needs two versions of the same file agreeing on
-#: eight hex characters.
-_HASH_CHARS = 8
-
-#: ``src="static/…"`` / ``href="static/…"`` with an optional existing ``?v=``.
-#: Deliberately narrow — only the ``static/`` prefix the dashboard mounts, only
-#: double-quoted attributes, and the path is captured without its query so the
-#: rewrite cannot alter it.
-_ASSET_REF = re.compile(
-    r'(?P<attr>\b(?:src|href)=")'
-    r'(?P<path>static/[^"?#]+)'
-    r'(?P<query>\?[^"#]*)?'
-    r'(?P<fragment>#[^"]*)?'
-    r'(?P<close>")'
-)
-
-#: (resolved path) -> (size, mtime_ns, digest). Keyed on the path so a daemon
-#: serving from the data-directory copy and one serving from the source tree do
-#: not share entries.
-_CACHE: dict[Path, tuple[int, int, str]] = {}
-
-
-def asset_version(asset_path: Path) -> str | None:
-    """Short content hash of ``asset_path``, or None if it cannot be read.
-
-    Cached on ``(size, mtime_ns)``. That pair is what ETag generators use for
-    the same reason: it changes on every practical edit, and re-reading a file
-    that has not changed costs a page-load's worth of I/O for nothing.
-
-    ``mtime_ns`` rather than ``mtime``: the UI is installed with
-    ``shutil.copytree``, which preserves timestamps, so two files written inside
-    the same filesystem tick are a real possibility on a fast copy.
-    """
-    try:
-        stat = asset_path.stat()
-    except OSError:
-        return None
-
-    key = (stat.st_size, stat.st_mtime_ns)
-    cached = _CACHE.get(asset_path)
-    if cached is not None and cached[:2] == key:
-        return cached[2]
-
-    try:
-        digest = hashlib.sha256(asset_path.read_bytes()).hexdigest()[:_HASH_CHARS]
-    except OSError as exc:
-        logger.debug("asset version unavailable for %s: %s", asset_path, exc)
-        return None
-
-    _CACHE[asset_path] = (*key, digest)
-    return digest
-
-
-def rewrite_asset_versions(html: str, ui_root: Path) -> str:
-    """Replace every ``static/…?v=`` with a version derived from the file.
-
-    ``ui_root`` is the directory mounted at ``/static``, so a reference to
-    ``static/js/core.js`` resolves to ``ui_root/js/core.js`` — the ``static/``
-    segment is the mount point, not a directory on disk. Getting that wrong
-    silently resolves nothing and leaves all 64 literals in place, which is why
-    the test asserts a version actually moved rather than only that the call
-    returned.
-
-    Assets with no existing query gain one. That is a URL change, and it is the
-    point: 29 of the 64 references had no cache-buster at all, so they were the
-    ones a policy change would break first.
-    """
-
-    def _replace(match: re.Match[str]) -> str:
-        path = match.group("path")
-        version = asset_version(ui_root / path[len("static/"):])
-        if version is None:
-            # Keep whatever the HTML said. A reference we cannot resolve is not
-            # a reason to serve a page that cannot load its own stylesheet.
-            return match.group(0)
-        return (
-            f"{match.group('attr')}{path}?v={version}"
-            f"{match.group('fragment') or ''}{match.group('close')}"
-        )
-
-    return _ASSET_REF.sub(_replace, html)
-
-
-def render_index(
-    index_path: Path,
-    ui_root: Path | None = None,
-    *,
-    substitutions: dict[str, str] | None = None,
-) -> str:
-    """Read ``index.html`` and prepare it for serving.
-
-    One function for the three ``root()`` handlers (``api.py``, ``ui.py``,
-    ``unified_daemon.py``) that each read this file and returned it. They had
-    drifted: only the daemon substituted ``__SLM_VERSION__``, so the upgrade
-    detector the dashboard relies on silently did nothing on the other two.
-
-    ``ui_root`` defaults to the file's own directory, which is correct for every
-    caller today — ``index.html`` sits at the root of the tree mounted at
-    ``/static``.
-
-    Raises ``OSError`` if the index itself cannot be read; every caller already
-    checks ``exists()`` and has its own fallback page.
-    """
-    html = index_path.read_text()
-    html = rewrite_asset_versions(html, ui_root or index_path.parent)
-    for placeholder, value in (substitutions or {}).items():
-        html = html.replace(placeholder, value)
-    return html

package/src/superlocalmemory/server/bandit_loops.py

@@ -1,158 +0,0 @@
-# Copyright (c) 2026 Varun Pratap Bhardwaj / Qualixar
-# Licensed under AGPL-3.0-or-later - see LICENSE file
-# Part of SuperLocalMemory v3.4.22 — LLD-03 §3.5 + §3.6
-
-"""Background schedulers for the v3.4.22 contextual bandit.
-
-Two asyncio tasks, both registered in the daemon lifespan:
-
-  1. Reward-proxy settler — every 60 s (``SLM_BANDIT_REWARD_WINDOW_SEC``),
-     calls ``reward_proxy.settle_stale_plays`` for the configured profile(s).
-  2. Retention sweep — every 24 h
-     (``SLM_BANDIT_PLAYS_RETENTION_INTERVAL_SEC``), calls
-     ``bandit.retention_sweep`` with the configured horizon
-     (``SLM_BANDIT_PLAYS_RETENTION_DAYS``, default 7).
-
-Both honour ``SLM_BANDIT_DISABLED=1`` (caller checks before scheduling).
-"""
-
-from __future__ import annotations
-
-import asyncio
-import logging
-import os
-from pathlib import Path
-from typing import Any
-
-from superlocalmemory.infra.data_root import state_path
-
-logger = logging.getLogger(__name__)
-
-_REWARD_INTERVAL = float(
-    os.environ.get("SLM_BANDIT_REWARD_WINDOW_SEC", "60"),
-)
-_RETENTION_INTERVAL = float(
-    os.environ.get("SLM_BANDIT_PLAYS_RETENTION_INTERVAL_SEC", "86400"),
-)
-_RETENTION_DAYS = int(
-    os.environ.get("SLM_BANDIT_PLAYS_RETENTION_DAYS", "7"),
-)
-
-
-def _learning_db(config: Any) -> Path:
-    if config is not None:
-        cand = getattr(config, "learning_db_path", None)
-        if cand is not None:
-            return Path(cand)
-    return state_path("learning.db")
-
-
-def _memory_db(config: Any) -> Path:
-    if config is not None:
-        cand = getattr(config, "db_path", None)
-        if cand is not None:
-            return Path(cand)
-    return state_path("memory.db")
-
-
-def _profile_id(config: Any) -> str:
-    if config is not None:
-        pid = getattr(config, "default_profile", None)
-        if isinstance(pid, str) and pid:
-            return pid
-    return "default"
-
-
-async def _reward_proxy_loop(
-    learning_db: Path, memory_db: Path, profile_id: str,
-    interval_sec: float,
-) -> None:
-    """Run the proxy settler on a steady interval. Never raises."""
-    from superlocalmemory.learning.reward_from_outcomes import (
-        settle_from_outcomes,
-    )
-    from superlocalmemory.learning.reward_proxy import settle_stale_plays
-
-    while True:
-        try:
-            await asyncio.sleep(interval_sec)
-            # Reported outcomes FIRST. The proxy defaults a play once its
-            # window closes; if it ran first it would claim every play and a
-            # real outcome arriving later would find nothing to settle.
-            real = await asyncio.to_thread(
-                settle_from_outcomes,
-                profile_id, learning_db, memory_db,
-            )
-            # The settler is synchronous + fast; run in a thread to avoid
-            # blocking the event loop on unusual DB lock stalls.
-            n = await asyncio.to_thread(
-                settle_stale_plays,
-                profile_id, learning_db, memory_db,
-            )
-            # INFO, not DEBUG, when a real outcome moved an arm: this is the
-            # only line that distinguishes a learning loop that is running
-            # from one that merely starts. Its absence for a month is what
-            # made this defect invisible.
-            if real:
-                logger.info("bandit settled %d play(s) from outcomes", real)
-            if n:
-                logger.debug("bandit.reward_proxy settled=%d (default)", n)
-        except asyncio.CancelledError:  # pragma: no cover — lifecycle
-            raise
-        except Exception as exc:  # pragma: no cover — defensive
-            logger.warning("bandit.reward_proxy loop: %s", exc)
-
-
-async def _retention_loop(
-    learning_db: Path, interval_sec: float, retention_days: int,
-) -> None:
-    """Run retention_sweep on a 24h cadence. Never raises."""
-    from superlocalmemory.learning.bandit import retention_sweep
-
-    while True:
-        try:
-            await asyncio.sleep(interval_sec)
-            deleted = await asyncio.to_thread(
-                retention_sweep, learning_db, retention_days,
-            )
-            logger.info(
-                "bandit_plays_retention_sweep tick: deleted=%d", deleted,
-            )
-        except asyncio.CancelledError:  # pragma: no cover — lifecycle
-            raise
-        except Exception as exc:  # pragma: no cover — defensive
-            logger.warning("bandit.retention loop: %s", exc)
-
-
-def schedule_bandit_loops(application: Any, config: Any) -> None:
-    """Register both background tasks with the FastAPI app state.
-
-    Tasks are stored on ``application.state.bandit_tasks`` so the daemon's
-    shutdown path can cancel them cleanly (if added).
-    """
-    learning = _learning_db(config)
-    memory = _memory_db(config)
-    profile = _profile_id(config)
-
-    try:
-        loop = asyncio.get_event_loop()
-    except RuntimeError:  # pragma: no cover — defensive
-        return
-
-    tasks = []
-    tasks.append(loop.create_task(
-        _reward_proxy_loop(learning, memory, profile, _REWARD_INTERVAL),
-    ))
-    tasks.append(loop.create_task(
-        _retention_loop(learning, _RETENTION_INTERVAL, _RETENTION_DAYS),
-    ))
-    if hasattr(application, "state"):
-        application.state.bandit_tasks = tasks
-    logger.info(
-        "bandit loops scheduled: reward=%.0fs, retention=%.0fs, "
-        "retention_days=%d",
-        _REWARD_INTERVAL, _RETENTION_INTERVAL, _RETENTION_DAYS,
-    )
-
-
-__all__ = ("schedule_bandit_loops",)