@ngocsangairvds/vsaf 3.2.16 → 4.0.1

package/tools/vds-scripts/memory_orchestrator/src/vds_memory_orchestrator/service/services/ai_memory_service.py

@@ -1,2754 +0,0 @@
-"""VDS AI Memory Service with session analytics and automation helpers."""
-
-import asyncio
-import contextlib
-import inspect
-import json
-import logging
-import time
-from collections import Counter
-from datetime import UTC, datetime, timedelta
-from typing import Any
-from uuid import uuid4
-
-from sqlalchemy import text
-
-from vds_memory_orchestrator.service.services.mem0_sync_service import (
-    Mem0SyncService,
-)
-from vds_memory_orchestrator.service.services.memory_admin_service import MemoryAdminService
-from vds_memory_orchestrator.service.services.memory_crud_service import MemoryCRUDService
-from vds_memory_orchestrator.service.services.memory_search_service import MemorySearchService
-
-try:
-    from vds_memory_orchestrator.agents import agents_enabled
-    from vds_memory_orchestrator.agents.extraction import ExtractedKeyPoints, make_extraction_agent
-
-    _AGENTS_IMPORTABLE = True
-except ImportError:
-    _AGENTS_IMPORTABLE = False
-
-
-from vds_memory_orchestrator.service.core.ai_memory_exceptions import (
-    NotFoundError,
-    ServiceUnavailableError,
-    SessionError,
-    ValidationError,
-)
-from vds_memory_orchestrator.service.core.config import (
-    REDIS_ANALYTICS_DB,
-    REDIS_SESSION_STORE_DB,
-    get_config,
-)
-from vds_memory_orchestrator.service.database.postgres_manager import database_service
-from vds_memory_orchestrator.service.database.redis_manager import get_redis_service, redis_manager
-from vds_memory_orchestrator.service.integrations.memory_transformer import (
-    DataModelTransformer,
-    MCPUserPreferences,
-)
-from vds_memory_orchestrator.service.models.ai_memory_models import (
-    Analytics,
-    BusinessDomain,
-    ConsolidationResponse,
-    Memory,
-    MemoryCreateRequest,
-    MemorySearchRequest,
-    MemorySearchResponse,
-    Operation,
-    OperationType,
-    Session,
-    SessionBackupRequest,
-    SessionBackupResponse,
-    SessionBackupSummary,
-    SessionBehaviorAnalytics,
-    SessionBehaviorEvent,
-    SessionConsolidationRequest,
-    SessionContextRequest,
-    SessionContextResponse,
-    SessionContextSummary,
-    SessionCreateRequest,
-    SessionCreateResponse,
-    SessionPerformanceMetrics,
-    SessionPerformanceSummary,
-    SessionRestoreRequest,
-    SessionRestoreResponse,
-    SessionShareAccessLevel,
-    SessionShareListEntry,
-    SessionShareRequest,
-    SessionShareResponse,
-    SessionStatus,
-    SessionTemplateInstantiateRequest,
-    SessionTemplateMetadata,
-    SessionUpdateRequest,
-    TeamInsightRequest,
-    TeamInsightResponse,
-    TeamMemoryShare,
-    TeamMemorySynthesisRequest,
-    TeamMemorySynthesisResponse,
-    ToolType,
-    TopicClusteringRequest,
-    TopicClusteringResponse,
-)
-from vds_memory_orchestrator.service.services.embedding_service import embedding_service
-from vds_memory_orchestrator.service.services.memory_evolution import memory_evolution_tracker
-from vds_memory_orchestrator.service.services.session_template_service import (
-    session_template_service,
-)
-from vds_memory_orchestrator.service.services.storage_strategy import StorageStrategyEngine
-
-logger = logging.getLogger(__name__)
-
-# Constants for magic values
-SECONDS_PER_HOUR = 3600
-MINUTES_PER_HOUR = 60
-MS_PER_SECOND = 1000
-TWO_HOURS_SECONDS = 7200
-DEFAULT_SESSION_BACKUP_TTL_HOURS = 7 * 24
-SESSION_BACKUP_TTL_SECONDS = DEFAULT_SESSION_BACKUP_TTL_HOURS * SECONDS_PER_HOUR
-MAX_SESSION_BACKUP_HISTORY = 20
-SESSION_SHARE_TTL_SECONDS = SECONDS_PER_HOUR * 24 * 90
-SESSION_BEHAVIOR_TIMELINE_LIMIT = 50
-
-# Thresholds for session and memory analysis
-HIGH_OPERATION_COUNT = 50
-HIGH_ACTIVITY_COUNT = 10
-MULTI_CATEGORY_THRESHOLD = 5
-HIGH_MEMORY_COUNT = 50
-LOW_MEMORY_COUNT = 5
-DIVERSE_CATEGORY_THRESHOLD = 5
-
-# Health check metrics are now tracked in Redis:
-# - metrics:cache:hits and metrics:cache:misses (cache hit rate)
-# - metrics:resp:count and metrics:resp:sum_ms (avg response time)
-# - Service startup time tracked in _startup_time attribute
-
-
-class VDSAIMemoryService:
-    """VDS AI Service combining Memory and Session management."""
-
-    def __init__(self) -> None:
-        self.config = get_config()
-        self._redis_service = None
-        self._mem0_sync: Mem0SyncService | None = None
-        self._mem0_client_backing = None  # holds client when _mem0_sync is None (pre-init / tests)
-        self._search_service: MemorySearchService | None = None
-        self._crud_service: MemoryCRUDService | None = None
-        self._admin_service: MemoryAdminService | None = None
-        self._storage_engine = None
-        self._embedding_service = embedding_service
-        self._background_tasks = set()
-        self._startup_time = None  # Track service startup time
-        self._memory_evolution_tracker = memory_evolution_tracker
-
-    @property
-    def _mem0_client(self):  # type: ignore[override]
-        """Property proxy: forwards to Mem0SyncService once initialized."""
-        if self._mem0_sync is not None:
-            return self._mem0_sync._mem0_client
-        return self._mem0_client_backing
-
-    @_mem0_client.setter
-    def _mem0_client(self, value) -> None:  # type: ignore[override]
-        if self._mem0_sync is not None:
-            self._mem0_sync._mem0_client = value
-        else:
-            self._mem0_client_backing = value
-
-    @property
-    def _mem0_http_clients(self):  # type: ignore[override]
-        """Property proxy for HTTP client pool (lives in Mem0SyncService)."""
-        if self._mem0_sync is not None:
-            return self._mem0_sync._mem0_http_clients
-        return None
-
-    async def initialize(self):
-        """Initialize the unified service."""
-        # Record startup time
-        if not self._startup_time:
-            self._startup_time = datetime.now(UTC)
-
-        await self._initialize_redis()
-
-        # Create and wire Mem0SyncService (leaf dependency)
-        self._mem0_sync = Mem0SyncService(self.config)
-        if self._mem0_client_backing is not None:
-            # Transfer any client set by tests before initialize() was called
-            self._mem0_sync._mem0_client = self._mem0_client_backing
-            self._mem0_client_backing = None
-        await self._mem0_sync.initialize()
-
-        # Wire MemorySearchService after Mem0Sync is ready.
-        # Use a closure for session_loader so that patch.object on the facade's
-        # get_session is picked up at call time (bound methods bypass instance-dict patching).
-        _facade = self
-        # Phase 223.C: wire semantic cache so that search_memories() probes and
-        # populates it — making hit/miss telemetry non-zero after operations.
-        from vds_memory_orchestrator.service.services.semantic_cache_service import (
-            get_semantic_cache_service as _get_sem_cache,
-        )
-        _semantic_cache = await _get_sem_cache()
-        self._search_service = MemorySearchService(
-            config=self.config,
-            mem0_sync=self._mem0_sync,
-            redis_service=self._redis_service,
-            session_loader=lambda sid: _facade.get_session(sid),
-            semantic_cache=_semantic_cache,
-        )
-
-        # Initialize storage strategy before wiring CRUD service so the engine
-        # reference is non-None when passed as a constructor argument.
-        await self._initialize_storage_strategy()
-
-        # Wire MemoryCRUDService with all collaborator deps.
-        _crud_facade = self
-        self._crud_service = MemoryCRUDService(
-            config=self.config,
-            mem0_sync=self._mem0_sync,
-            redis_service=self._redis_service,
-            session_loader=lambda sid: _crud_facade.get_session(sid),
-            session_updater=lambda req: _crud_facade.update_session(req),
-            emit_operation_fn=lambda **kw: _crud_facade._emit_operation(**kw),
-            storage_engine=self._storage_engine,
-            evolution_tracker=self._memory_evolution_tracker,
-        )
-        _crud_svc = self._crud_service
-        _admin_facade = self
-        self._admin_service = MemoryAdminService(
-            config=self.config,
-            mem0_sync=self._mem0_sync,
-            redis_service=self._redis_service,
-            resolve_mem0_from_event_fn=lambda e, m, meta: _crud_svc._resolve_mem0_id_from_event(
-                e, m, meta
-            ),
-            resolve_mem0_by_search_fn=lambda mid: _crud_svc._resolve_mem0_id_by_search(mid),
-            startup_time=self._startup_time,
-            get_background_task_count_fn=lambda: len(_admin_facade._background_tasks),
-        )
-        if self._memory_evolution_tracker:
-            try:
-                self._memory_evolution_tracker.reload()
-            except Exception as exc:
-                logger.debug("Memory evolution tracker reload failed: %s", exc)
-        service_env = getattr(self.config.service, "environment", "prod")
-        if service_env == "test":
-            logger.debug("Skipping auto background task start in test environment")
-        else:
-            await self._start_background_tasks()
-        logger.info("VDS AI Service initialized successfully")
-
-    async def _initialize_redis(self):
-        """Initialize Redis service."""
-        try:
-            self._redis_service = await get_redis_service()
-            logger.info("Redis service initialized")
-        except Exception as exc:  # pragma: no cover - defensive guardrail
-            logger.exception("Failed to initialize Redis service: %s", exc)
-            raise ServiceUnavailableError(f"Redis initialization failed: {exc}") from exc
-
-    async def _initialize_storage_strategy(self):
-        """Initialize storage strategy engine for tiered storage."""
-        try:
-            self._storage_engine = StorageStrategyEngine()
-            await self._storage_engine.initialize()
-            logger.info("Storage strategy engine initialized successfully")
-        except Exception as e:
-            logger.exception("Failed to initialize storage strategy engine: %s", e)
-            self._storage_engine = None
-
-    async def _start_background_tasks(self):
-        """Start background tasks for maintenance."""
-        # Start session cleanup task
-        cleanup_task = asyncio.create_task(self._session_cleanup_loop())
-        self._background_tasks.add(cleanup_task)
-
-        # Start analytics aggregation task
-        analytics_task = asyncio.create_task(self._analytics_aggregation_loop())
-        self._background_tasks.add(analytics_task)
-
-    def start_background_tasks(self):
-        """Public wrapper for tests/agents to kick off background loops."""
-        # Avoid duplicate starts
-        if self._background_tasks:
-            return
-        # In tests we want deterministic immediate population of the set
-        try:
-            cleanup_task = asyncio.create_task(self._session_cleanup_loop())
-            analytics_task = asyncio.create_task(self._analytics_aggregation_loop())
-            self._background_tasks.update({cleanup_task, analytics_task})
-        except RuntimeError:
-            # No running loop (rare in sync callers) – create a new one temporarily
-            loop = asyncio.new_event_loop()
-            asyncio.set_event_loop(loop)
-            cleanup_task = loop.create_task(self._session_cleanup_loop())
-            analytics_task = loop.create_task(self._analytics_aggregation_loop())
-            self._background_tasks.update({cleanup_task, analytics_task})
-
-    def stop_background_tasks(self):
-        """Cancel and clear background tasks (test helper)."""
-        for task in list(self._background_tasks):
-            task.cancel()
-        self._background_tasks.clear()
-
-    async def _session_cleanup_loop(self):
-        """Background task to clean up expired sessions."""
-        while True:
-            try:
-                await asyncio.sleep(self.config.service.session_cleanup_interval)
-                await self.cleanup_expired_sessions()
-            except Exception as e:
-                logger.exception("Error in session cleanup loop: %s", e)
-                await asyncio.sleep(60)  # Wait before retrying
-
-    async def _analytics_aggregation_loop(self):
-        """Background task to aggregate analytics data."""
-        while True:
-            try:
-                await asyncio.sleep(self.config.service.metrics_interval)
-                await self.aggregate_analytics()
-            except Exception as e:
-                logger.exception("Error in analytics aggregation loop: %s", e)
-                await asyncio.sleep(60)  # Wait before retrying
-
-    async def shutdown(self):
-        """Shutdown the service."""
-        # Cancel background tasks
-        for task in self._background_tasks:
-            task.cancel()
-            with contextlib.suppress(asyncio.CancelledError):
-                await task
-
-        # Close Redis connections
-        if self._redis_service:
-            await self._redis_service.close_all()
-
-        if self._embedding_service:
-            await self._embedding_service.aclose()
-
-        if self._mem0_sync:
-            await self._mem0_sync.close()
-
-        logger.info("VDS AI Service shutdown complete")
-
-    async def _mem0_call(self, method_name: str, **kwargs):
-        """Delegate to Mem0SyncService; pre-init fallback for tests bypassing initialize()."""
-        if self._mem0_sync is not None:
-            return await self._mem0_sync.mem0_call(method_name, **kwargs)
-        # Pre-init path: tests that set service._mem0_client before calling initialize()
-        client = self._mem0_client_backing
-        if not client:
-            raise ServiceUnavailableError("Mem0 client not initialized")
-        method = getattr(client, method_name, None)
-        if not method:
-            raise ServiceUnavailableError(f"Mem0 client missing method {method_name}")
-        result = method(**kwargs)
-        if inspect.isawaitable(result):
-            result = await result
-        return result
-
-    def get_mem0_circuit_breaker_state(self) -> dict[str, Any]:
-        """Expose Mem0 circuit breaker state for health checks."""
-        if self._mem0_sync is not None:
-            return self._mem0_sync.get_circuit_breaker_state()
-        return {
-            "state": "closed",
-            "failures": 0,
-            "failure_threshold": 0,
-            "reset_seconds": 0,
-            "last_failure_at": None,
-            "reset_at": None,
-            "remaining_seconds": 0.0,
-        }
-
-    async def _record_mem0_fallback_metrics(self, search_mode: str | None) -> None:
-        """Track fallback usage in Redis analytics."""
-        if not self._redis_service:
-            return
-        mode = (search_mode or "").lower()
-        with contextlib.suppress(Exception):
-            await self._redis_service.increment_metric("mem0_fallback_requests", 1)
-            if mode in {"pgvector", "bm25"}:
-                await self._redis_service.increment_metric(f"mem0_fallback_{mode}", 1)
-
-    # ------------------------------------------------------------------
-    # Lazy-init service accessors (reduces delegation stub boilerplate)
-    # ------------------------------------------------------------------
-
-    def _get_crud_svc(self) -> "MemoryCRUDService":
-        if self._crud_service is None:
-            self._crud_service = MemoryCRUDService(
-                config=self.config,
-                mem0_sync=self._mem0_sync,
-                redis_service=self._redis_service,
-                session_loader=lambda sid: self.get_session(sid),
-                session_updater=lambda req: self.update_session(req),
-                emit_operation_fn=lambda **kw: self._emit_operation(**kw),
-                storage_engine=self._storage_engine,
-                evolution_tracker=self._memory_evolution_tracker,
-            )
-        return self._crud_service
-
-    def _get_search_svc(self) -> "MemorySearchService":
-        if self._search_service is None:
-            self._search_service = MemorySearchService(
-                config=self.config,
-                mem0_sync=self._mem0_sync,
-                redis_service=self._redis_service,
-                session_loader=lambda sid: self.get_session(sid),
-            )
-        return self._search_service
-
-    def _get_admin_svc(self) -> "MemoryAdminService":
-        if self._admin_service is None:
-            crud = self._get_crud_svc()
-            self._admin_service = MemoryAdminService(
-                config=self.config,
-                mem0_sync=self._mem0_sync,
-                redis_service=self._redis_service,
-                resolve_mem0_from_event_fn=lambda e, m, meta: crud._resolve_mem0_id_from_event(
-                    e, m, meta
-                ),
-                resolve_mem0_by_search_fn=lambda mid: crud._resolve_mem0_id_by_search(mid),
-                startup_time=self._startup_time,
-                get_background_task_count_fn=lambda: len(self._background_tasks),
-            )
-        return self._admin_service
-
-    def _derive_org_id(self, *args, **kwargs):
-        """Delegates to MemoryCRUDService."""
-        return self._get_crud_svc()._derive_org_id(*args, **kwargs)
-
-    async def _invalidate_semantic_cache(self, *args, **kwargs):
-        """Delegates to MemoryCRUDService."""
-        return await self._get_crud_svc()._invalidate_semantic_cache(*args, **kwargs)
-
-    def _should_create_index_memory(self, *args, **kwargs):
-        """Delegates to MemoryCRUDService."""
-        return self._get_crud_svc()._should_create_index_memory(*args, **kwargs)
-
-    def _build_index_memory_content(self, *args, **kwargs):
-        """Delegates to MemoryCRUDService."""
-        return self._get_crud_svc()._build_index_memory_content(*args, **kwargs)
-
-    async def _create_index_memory(self, *args, **kwargs):
-        """Delegates to MemoryCRUDService."""
-        return await self._get_crud_svc()._create_index_memory(*args, **kwargs)
-
-    async def _resolve_mem0_id_from_event(self, *args, **kwargs):
-        """Delegates to MemoryCRUDService."""
-        return await self._get_crud_svc()._resolve_mem0_id_from_event(*args, **kwargs)
-
-    async def _resolve_mem0_id_by_search(self, *args, **kwargs):
-        """Delegates to MemoryCRUDService."""
-        return await self._get_crud_svc()._resolve_mem0_id_by_search(*args, **kwargs)
-
-    async def _record_evolution_event(self, *args, **kwargs):
-        """Delegates to MemoryCRUDService."""
-        return await self._get_crud_svc()._record_evolution_event(*args, **kwargs)
-
-    async def create_session(self, request: SessionCreateRequest) -> SessionCreateResponse:
-        """Create a new session."""
-        try:
-            # Generate session ID
-            now = datetime.now(UTC)
-            if not request.user_id or not str(request.user_id).strip():
-                raise ValidationError("user_id must not be empty")
-
-            session_id = f"session-{request.user_id}-{int(now.timestamp())}"
-            expires_at = now + timedelta(hours=request.ttl_hours)
-
-            # Handle project_domain conversion (support both string and enum)
-            project_domain = request.project_domain
-            if isinstance(project_domain, str):
-                project_domain = BusinessDomain(project_domain.upper())
-
-            # Get string representation for logging/memory
-            project_domain_str = (
-                project_domain.value if hasattr(project_domain, "value") else str(project_domain)
-            )
-
-            context_metadata = dict(request.metadata or {})
-            if request.context and "session_context" not in context_metadata:
-                context_metadata["session_context"] = request.context
-            if request.template_id:
-                context_metadata.setdefault("template_id", request.template_id)
-            if request.template_name:
-                context_metadata.setdefault("template_name", request.template_name)
-
-            session_data = Session(
-                session_id=session_id,
-                user_id=request.user_id,
-                project_domain=project_domain,
-                working_directory=request.working_directory,
-                git_branch=request.git_branch,
-                git_repository=request.git_repository,
-                environment=request.environment,
-                session_context=request.context,
-                template_id=request.template_id,
-                template_name=request.template_name,
-                context_tags=request.context_tags,
-                key_tasks=request.key_tasks,
-                created_at=now,
-                last_accessed=now,
-                expires_at=expires_at,
-                preferences=request.preferences or {},
-                context_metadata=context_metadata,
-            )
-
-            session_data = self._apply_session_enrichment(session_data)
-
-            # Store in Redis
-            success = await self._redis_service.store_session(
-                session_id,
-                session_data.model_dump(),
-                ttl=request.ttl_hours * SECONDS_PER_HOUR,
-            )
-
-            if success:
-                # Create initial memory for session creation
-                session_memory = MemoryCreateRequest(
-                    content=f"Session created for {request.user_id} in {project_domain_str} project",
-                    category="session-summary",
-                    importance="medium",
-                    session_id=session_id,
-                    user_id=request.user_id,
-                    working_directory=request.working_directory,
-                    operation_type="create",  # Use valid enum value
-                    metadata={
-                        "project_domain": request.project_domain.value
-                        if hasattr(request.project_domain, "value")
-                        else str(request.project_domain),
-                        "session_type": "creation",
-                    },
-                )
-                await self.create_memory(session_memory)
-
-                logger.info("Session created successfully: %s", session_id)
-
-                await self._record_evolution_event(
-                    "session_created",
-                    session_id=session_id,
-                    user_id=request.user_id,
-                    org_id=self._derive_org_id(request.metadata, context_metadata),
-                    payload={
-                        "project_domain": project_domain_str,
-                        "template_id": request.template_id,
-                        "ttl_hours": request.ttl_hours,
-                    },
-                    metadata={
-                        "context_tags": request.context_tags,
-                        "shadow_reason": "stage0_observation",
-                    },
-                )
-                return SessionCreateResponse(
-                    success=True,
-                    session_id=session_id,
-                    user_id=request.user_id,
-                    project_domain=project_domain,
-                    status=SessionStatus.ACTIVE,
-                    created_at=now,
-                    message="Session created successfully",
-                    expires_at=expires_at,
-                )
-            msg = "Failed to store session in Redis"
-            raise SessionError(msg)
-
-        except ValidationError:
-            raise
-        except Exception as e:
-            logger.exception(f"Error creating session: {e}")
-            raise SessionError(str(e)) from e
-
-    async def get_session(self, session_id: str) -> Session | None:
-        """Get session data."""
-        try:
-            session_data = await self._redis_service.get_session(session_id)
-            if session_data:
-                # Normalize minimal required fields for tests/mocks
-                if "expires_at" not in session_data:
-                    now_norm = datetime.now(UTC)
-                    session_data = {
-                        **session_data,
-                        "created_at": session_data.get("created_at") or now_norm,
-                        "last_accessed": session_data.get("last_accessed") or now_norm,
-                        "expires_at": session_data.get("expires_at")
-                        or now_norm + timedelta(hours=1),
-                        "status": session_data.get("status") or SessionStatus.ACTIVE,
-                        "project_domain": session_data.get("project_domain")
-                        or BusinessDomain.GENERAL,
-                        "preferences": session_data.get("preferences") or MCPUserPreferences(),
-                        "total_operations": session_data.get("total_operations") or 0,
-                        "total_memories": session_data.get("total_memories") or 0,
-                    }
-                return Session(**session_data)
-            return None
-        except Exception as e:
-            logger.exception("Error getting session {session_id}: %s", e)
-            return None
-
-    async def update_session(self, request: SessionUpdateRequest) -> bool:
-        """Update session data."""
-        try:
-            if isinstance(request, dict):
-                updates_payload = request.get("updates")
-                if not updates_payload:
-                    updates_payload = {
-                        k: v
-                        for k, v in request.items()
-                        if k not in {"session_id", "extend_ttl", "ttl_hours"}
-                    }
-                request = SessionUpdateRequest(
-                    session_id=request.get("session_id"),
-                    updates=updates_payload,
-                    extend_ttl=request.get("extend_ttl"),
-                    ttl_hours=request.get("ttl_hours"),
-                )
-            # Get existing session
-            existing_session = await self.get_session(request.session_id)
-            if not existing_session:
-                return False
-
-            # Update session data
-            updates = request.updates.copy()
-            if "last_accessed" not in updates:
-                updates["last_accessed"] = datetime.now(UTC)
-
-            # Handle TTL extension
-            new_ttl_seconds = None
-            if request.extend_ttl:
-                if request.ttl_hours:
-                    new_ttl_seconds = request.ttl_hours * SECONDS_PER_HOUR
-                else:
-                    # Default extend by 2 hours (or current session TTL if available)
-                    new_ttl_seconds = TWO_HOURS_SECONDS  # Default extension
-
-            # Update in Redis
-            success = await self._redis_service.update_session(
-                request.session_id,
-                updates,
-                ttl=new_ttl_seconds,  # Pass the new TTL to redis_service
-            )
-
-            if success:
-                # Trigger cross-invalidation
-                await self._redis_service.cross_invalidate(request.session_id)
-                # Invalidate search cache for this session/user/org
-                with contextlib.suppress(Exception):
-                    await self._redis_service.invalidate_memory_prefix("search:")
-                logger.info("Session updated successfully: %s", request.session_id)
-
-            return success
-
-        except Exception as e:
-            logger.exception("Error updating session {request.session_id}: %s", e)
-            return False
-
-    async def delete_session(self, session_id: str) -> bool:
-        """Delete a session."""
-        try:
-            # Get session data for cleanup
-            session_data = await self.get_session(session_id)
-            if session_data:
-                # Create final memory for session closure
-                closure_memory = MemoryCreateRequest(
-                    content=f"Session closed for {session_data.user_id}. "
-                    f"Total operations: {session_data.total_operations}, "
-                    f"Total memories: {session_data.total_memories}",
-                    category="session-summary",
-                    importance="medium",
-                    session_id=session_id,
-                    user_id=session_data.user_id,
-                    operation_type="delete",
-                    metadata={
-                        "closure_reason": "user_initiated",
-                        "total_operations": session_data.total_operations,
-                        "total_memories": session_data.total_memories,
-                    },
-                )
-                await self.create_memory(closure_memory)
-
-            # Delete from Redis
-            success = await self._redis_service.delete_session(session_id)
-
-            if success:
-                logger.info("Session deleted successfully: %s", session_id)
-                with contextlib.suppress(Exception):
-                    await self._redis_service.cross_invalidate(session_id)
-                    await self._redis_service.invalidate_search_scope(
-                        org_id=self._derive_org_id(getattr(session_data, "context_metadata", None)),
-                        user_id=getattr(session_data, "user_id", None),
-                        session_id=session_id,
-                    )
-                await self._record_evolution_event(
-                    "session_closed",
-                    session_id=session_id,
-                    user_id=session_data.user_id if session_data else "unknown",
-                    org_id=self._derive_org_id(
-                        getattr(session_data, "context_metadata", None) if session_data else None
-                    ),
-                    payload={
-                        "total_operations": getattr(session_data, "total_operations", None),
-                        "total_memories": getattr(session_data, "total_memories", None),
-                    },
-                    metadata={"shadow_reason": "stage0_observation"},
-                )
-
-            return success
-
-        except Exception as e:
-            logger.exception("Error deleting session {session_id}: %s", e)
-            return False
-
-    async def get_user_sessions(self, user_id: str) -> list[str]:
-        """Get all session IDs for a user."""
-        try:
-            return await self._redis_service.get_user_sessions(user_id)
-        except Exception as e:
-            logger.exception("Error getting sessions for user {user_id}: %s", e)
-            return []
-
-    async def cleanup_expired_sessions(self) -> int:
-        """Clean up expired sessions."""
-        try:
-            return await self._redis_service.cleanup_expired_sessions()
-        except Exception as e:
-            logger.exception("Error cleaning up expired sessions: %s", e)
-            return 0
-
-    # Session Template Methods
-    def list_session_templates(self) -> list[SessionTemplateMetadata]:
-        """Return all available session templates."""
-        return session_template_service.list_templates()
-
-    def get_session_template(self, template_id: str) -> SessionTemplateMetadata:
-        """Load metadata for a specific session template."""
-        return session_template_service.get_template(template_id)
-
-    async def instantiate_session_template(
-        self,
-        template_id: str,
-        request: SessionTemplateInstantiateRequest,
-    ) -> SessionCreateResponse:
-        """Create a session using a reusable template definition."""
-        session_request = session_template_service.build_session_request(template_id, request)
-        return await self.create_session(session_request)
-
-    # Session Backup & Restore
-    async def backup_session(self, request: SessionBackupRequest) -> SessionBackupResponse:
-        """Persist a snapshot of a session for later recovery."""
-        session_data = await self.get_session(request.session_id)
-        if not session_data:
-            raise NotFoundError("Session", request.session_id)
-
-        session_payload = session_data.model_dump()
-        session_payload.setdefault("session_id", request.session_id)
-
-        memories_payload: list[dict[str, Any]] = []
-        if request.include_memories:
-            memories = await self._get_session_memories(request.session_id, request.memory_limit)
-            memories_payload = [mem.model_dump() for mem in memories]
-
-        operations_payload: list[dict[str, Any]] = []
-        if request.include_operations:
-            raw_events = await self._fetch_operation_events(request.session_id)
-            trimmed = raw_events[-request.operation_limit :]
-            for payload, score in trimmed:
-                try:
-                    if isinstance(payload, bytes):
-                        payload = payload.decode()
-                    event = json.loads(payload)
-                except Exception as exc:
-                    logger.debug(
-                        "Skipping corrupt operation event for %s: %s",
-                        request.session_id,
-                        exc,
-                    )
-                    continue
-
-                operations_payload.append(
-                    {
-                        "type": event.get("type", OperationType.CREATE.value),
-                        "status": event.get("status", "success"),
-                        "duration_ms": event.get("duration_ms"),
-                        "metadata": event.get("metadata", {}),
-                        "user_id": event.get("user_id", "system"),
-                        "tool_used": event.get("tool_used", ToolType.READ.value),
-                        "timestamp_ms": score,
-                        "error": event.get("error"),
-                    }
-                )
-
-        created_at = datetime.now(UTC)
-        retention_hours = request.retention_hours or DEFAULT_SESSION_BACKUP_TTL_HOURS
-        ttl_seconds = int(retention_hours * SECONDS_PER_HOUR)
-        expires_at = created_at + timedelta(seconds=ttl_seconds)
-        backup_id = f"session-backup-{uuid4().hex}"
-
-        backup_payload = {
-            "backup_id": backup_id,
-            "session_id": request.session_id,
-            "created_at": created_at.isoformat(),
-            "expires_at": expires_at.isoformat(),
-            "notes": request.notes,
-            "include_memories": request.include_memories,
-            "include_operations": request.include_operations,
-            "session_data": session_payload,
-            "memories": memories_payload,
-            "operations": operations_payload,
-        }
-
-        serialized_payload = json.dumps(backup_payload, default=str)
-        size_bytes = len(serialized_payload.encode("utf-8"))
-
-        async with redis_manager.get_redis(REDIS_SESSION_STORE_DB) as conn:
-            backup_key = f"session:backup:{backup_id}"
-            await conn.setex(backup_key, ttl_seconds, serialized_payload)
-
-            history_key = f"session:{request.session_id}:backups"
-            await conn.zadd(history_key, {backup_id: created_at.timestamp()})
-            await conn.expire(history_key, ttl_seconds)
-            await conn.zremrangebyrank(history_key, 0, -(MAX_SESSION_BACKUP_HISTORY + 1))
-
-        return SessionBackupResponse(
-            backup_id=backup_id,
-            session_id=request.session_id,
-            created_at=created_at,
-            expires_at=expires_at,
-            include_memories=request.include_memories,
-            include_operations=request.include_operations,
-            size_bytes=size_bytes,
-        )
-
-    async def list_session_backups(
-        self, session_id: str, limit: int = 10
-    ) -> list[SessionBackupSummary]:
-        """List session backups sorted by recency."""
-        history_key = f"session:{session_id}:backups"
-        async with redis_manager.get_redis(REDIS_SESSION_STORE_DB) as conn:
-            entries = await conn.zrevrange(history_key, 0, limit - 1, withscores=True)
-
-        summaries: list[SessionBackupSummary] = []
-        for backup_id, _ in entries or []:
-            if isinstance(backup_id, bytes):
-                backup_id = backup_id.decode()
-            payload = await self._load_session_backup(backup_id)
-            if not payload:
-                continue
-            summaries.append(
-                SessionBackupSummary(
-                    backup_id=backup_id,
-                    session_id=payload.get("session_id", session_id),
-                    created_at=datetime.fromisoformat(payload["created_at"]),
-                    expires_at=datetime.fromisoformat(payload["expires_at"]),
-                    has_memories=bool(payload.get("memories")),
-                    has_operations=bool(payload.get("operations")),
-                    notes=payload.get("notes"),
-                )
-            )
-
-        return summaries
-
-    async def restore_session_from_backup(
-        self, request: SessionRestoreRequest
-    ) -> SessionRestoreResponse:
-        """Restore a session from a stored backup snapshot."""
-        backup_payload = await self._load_session_backup(request.backup_id)
-        if not backup_payload:
-            raise NotFoundError("SessionBackup", request.backup_id)
-
-        session_snapshot = backup_payload["session_data"].copy()
-        base_session_id = session_snapshot.get("session_id") or "session"
-
-        target_session_id = request.target_session_id or base_session_id
-        if request.restore_mode == "create" or not target_session_id:
-            target_session_id = f"{base_session_id}-restore-{uuid4().hex[:8]}"
-
-        session_snapshot["session_id"] = target_session_id
-        session_snapshot["last_accessed"] = datetime.now(UTC).isoformat()
-        session_snapshot.setdefault("metadata", {})
-        session_snapshot["metadata"].update(
-            {
-                "restored_from_backup": request.backup_id,
-                "restored_at": datetime.now(UTC).isoformat(),
-            }
-        )
-
-        ttl_hours = request.ttl_hours or (self.config.cache.session_ttl // SECONDS_PER_HOUR)
-        await self._redis_service.store_session(
-            target_session_id,
-            session_snapshot,
-            ttl=ttl_hours * SECONDS_PER_HOUR,
-        )
-
-        memories = backup_payload.get("memories", [])
-        if memories:
-            memory_ids: list[str] = []
-            for mem in memories:
-                mem_id = mem.get("memory_id") or f"{target_session_id}-mem-{uuid4().hex[:6]}"
-                mem["memory_id"] = mem_id
-                mem["session_id"] = target_session_id
-                memory_ids.append(mem_id)
-                await self._redis_service.set_json(
-                    f"memory:{mem_id}:payload",
-                    mem,
-                    ttl=self.config.cache.memory_ttl,
-                )
-
-            await self._redis_service.set_list(
-                f"session:{target_session_id}:memories:ids",
-                memory_ids,
-                ttl=self.config.cache.session_ttl,
-            )
-
-        operations = backup_payload.get("operations", [])
-        for op in operations:
-            await self._emit_operation(
-                session_id=target_session_id,
-                operation_type=op.get("type", OperationType.CREATE.value),
-                status=op.get("status", "success"),
-                duration_ms=int(op.get("duration_ms") or 0),
-                error=op.get("error"),
-                metadata=op.get("metadata"),
-                user_id=op.get("user_id"),
-                tool_used=op.get("tool_used"),
-                timestamp_ms=op.get("timestamp_ms"),
-            )
-
-        message = f"Session restored{' as new session' if request.restore_mode == 'create' else ''}"
-
-        return SessionRestoreResponse(
-            success=True,
-            restored_session_id=target_session_id,
-            backup_id=request.backup_id,
-            message=message,
-        )
-
-    async def _load_session_backup(self, backup_id: str) -> dict[str, Any] | None:
-        """Load a session backup payload from Redis."""
-        backup_key = f"session:backup:{backup_id}"
-        async with redis_manager.get_redis(REDIS_SESSION_STORE_DB) as conn:
-            raw = await conn.get(backup_key)
-            if not raw:
-                return None
-            if isinstance(raw, bytes):
-                raw = raw.decode()
-            return json.loads(raw)
-
-    # Session Sharing Methods
-    async def share_session(
-        self, session_id: str, request: SessionShareRequest
-    ) -> SessionShareResponse:
-        """Share a session with a user or team."""
-        session_data = await self.get_session(session_id)
-        if not session_data:
-            raise NotFoundError("Session", session_id)
-
-        now = datetime.now(UTC)
-        expires_at = request.expires_at or (now + timedelta(seconds=SESSION_SHARE_TTL_SECONDS))
-        ttl_seconds = max(60, int((expires_at - now).total_seconds()))
-
-        share_id = f"session-share-{uuid4().hex}"
-        payload = {
-            "share_id": share_id,
-            "session_id": session_id,
-            "target_user_id": request.target_user_id,
-            "target_team_id": request.target_team_id,
-            "access_level": request.access_level.value,
-            "granted_by": request.granted_by,
-            "granted_at": now.isoformat(),
-            "expires_at": expires_at.isoformat(),
-            "notes": request.notes,
-        }
-
-        async with redis_manager.get_redis(REDIS_SESSION_STORE_DB) as conn:
-            await conn.setex(f"session:share:{share_id}", ttl_seconds, json.dumps(payload))
-            await conn.zadd(
-                f"session:{session_id}:shares",
-                {share_id: now.timestamp()},
-            )
-
-            if request.target_user_id:
-                await conn.zadd(
-                    f"user:{request.target_user_id}:session_shares",
-                    {share_id: now.timestamp()},
-                )
-
-            if request.target_team_id:
-                await conn.zadd(
-                    f"team:{request.target_team_id}:session_shares",
-                    {share_id: now.timestamp()},
-                )
-
-        return SessionShareResponse(
-            share_id=share_id,
-            session_id=session_id,
-            access_level=request.access_level,
-            target_user_id=request.target_user_id,
-            target_team_id=request.target_team_id,
-            granted_by=request.granted_by,
-            granted_at=now,
-            expires_at=expires_at,
-            notes=request.notes,
-        )
-
-    async def revoke_session_share(self, session_id: str, share_id: str, revoked_by: str) -> bool:
-        """Revoke a previously granted session share."""
-        payload = await self._load_session_share_payload(share_id)
-        if not payload:
-            return False
-
-        async with redis_manager.get_redis(REDIS_SESSION_STORE_DB) as conn:
-            await conn.delete(f"session:share:{share_id}")
-            await conn.zrem(f"session:{session_id}:shares", share_id)
-
-            target_user = payload.get("target_user_id")
-            target_team = payload.get("target_team_id")
-            if target_user:
-                await conn.zrem(
-                    f"user:{target_user}:session_shares",
-                    share_id,
-                )
-            if target_team:
-                await conn.zrem(
-                    f"team:{target_team}:session_shares",
-                    share_id,
-                )
-
-        logger.info(
-            "Session share %s revoked by %s for session %s",
-            share_id,
-            revoked_by,
-            session_id,
-        )
-        return True
-
-    async def list_session_shares(self, session_id: str) -> list[SessionShareResponse]:
-        """List shares associated with a session."""
-        async with redis_manager.get_redis(REDIS_SESSION_STORE_DB) as conn:
-            share_ids = await conn.zrevrange(
-                f"session:{session_id}:shares", 0, -1, withscores=False
-            )
-
-        responses: list[SessionShareResponse] = []
-        for share_id in share_ids or []:
-            if isinstance(share_id, bytes):
-                share_id = share_id.decode()
-            payload = await self._load_session_share_payload(share_id)
-            if not payload:
-                continue
-            responses.append(self._map_session_share_payload(payload))
-
-        return responses
-
-    async def list_shared_sessions(
-        self, user_id: str, team_ids: list[str] | None = None
-    ) -> list[SessionShareListEntry]:
-        """List sessions shared with a user or their teams."""
-        team_ids = team_ids or []
-        share_ids: dict[str, float] = {}
-
-        async with redis_manager.get_redis(REDIS_SESSION_STORE_DB) as conn:
-            user_entries = await conn.zrevrange(
-                f"user:{user_id}:session_shares", 0, -1, withscores=True
-            )
-            for share_id, score in user_entries or []:
-                if isinstance(share_id, bytes):
-                    share_id = share_id.decode()
-                share_ids[share_id] = score
-
-            for team_id in team_ids:
-                team_entries = await conn.zrevrange(
-                    f"team:{team_id}:session_shares", 0, -1, withscores=True
-                )
-                for share_id, score in team_entries or []:
-                    if isinstance(share_id, bytes):
-                        share_id = share_id.decode()
-                    share_ids.setdefault(share_id, score)
-
-        entries: list[SessionShareListEntry] = []
-        for share_id in share_ids:
-            payload = await self._load_session_share_payload(share_id)
-            if not payload:
-                continue
-            session_id = payload.get("session_id")
-            session_obj = await self.get_session(session_id)
-            summary = None
-            if session_obj:
-                summary = session_obj.session_summary or session_obj.session_context
-            response = self._map_session_share_payload(payload)
-            entries.append(
-                SessionShareListEntry(
-                    **response.model_dump(),
-                    session_summary=summary,
-                )
-            )
-
-        return entries
-
-    async def _load_session_share_payload(self, share_id: str) -> dict[str, Any] | None:
-        """Load a session share payload from Redis."""
-        async with redis_manager.get_redis(REDIS_SESSION_STORE_DB) as conn:
-            raw = await conn.get(f"session:share:{share_id}")
-            if not raw:
-                return None
-            if isinstance(raw, bytes):
-                raw = raw.decode()
-            return json.loads(raw)
-
-    def _map_session_share_payload(self, payload: dict[str, Any]) -> SessionShareResponse:
-        """Convert raw share payload to response model."""
-        return SessionShareResponse(
-            share_id=payload["share_id"],
-            session_id=payload["session_id"],
-            access_level=SessionShareAccessLevel(payload["access_level"]),
-            target_user_id=payload.get("target_user_id"),
-            target_team_id=payload.get("target_team_id"),
-            granted_by=payload.get("granted_by"),
-            granted_at=datetime.fromisoformat(payload["granted_at"]),
-            expires_at=datetime.fromisoformat(payload["expires_at"])
-            if payload.get("expires_at")
-            else None,
-            notes=payload.get("notes"),
-        )
-
-    def _apply_session_enrichment(
-        self,
-        session_data: Session,
-        memories: list[Memory] | None = None,
-        operations: list[Operation] | None = None,
-    ) -> Session:
-        """Apply derived tags, tasks, and risk flags to a session model."""
-        tags = set(session_data.context_tags)
-        tags.update(self._derive_context_tags(session_data, memories, operations))
-
-        session_data.context_tags = sorted(tags)[:20]
-        session_data.key_tasks = self._derive_key_tasks(session_data, memories, operations)
-        session_data.risk_flags = self._derive_risk_flags(session_data, memories, operations)
-
-        enrichment_blob = {
-            "context_tags": session_data.context_tags,
-            "key_tasks": session_data.key_tasks,
-            "risk_flags": session_data.risk_flags,
-        }
-        session_data.context_metadata.setdefault("enrichment", {}).update(enrichment_blob)
-        return session_data
-
-    def _derive_context_tags(
-        self,
-        session_data: Session,
-        memories: list[Memory] | None,
-        operations: list[Operation] | None,
-    ) -> set[str]:
-        tags: set[str] = set()
-        tags.add(session_data.project_domain.value.lower())
-        tags.add(f"env:{session_data.environment.value}")
-        if session_data.working_directory:
-            parts = [p for p in session_data.working_directory.split("/") if p]
-            if parts:
-                tags.add(f"dir:{parts[-1].lower()}")
-        if session_data.git_branch:
-            tags.add(f"branch:{session_data.git_branch}")
-        if session_data.git_repository:
-            repo = session_data.git_repository.rsplit("/", 1)[-1]
-            tags.add(f"repo:{repo.replace('.git', '').lower()}")
-
-        metadata_tags = (
-            session_data.context_metadata.get("tags")
-            if isinstance(session_data.context_metadata, dict)
-            else []
-        )
-        if isinstance(metadata_tags, list):
-            tags.update(tag.lower() for tag in metadata_tags)
-
-        if memories:
-            for mem in memories:
-                cat = mem.category.value if hasattr(mem.category, "value") else str(mem.category)
-                tags.add(f"category:{cat.lower()}")
-        if operations:
-            for op in operations:
-                tags.add(f"tool:{op.tool_used.value.lower()}")
-
-        return tags
-
-    def _derive_key_tasks(
-        self,
-        session_data: Session,
-        memories: list[Memory] | None,
-        operations: list[Operation] | None,
-    ) -> list[str]:
-        tasks: list[str] = []
-        if session_data.current_task:
-            tasks.append(session_data.current_task)
-        metadata = session_data.context_metadata or {}
-        if isinstance(metadata, dict):
-            meta_tasks = metadata.get("current_tasks") or metadata.get("tasks")
-            if isinstance(meta_tasks, list):
-                tasks.extend(str(t) for t in meta_tasks)
-
-        for source in memories or []:
-            task = (source.metadata or {}).get("task") if source.metadata else None
-            if task:
-                tasks.append(str(task))
-
-        for op in operations or []:
-            task = op.operation_parameters.get("task") if op.operation_parameters else None
-            if task:
-                tasks.append(str(task))
-
-        dedup = []
-        seen = set()
-        for task in tasks:
-            normalized = task.strip()
-            if normalized and normalized not in seen:
-                dedup.append(normalized)
-                seen.add(normalized)
-            if len(dedup) >= 5:
-                break
-        return dedup
-
-    def _derive_risk_flags(
-        self,
-        session_data: Session,
-        memories: list[Memory] | None,
-        operations: list[Operation] | None,
-    ) -> list[str]:
-        flags: list[str] = []
-        now = datetime.now(UTC)
-        if session_data.error_count >= 3:
-            flags.append("high-error-volume")
-        ttl_remaining = (session_data.expires_at - now).total_seconds()
-        if ttl_remaining < 900:
-            flags.append("session-expiring-soon")
-        if operations:
-            failures = sum(1 for op in operations if op.status not in {"success", "ok"})
-            if failures:
-                flags.append("operation-failures")
-        if memories and len(memories) > 80:
-            flags.append("memory-sprawl")
-        idle_seconds = (now - session_data.last_accessed).total_seconds()
-        if idle_seconds > 3600 and (operations is None or len(operations) < 3):
-            flags.append("idle-session")
-        return flags
-
-    # Key-point extraction (agent-powered, structured output)
-
-    async def _extract_key_points_structured(
-        self, content: str, llm_config: Any | None = None
-    ) -> list[dict[str, Any]]:
-        """Extract structured key points from memory content.
-
-        Uses the extraction agent when agents are enabled; falls back to
-        returning the full content as a single key point.
-        """
-        config = llm_config
-        if _AGENTS_IMPORTABLE and config is not None and agents_enabled(config):
-            try:
-                agent = make_extraction_agent(config)
-                result = await agent.run(content)
-                extracted: ExtractedKeyPoints = result.output
-                return [
-                    {
-                        "text": kp.text,
-                        "importance": kp.importance,
-                        "category": kp.category,
-                    }
-                    for kp in extracted.key_points
-                ]
-            except Exception as exc:
-                logger.debug("Extraction agent failed, returning raw content: %s", exc)
-
-        return [{"text": content, "importance": "medium", "category": None}]
-
-    # Session Performance Monitoring
-    async def get_session_performance_metrics(
-        self, session_id: str, timeframe_hours: int = 24
-    ) -> SessionPerformanceMetrics:
-        cache_key = f"session:perf:{session_id}:{timeframe_hours}"
-        cached = await self._redis_service.get_json(cache_key)
-        if cached:
-            return SessionPerformanceMetrics(**cached)
-
-        now = datetime.now(UTC)
-        start_ts = (now - timedelta(hours=timeframe_hours)).timestamp() * 1000
-        raw_events = await self._fetch_operation_events(session_id)
-        durations: list[int] = []
-        success_count = 0
-        failure_count = 0
-        last_ts = None
-
-        for payload, score in raw_events:
-            if score < start_ts:
-                continue
-            if isinstance(payload, bytes):
-                payload = payload.decode()
-            event = json.loads(payload)
-            status = event.get("status", "unknown")
-            if status in {"success", "ok"}:
-                success_count += 1
-            else:
-                failure_count += 1
-            duration = event.get("duration_ms")
-            if isinstance(duration, (int, float)):
-                durations.append(int(duration))
-            last_ts = score
-
-        total_ops = success_count + failure_count
-        success_rate = success_count / total_ops if total_ops else 0.0
-        avg_duration = sum(durations) / len(durations) if durations else 0.0
-        p95 = self._calculate_percentile(durations, 95)
-        elapsed_minutes = max(1, timeframe_hours * 60)
-        throughput = total_ops / elapsed_minutes
-        last_operation_at = datetime.fromtimestamp(last_ts / 1000, UTC) if last_ts else None
-
-        metrics = SessionPerformanceMetrics(
-            session_id=session_id,
-            timeframe_hours=timeframe_hours,
-            total_operations=total_ops,
-            success_count=success_count,
-            failure_count=failure_count,
-            success_rate=round(success_rate, 3),
-            average_duration_ms=round(avg_duration, 2),
-            p95_duration_ms=round(p95, 2),
-            ops_per_minute=round(throughput, 3),
-            last_operation_at=last_operation_at,
-        )
-
-        await self._redis_service.set_json(
-            cache_key,
-            metrics.model_dump(mode="json"),
-            ttl=self.config.cache.session_ttl,
-        )
-        return metrics
-
-    async def get_session_performance_summary(
-        self, timeframe_hours: int = 24
-    ) -> SessionPerformanceSummary:
-        async with redis_manager.get_redis(REDIS_ANALYTICS_DB) as conn:
-            session_ids = await conn.smembers("ops:index")
-
-        summaries: list[SessionPerformanceMetrics] = []
-        for session_id in session_ids or []:
-            if isinstance(session_id, bytes):
-                session_id = session_id.decode()
-            metrics = await self.get_session_performance_metrics(session_id, timeframe_hours)
-            summaries.append(metrics)
-
-        sessions_evaluated = len(summaries)
-        total_ops = sum(m.total_operations for m in summaries)
-        avg_success = (
-            sum(m.success_rate for m in summaries) / sessions_evaluated
-            if sessions_evaluated
-            else 0.0
-        )
-        p95 = self._calculate_percentile(
-            [m.p95_duration_ms for m in summaries if m.p95_duration_ms], 95
-        )
-        busiest = max(summaries, key=lambda m: m.ops_per_minute, default=None)
-
-        return SessionPerformanceSummary(
-            timeframe_hours=timeframe_hours,
-            sessions_evaluated=sessions_evaluated,
-            total_operations=total_ops,
-            average_success_rate=round(avg_success, 3),
-            p95_duration_ms=round(p95, 2),
-            busiest_session_id=busiest.session_id if busiest else None,
-            peak_ops_per_minute=busiest.ops_per_minute if busiest else 0.0,
-        )
-
-    def _calculate_percentile(self, values: list[int], percentile: int) -> float:
-        if not values:
-            return 0.0
-        sorted_values = sorted(values)
-        k = (len(sorted_values) - 1) * (percentile / 100)
-        f = int(k)
-        c = min(f + 1, len(sorted_values) - 1)
-        if f == c:
-            return float(sorted_values[int(k)])
-        d0 = sorted_values[f] * (c - k)
-        d1 = sorted_values[c] * (k - f)
-        return float(d0 + d1)
-
-    # Memory Management Methods
-    async def create_memory(self, *args, **kwargs):
-        """Delegates to MemoryCRUDService."""
-        return await self._get_crud_svc().create_memory(*args, **kwargs)
-
-    async def find_by_user_session_category(
-        self,
-        user_id: str,
-        session_id: str,
-        category: str,
-    ) -> "Memory | None":
-        """ADR-59 Phase 199: Return first memory matching (user_id, session_id, category).
-
-        Used by the session-persist hook for idempotency checking (OPS-2).
-        Prevents the per-session debris pattern: multiple POSTs for the same
-        session_id produce only ONE memory record.
-
-        Returns the Memory if found, None otherwise.
-        """
-        query = text(
-            """
-            SELECT * FROM memories
-            WHERE user_id = :user_id
-              AND session_id = :session_id
-              AND category = :category
-            LIMIT 1
-            """
-        )
-        try:
-            async with database_service.postgres.engine.connect() as conn:
-                result = await conn.execute(
-                    query,
-                    {"user_id": user_id, "session_id": session_id, "category": category},
-                )
-                row = result.mappings().first()
-                if not row:
-                    return None
-                return database_service._map_row_to_memory(row)
-        except Exception as exc:
-            logger.warning("find_by_user_session_category failed: %s", exc)
-            return None
-
-    async def _enqueue_mem0_push(self, *args, **kwargs):
-        """Delegates to MemoryCRUDService."""
-        return await self._get_crud_svc()._enqueue_mem0_push(*args, **kwargs)
-
-    async def search_memories(
-        self, request: MemorySearchRequest, include_internal: bool = False
-    ) -> MemorySearchResponse:
-        """Search memories."""
-        return await self._get_search_svc().search_memories(request, include_internal)
-
-    async def cluster_memory_topics(
-        self, request: TopicClusteringRequest
-    ) -> TopicClusteringResponse:
-        """Cluster memories into topic groups using embeddings."""
-        return await self._get_search_svc().cluster_memory_topics(request)
-
-    # Session Context Methods
-    async def get_session_context(self, request: SessionContextRequest) -> SessionContextResponse:
-        """Get comprehensive session context."""
-        try:
-            # Get session data
-            session_data = await self.get_session(request.session_id)
-            if not session_data:
-                raise NotFoundError("Session", request.session_id)
-
-            # Get session memories
-            memories = []
-            if request.include_memories:
-                memories = await self._get_session_memories(
-                    request.session_id, request.memory_limit
-                )
-
-            # Get session operations
-            operations = []
-            if request.include_operations:
-                operations = await self._get_session_operations(
-                    request.session_id, request.operation_limit
-                )
-
-            # Get analytics if requested
-            analytics = None
-            behavior = None
-            if request.include_analytics:
-                analytics_raw = await self._get_session_analytics(request.session_id)
-                analytics = self._ensure_session_analytics(session_data, analytics_raw)
-                behavior = await self.get_session_behavior_metrics(request.session_id)
-
-            # Generate suggested actions and patterns
-            suggested_actions = self._generate_suggested_actions(session_data, memories, operations)
-            patterns = self._detect_session_patterns(session_data, memories, operations)
-
-            session_data = self._apply_session_enrichment(session_data, memories, operations)
-
-            with contextlib.suppress(Exception):
-                await self._redis_service.update_session(
-                    request.session_id,
-                    {
-                        "context_tags": session_data.context_tags,
-                        "key_tasks": session_data.key_tasks,
-                        "risk_flags": session_data.risk_flags,
-                        "context_metadata": session_data.context_metadata,
-                    },
-                )
-
-            summary = SessionContextSummary(
-                total_memories=session_data.total_memories,
-                total_operations=session_data.total_operations,
-            )
-
-            response = SessionContextResponse(
-                session_id=request.session_id,
-                session_data=session_data,
-                summary=summary,
-                memories=memories,
-                operations=operations,
-                analytics=analytics,
-                behavior=behavior,
-                suggested_actions=suggested_actions,
-                patterns=patterns,
-            )
-
-            logger.info("Session context retrieved: %s", request.session_id)
-            return response
-
-        except NotFoundError:
-            logger.info("Session context not found: %s", request.session_id)
-            raise
-        except Exception as e:
-            logger.exception(f"Error getting session context for {request.session_id}: {e}")
-            raise
-
-    async def _get_session_memories(self, session_id: str, limit: int = 20) -> list[Memory]:
-        """Get memories for a session with Redis caching + Mem0 fallback."""
-        return await self._get_search_svc()._get_session_memories(session_id, limit)
-
-    # Test-friendly hook stubs
-    async def _calculate_user_analytics(self, _user_id: str | None, _start, _end):
-        return {}
-
-    async def _calculate_system_analytics(self, _start, _end):
-        return {}
-
-    async def _analyze_usage_patterns(self, *_args, **_kwargs):
-        return {}
-
-    async def _generate_session_summary(self, _session_id: str):
-        return ""
-
-    async def _generate_session_insights(self, _session_id: str):
-        return []
-
-    async def _calculate_consolidation_metrics(self, _session_id: str):
-        return {}
-
-    async def _emit_operation(
-        self,
-        session_id: str,
-        operation_type: str,
-        status: str,
-        duration_ms: int,
-        error: str | None = None,
-        metadata: dict | None = None,
-        user_id: str | None = None,
-        tool_used: ToolType | str | None = None,
-        timestamp_ms: float | None = None,
-    ):
-        """Emit operation event to Redis for tracking."""
-        try:
-            timestamp = (
-                timestamp_ms if timestamp_ms is not None else datetime.now(UTC).timestamp() * 1000
-            )
-
-            if isinstance(tool_used, ToolType):
-                resolved_tool = tool_used
-            elif isinstance(tool_used, str) and tool_used:
-                try:
-                    resolved_tool = ToolType(tool_used)
-                except ValueError:
-                    resolved_tool = ToolType.WRITE
-            else:
-                resolved_tool = ToolType.WRITE
-
-            event = {
-                "type": operation_type,
-                "status": status,
-                "duration_ms": duration_ms,
-                "timestamp": timestamp,
-                "error": error,
-                "metadata": metadata or {},
-                "user_id": user_id or "system",
-                "tool_used": resolved_tool.value,
-            }
-
-            # Store in session-specific sorted set (score = timestamp)
-            ops_key = f"ops:{session_id}"
-            event_json = json.dumps(event)
-
-            # Use Redis analytics DB
-            async with redis_manager.get_redis(REDIS_ANALYTICS_DB) as conn:
-                await conn.zadd(ops_key, {event_json: timestamp})
-                await conn.sadd("ops:index", session_id)
-                await conn.expire(ops_key, 86400 * 7)  # 7 days
-
-            logger.debug(f"Operation emitted: {operation_type} for session {session_id}")
-
-        except Exception as e:
-            logger.exception(f"Error emitting operation: {e}")
-
-    async def _get_session_operations(
-        self,
-        session_id: str,
-        limit: int = 50,
-        from_ts: float | None = None,
-        to_ts: float | None = None,
-    ) -> list[Operation]:
-        """Get operations for a session from Redis."""
-        try:
-            ops_key = f"ops:{session_id}"
-
-            # Query sorted set by timestamp range
-            min_score = from_ts if from_ts else "-inf"
-            max_score = to_ts if to_ts else "+inf"
-
-            # Get operations with scores (timestamps)
-            async with redis_manager.get_redis(REDIS_ANALYTICS_DB) as conn:
-                results = await conn.zrangebyscore(
-                    ops_key, min_score, max_score, start=0, num=limit, withscores=True
-                )
-
-                operations = []
-                for event_data, score in results:
-                    try:
-                        # Decode if bytes
-                        if isinstance(event_data, bytes):
-                            event_data = event_data.decode()
-
-                        event = json.loads(event_data)
-                        event_timestamp = datetime.fromtimestamp(score / 1000, UTC)
-
-                        op_type_raw = event.get("type", OperationType.CREATE.value)
-                        try:
-                            op_type = OperationType(op_type_raw)
-                        except ValueError:
-                            op_type = OperationType.CREATE
-
-                        tool_raw = event.get("tool_used", ToolType.READ.value)
-                        try:
-                            tool_enum = ToolType(tool_raw)
-                        except ValueError:
-                            tool_enum = ToolType.READ
-
-                        operations.append(
-                            Operation(
-                                operation_id=f"op_{int(score)}",
-                                session_id=session_id,
-                                user_id=event.get("user_id", "system"),
-                                operation_type=op_type,
-                                tool_used=tool_enum,
-                                status=event.get("status", "unknown"),
-                                duration_ms=int(event.get("duration_ms", 0) or 0),
-                                error=event.get("error"),
-                                operation_parameters=event.get("metadata", {}),
-                                start_time=event_timestamp,
-                                end_time=event_timestamp,
-                            )
-                        )
-                    except Exception as e:
-                        logger.warning(f"Failed to parse operation event: {e}")
-                        continue
-
-            logger.info(f"Retrieved {len(operations)} operations for session {session_id}")
-            return operations
-
-        except Exception as e:
-            logger.exception(f"Error retrieving operations for {session_id}: {e}")
-            return []
-
-    async def _fetch_operation_events(self, session_id: str) -> list[tuple[str | bytes, float]]:
-        """Fetch raw operation events for deeper analytics."""
-        try:
-            ops_key = f"ops:{session_id}"
-            async with redis_manager.get_redis(REDIS_ANALYTICS_DB) as conn:
-                return await conn.zrange(ops_key, 0, -1, withscores=True)
-        except Exception as exc:
-            logger.warning("Failed to fetch raw operation events: %s", exc)
-            return []
-
-    async def get_session_behavior_metrics(
-        self,
-        session_id: str,
-        timeline_limit: int = SESSION_BEHAVIOR_TIMELINE_LIMIT,
-    ) -> SessionBehaviorAnalytics:
-        """Compute detailed analytics describing session behavior."""
-        session_data = await self.get_session(session_id)
-        if not session_data:
-            raise NotFoundError("Session", session_id)
-
-        raw_events = await self._fetch_operation_events(session_id)
-        total_operations = len(raw_events)
-
-        operations_by_type: Counter[str] = Counter()
-        tool_usage: Counter[str] = Counter()
-        success_count = 0
-        error_count = 0
-        durations: list[int] = []
-        timeline_buffer: list[SessionBehaviorEvent] = []
-        first_event_at: datetime | None = None
-        last_event_at: datetime | None = None
-
-        for payload, score in raw_events:
-            try:
-                if isinstance(payload, bytes):
-                    payload = payload.decode()
-                event = json.loads(payload)
-            except Exception as exc:
-                logger.warning("Failed to parse operation event for %s: %s", session_id, exc)
-                continue
-
-            timestamp = datetime.fromtimestamp(score / 1000, tz=UTC)
-            if not first_event_at:
-                first_event_at = timestamp
-            last_event_at = timestamp
-
-            op_type_raw = event.get("type", OperationType.CREATE.value)
-            tool_raw = event.get("tool_used", ToolType.READ.value)
-
-            try:
-                op_type = OperationType(op_type_raw)
-            except ValueError:
-                op_type = OperationType.CREATE
-
-            try:
-                tool_used = ToolType(tool_raw)
-            except ValueError:
-                tool_used = ToolType.READ
-
-            operations_by_type[op_type.value] += 1
-            tool_usage[tool_used.value] += 1
-
-            status = event.get("status", "unknown")
-            if status in {"success", "ok"}:
-                success_count += 1
-            else:
-                error_count += 1
-
-            duration_val = event.get("duration_ms")
-            normalized_duration = None
-            if isinstance(duration_val, (int, float)):
-                normalized_duration = int(duration_val)
-                durations.append(normalized_duration)
-
-            timeline_buffer.append(
-                SessionBehaviorEvent(
-                    timestamp=timestamp,
-                    operation_type=op_type,
-                    tool_used=tool_used,
-                    status=status,
-                    duration_ms=normalized_duration,
-                    metadata=event.get("metadata", {}),
-                )
-            )
-
-        # Keep only the most recent timeline events
-        if len(timeline_buffer) > timeline_limit:
-            timeline_buffer = timeline_buffer[-timeline_limit:]
-
-        success_rate = success_count / total_operations if total_operations else 0.0
-        avg_duration = sum(durations) / len(durations) if durations else 0.0
-
-        session_duration_minutes = max(
-            0.0,
-            (session_data.last_accessed - session_data.created_at).total_seconds() / 60,
-        )
-        active_minutes = (
-            max(0.0, (last_event_at - first_event_at).total_seconds() / 60)
-            if first_event_at and last_event_at
-            else 0.0
-        )
-        idle_minutes = max(session_duration_minutes - active_minutes, 0.0)
-
-        return SessionBehaviorAnalytics(
-            session_id=session_id,
-            user_id=session_data.user_id,
-            template_id=session_data.template_id,
-            total_operations=total_operations,
-            success_rate=round(success_rate, 3),
-            error_count=error_count,
-            duration_minutes=round(session_duration_minutes, 2),
-            active_minutes=round(active_minutes, 2),
-            idle_minutes=round(idle_minutes, 2),
-            operations_by_type=dict(operations_by_type),
-            tool_usage=dict(tool_usage),
-            average_operation_duration_ms=round(avg_duration, 2),
-            first_event_at=first_event_at,
-            last_event_at=last_event_at,
-            recent_activity=timeline_buffer,
-        )
-
-    def _ensure_session_analytics(
-        self, session_data: Session, analytics_obj: Analytics | dict | None
-    ) -> Analytics:
-        """Normalize analytics payload to a valid Analytics model."""
-        end_time = datetime.now(UTC)
-        start_time = end_time - timedelta(hours=24)
-
-        if isinstance(analytics_obj, Analytics):
-            return analytics_obj
-
-        if isinstance(analytics_obj, dict):
-            try:
-                return Analytics(**analytics_obj)
-            except Exception:
-                logger.debug("Analytics dict conversion failed; using defaults", exc_info=True)
-
-        total_memories = getattr(session_data, "total_memories", 0) or 0
-        total_operations = getattr(session_data, "total_operations", 0) or 0
-
-        return Analytics(
-            analytics_id=f"session_{session_data.session_id}",
-            user_id=getattr(session_data, "user_id", None),
-            timeframe_start=start_time,
-            timeframe_end=end_time,
-            total_sessions=1,
-            active_sessions=1,
-            total_memories=total_memories,
-            total_operations=total_operations,
-        )
-
-    async def _get_session_analytics(self, session_id: str) -> Analytics:
-        """Get analytics for a session from real Redis data."""
-        try:
-            # Get timeframe (last 24 hours)
-            end_time = datetime.now(UTC)
-            start_time = end_time - timedelta(hours=24)
-
-            # Get session data
-            session_data = await self.get_session(session_id)
-            if not session_data:
-                # Return empty analytics if session not found
-                return Analytics(
-                    analytics_id=f"session_{session_id}",
-                    user_id=None,
-                    timeframe_start=start_time,
-                    timeframe_end=end_time,
-                    total_sessions=0,
-                    active_sessions=0,
-                    total_memories=0,
-                    total_operations=0,
-                )
-
-            # Count memories for this session from Redis
-            total_memories = 0
-            try:
-                cache_key = f"session:{session_id}:memories:ids"
-                cached_ids = await self._redis_service.get_list(cache_key)
-                total_memories = len(cached_ids) if cached_ids else 0
-            except Exception as e:
-                logger.warning(f"Error counting memories for session {session_id}: {e}")
-
-            # Count operations for this session from Redis
-            total_operations = 0
-            try:
-                start_ts = start_time.timestamp() * 1000
-                end_ts = end_time.timestamp() * 1000
-                ops_key = f"ops:{session_id}"
-
-                async with redis_manager.get_redis(REDIS_ANALYTICS_DB) as conn:
-                    total_operations = await conn.zcount(ops_key, start_ts, end_ts)
-            except Exception as e:
-                logger.warning(f"Error counting operations for session {session_id}: {e}")
-
-            return Analytics(
-                analytics_id=f"session_{session_id}",
-                user_id=session_data.user_id,
-                timeframe_start=start_time,
-                timeframe_end=end_time,
-                total_sessions=1,
-                active_sessions=1,
-                total_memories=total_memories,
-                total_operations=total_operations,
-            )
-        except Exception as e:
-            logger.exception(f"Error getting session analytics: {e}")
-            # Return minimal analytics on error
-            return Analytics(
-                analytics_id=f"session_{session_id}",
-                user_id=None,
-                timeframe_start=datetime.now(UTC),
-                timeframe_end=datetime.now(UTC),
-                total_sessions=0,
-                active_sessions=0,
-                total_memories=0,
-                total_operations=0,
-            )
-
-    def _generate_suggested_actions(
-        self,
-        session_data: Session,
-        memories: list[Memory],
-        _operations: list[Operation],
-    ) -> list[str]:
-        """Generate AI-suggested actions based on session data."""
-        actions = []
-
-        # Based on session patterns
-        if session_data.total_operations > HIGH_OPERATION_COUNT:
-            actions.append("Consider consolidating this session to improve performance")
-
-        if session_data.total_memories > 20:
-            actions.append("Review and organize memories for better retrieval")
-
-        # Based on project domain
-        if session_data.project_domain == BusinessDomain.LENDING:
-            if "loan" not in str(memories).lower():
-                actions.append("Consider documenting loan-related decisions")
-        if session_data.project_domain == BusinessDomain.INSURANCE and "policy" not in str(memories).lower():
-                actions.append("Document insurance policy decisions and claims")
-
-        return actions
-
-    def _detect_session_patterns(
-        self,
-        session_data: Session,
-        memories: list[Memory],
-        _operations: list[Operation],
-    ) -> list[str]:
-        """Detect patterns in session usage."""
-        patterns = []
-
-        # Time-based patterns
-        duration = datetime.now(UTC) - session_data.created_at
-        if duration.total_seconds() > SECONDS_PER_HOUR:  # More than 1 hour
-            patterns.append("Long-running session")
-
-        # Activity patterns
-        if session_data.total_operations > HIGH_ACTIVITY_COUNT:
-            patterns.append("High activity session")
-
-        # Memory patterns
-        if memories:
-            categories = [
-                mem.category.value if hasattr(mem.category, "value") else str(mem.category)
-                for mem in memories
-            ]
-            if len(set(categories)) > MULTI_CATEGORY_THRESHOLD:
-                patterns.append("Multi-category exploration")
-
-        return patterns
-
-    # Session Consolidation Methods
-    async def consolidate_session(
-        self, request: SessionConsolidationRequest
-    ) -> ConsolidationResponse:
-        """Consolidate session memories."""
-        try:
-            start_time = datetime.now(UTC)
-            consolidation_id = (
-                f"consolidation-{request.session_id}-{int(time.time() * MS_PER_SECOND)}"
-            )
-            consolidation_type = getattr(request, "consolidation_type", None) or getattr(
-                request, "consolidation_strategy", "auto"
-            )
-            include_insights = getattr(
-                request, "include_insights", getattr(request, "generate_insights", True)
-            )
-
-            # Get session data and memories
-            session_data = await self.get_session(request.session_id)
-            if not session_data:
-                session_data = Session(
-                    session_id=request.session_id,
-                    user_id=request.user_id or "unknown",
-                    project_domain=BusinessDomain.GENERAL,
-                    status=SessionStatus.ACTIVE,
-                )
-
-            memories = await self._get_session_memories(request.session_id, 100)  # Get all memories
-
-            # Generate session summary (prefer injectable helper for tests)
-            session_summary = await self._generate_session_summary(request.session_id)
-            if not session_summary:
-                memory_contents = [mem.content for mem in memories]
-                session_summary = DataModelTransformer.create_session_summary_from_session(
-                    session_data, len(memories), memory_contents
-                )
-
-            metrics = await self._calculate_consolidation_metrics(request.session_id)
-
-            # Create consolidation memory
-            consolidation_memory = MemoryCreateRequest(
-                content=session_summary,
-                category="session-summary",
-                importance="high",
-                session_id=request.session_id,
-                user_id=request.user_id,
-                operation_type="execute",
-                metadata={
-                    "consolidation_type": consolidation_type,
-                    "total_memories": len(memories),
-                    "total_operations": session_data.total_operations,
-                    "consolidation_timestamp": datetime.now(UTC).isoformat(),
-                },
-            )
-
-            # Create the consolidation memory
-            memory_id = await self.create_memory(consolidation_memory)
-
-            # Generate insights if requested
-            insights = []
-            if include_insights:
-                # Prefer testable stubbed insights generator
-                insights = await self._generate_session_insights(request.session_id)
-                if not insights:
-                    insights = self._generate_consolidation_insights(session_data, memories)
-
-            processing_time = int((datetime.now(UTC) - start_time).total_seconds() * MS_PER_SECOND)
-
-            # Update session status
-            await self.update_session(
-                SessionUpdateRequest(
-                    session_id=request.session_id,
-                    updates={
-                        "session_summary": session_summary,
-                        "last_accessed": datetime.now(UTC),
-                    },
-                )
-            )
-
-            logger.info(f"Session consolidated: {request.session_id} ({len(memories)} memories)")
-
-            await self._record_evolution_event(
-                "session_consolidated",
-                session_id=request.session_id,
-                user_id=request.user_id,
-                org_id=self._derive_org_id(session_data.context_metadata),
-                memory_id=memory_id,
-                importance="high",
-                storage_tier=None,
-                payload={
-                    "total_memories": len(memories),
-                    "generate_insights": include_insights,
-                    "consolidation_type": consolidation_type,
-                },
-                metadata={
-                    "shadow_reason": "stage0_observation",
-                    "processing_time_ms": processing_time,
-                },
-            )
-
-            return ConsolidationResponse(
-                success=True,
-                session_id=request.session_id,
-                consolidation_id=consolidation_id,
-                consolidated_memory_id=memory_id,
-                summary=session_summary,
-                insights=insights,
-                metrics=metrics or {},
-                processing_time_ms=processing_time,
-            )
-
-        except Exception as e:
-            logger.exception("Error consolidating session {request.session_id}: %s", e)
-            return ConsolidationResponse(
-                success=False,
-                session_id=request.session_id,
-                consolidation_id=consolidation_id,
-                consolidated_memory_id=None,
-                summary=f"Failed to consolidate session: {e!s}",
-                insights=[],
-                metrics={},
-                processing_time_ms=0,
-            )
-
-    def _generate_consolidation_insights(
-        self, session_data: Session, memories: list[Memory]
-    ) -> list[str]:
-        """Generate insights from session consolidation."""
-        insights = []
-
-        # Session duration insight
-        duration = datetime.now(UTC) - session_data.created_at
-        if duration.total_seconds() > TWO_HOURS_SECONDS:  # More than 2 hours
-            insights.append(
-                "Session duration indicates high engagement - consider breaking into focused sessions"
-            )
-
-        # Memory count insight
-        if len(memories) > HIGH_MEMORY_COUNT:
-            insights.append(
-                f"High memory volume ({len(memories)} memories) - consider periodic summarization"
-            )
-        elif len(memories) < LOW_MEMORY_COUNT:
-            insights.append("Low memory count - consider documenting more decisions and context")
-
-        # Category distribution insight
-        if memories:
-            categories = [
-                mem.category.value if hasattr(mem.category, "value") else str(mem.category)
-                for mem in memories
-            ]
-            unique_categories = len(set(categories))
-            if unique_categories == 1:
-                insights.append(f"Focused session on {categories[0]} - good for specialized work")
-            elif unique_categories > DIVERSE_CATEGORY_THRESHOLD:
-                insights.append(
-                    "Diverse session covering multiple areas - consider organizing by project"
-                )
-
-        return insights
-
-    # Team Collaboration Methods
-
-    async def share_memory_with_team(self, request: TeamMemoryShare) -> bool:
-        """Share a memory with a team."""
-        try:
-            # Verify memory exists and user has permission to share
-            memory_data = await self._get_memory_by_id(request.memory_id, request.shared_by)
-            if not memory_data:
-                logger.error(f"Memory {request.memory_id} not found or access denied")
-                return False
-
-            # Store team share information in Redis
-            share_key = f"team_share:{request.team_id}:{request.memory_id}"
-            share_data = {
-                "memory_id": request.memory_id,
-                "team_id": request.team_id,
-                "access_level": request.access_level.value
-                if hasattr(request.access_level, "value")
-                else str(request.access_level),
-                "shared_by": request.shared_by,
-                "shared_at": request.shared_at.isoformat(),
-                "expires_at": request.expires_at.isoformat() if request.expires_at else None,
-                "permissions": request.permissions,
-            }
-
-            # Set with expiration if provided
-            ttl = None
-            if request.expires_at:
-                ttl = int((request.expires_at - datetime.now(UTC)).total_seconds())
-
-            await self._redis_service.set_json(share_key, share_data, ttl=ttl)
-
-            # Add to team's memory index
-            team_memories_key = f"team:{request.team_id}:shared_memories"
-            existing_memories = await self._redis_service.get_list(team_memories_key)
-            if request.memory_id not in existing_memories:
-                existing_memories.append(request.memory_id)
-                await self._redis_service.set_list(team_memories_key, existing_memories, ttl=ttl)
-
-            logger.info(f"Memory {request.memory_id} shared with team {request.team_id}")
-            return True
-
-        except Exception as e:
-            logger.exception(
-                f"Error sharing memory {request.memory_id} with team {request.team_id}: {e}"
-            )
-            return False
-
-    async def get_team_memories(self, team_id: str, user_id: str, limit: int = 50) -> list[Memory]:
-        """Get shared memories for a team."""
-        try:
-            # Get team's shared memory list
-            team_memories_key = f"team:{team_id}:shared_memories"
-            memory_ids = await self._redis_service.get_list(team_memories_key)
-
-            memories = []
-            for memory_id in memory_ids[:limit]:
-                # Check share permissions
-                share_key = f"team_share:{team_id}:{memory_id}"
-                share_data = await self._redis_service.get_json(share_key)
-
-                if share_data:
-                    # Get memory data
-                    memory_data = await self._get_memory_by_id(memory_id, user_id)
-                    if memory_data:
-                        # Add team context to memory
-                        memory_data.team_id = team_id
-                        memories.append(memory_data)
-
-            return memories
-
-        except Exception as e:
-            logger.exception(f"Error getting team memories for {team_id}: {e}")
-            return []
-
-    async def generate_team_insights(self, request: TeamInsightRequest) -> TeamInsightResponse:
-        """Generate AI-powered insights for a team."""
-        try:
-            start_time = datetime.now(UTC)
-
-            # Get team memories for analysis
-            team_memories = await self.get_team_memories(
-                request.team_id, request.user_id, limit=200
-            )
-
-            if not team_memories:
-                return TeamInsightResponse(
-                    team_id=request.team_id,
-                    insights={},
-                    summary="No team memories found for analysis",
-                    recommendations=["Start sharing memories with the team to enable insights"],
-                    collaboration_metrics={},
-                    knowledge_gaps=[],
-                    top_contributors=[],
-                    processing_time_ms=int((datetime.now(UTC) - start_time).total_seconds() * 1000),
-                )
-
-            # Analyze patterns and generate insights
-            insights = {}
-
-            # Pattern analysis
-            if "patterns" in request.insight_types:
-                insights["patterns"] = self._analyze_team_patterns(team_memories)
-
-            # Knowledge gaps analysis
-            if "knowledge_gaps" in request.insight_types:
-                insights["knowledge_gaps"] = self._identify_knowledge_gaps(team_memories)
-
-            # Collaboration analysis
-            if "collaboration" in request.insight_types:
-                insights["collaboration"] = self._analyze_collaboration_patterns(team_memories)
-
-            # Generate summary and recommendations
-            summary = self._generate_team_insight_summary(insights, team_memories)
-            recommendations = self._generate_team_recommendations(insights)
-
-            # Calculate metrics
-            collaboration_metrics = self._calculate_collaboration_metrics(team_memories)
-            knowledge_gaps = insights.get("knowledge_gaps", [])
-            top_contributors = self._identify_top_contributors(team_memories)
-
-            processing_time_ms = int((datetime.now(UTC) - start_time).total_seconds() * 1000)
-
-            return TeamInsightResponse(
-                team_id=request.team_id,
-                insights=insights,
-                summary=summary,
-                recommendations=recommendations,
-                collaboration_metrics=collaboration_metrics,
-                knowledge_gaps=knowledge_gaps,
-                top_contributors=top_contributors,
-                processing_time_ms=processing_time_ms,
-            )
-
-        except Exception as e:
-            logger.exception(f"Error generating team insights for {request.team_id}: {e}")
-            return TeamInsightResponse(
-                team_id=request.team_id,
-                insights={},
-                summary=f"Error generating insights: {str(e)}",
-                recommendations=["Please try again later"],
-                collaboration_metrics={},
-                knowledge_gaps=[],
-                top_contributors=[],
-                processing_time_ms=0,
-            )
-
-    async def synthesize_team_memories(
-        self, request: TeamMemorySynthesisRequest
-    ) -> TeamMemorySynthesisResponse:
-        """Synthesize team memories into comprehensive insights."""
-        try:
-            start_time = datetime.now(UTC)
-
-            # Get relevant memories
-            team_memories = await self.get_team_memories(
-                request.team_id, request.user_id, limit=request.max_memories
-            )
-
-            if not team_memories:
-                return TeamMemorySynthesisResponse(
-                    team_id=request.team_id,
-                    synthesis_type=request.synthesis_type,
-                    synthesis="No memories available for synthesis",
-                    key_points=[],
-                    action_items=[],
-                    related_memories=[],
-                    confidence_score=0.0,
-                    contributors=[],
-                    processing_time_ms=int((datetime.now(UTC) - start_time).total_seconds() * 1000),
-                )
-
-            # Prepare memory content for synthesis
-            memory_contents = [mem.content for mem in team_memories]
-            contributors = list({mem.user_id for mem in team_memories if mem.user_id})
-
-            # Perform synthesis based on type
-            if request.synthesis_type == "summary":
-                synthesis = self._create_memory_summary(memory_contents, team_memories)
-                key_points = self._extract_key_points(memory_contents)
-            elif request.synthesis_type == "analysis":
-                synthesis = self._analyze_memory_patterns(memory_contents, team_memories)
-                key_points = self._extract_analytical_points(team_memories)
-            else:  # insights
-                synthesis = self._generate_insights_synthesis(memory_contents, team_memories)
-                key_points = self._extract_insight_points(team_memories)
-
-            # Generate action items
-            action_items = self._generate_action_items(synthesis, team_memories)
-
-            # Get related memory IDs
-            related_memories = [mem.memory_id for mem in team_memories[:10]]
-
-            # Calculate confidence score
-            confidence_score = self._calculate_synthesis_confidence(memory_contents, team_memories)
-
-            processing_time_ms = int((datetime.now(UTC) - start_time).total_seconds() * 1000)
-
-            return TeamMemorySynthesisResponse(
-                team_id=request.team_id,
-                synthesis_type=request.synthesis_type,
-                synthesis=synthesis,
-                key_points=key_points,
-                action_items=action_items,
-                related_memories=related_memories,
-                confidence_score=confidence_score,
-                contributors=contributors,
-                processing_time_ms=processing_time_ms,
-            )
-
-        except Exception as e:
-            logger.exception(f"Error synthesizing team memories for {request.team_id}: {e}")
-            return TeamMemorySynthesisResponse(
-                team_id=request.team_id,
-                synthesis_type=request.synthesis_type,
-                synthesis=f"Error during synthesis: {str(e)}",
-                key_points=[],
-                action_items=[],
-                related_memories=[],
-                confidence_score=0.0,
-                contributors=[],
-                processing_time_ms=int((datetime.now(UTC) - start_time).total_seconds() * 1000),
-            )
-
-    # Helper methods for team collaboration
-    async def _get_memory_by_id(self, memory_id: str, user_id: str) -> Memory | None:
-        """Delegates to MemorySearchService."""
-        return await self._get_search_svc()._get_memory_by_id(memory_id, user_id)
-
-    def _analyze_team_patterns(self, memories: list[Memory]) -> dict[str, Any]:
-        """Analyze patterns in team memories."""
-        categories = {}
-        users = {}
-        time_patterns = {}
-
-        for mem in memories:
-            # Category distribution
-            cat = mem.category.value if hasattr(mem.category, "value") else str(mem.category)
-            categories[cat] = categories.get(cat, 0) + 1
-
-            # User contributions
-            if mem.user_id:
-                users[mem.user_id] = users.get(mem.user_id, 0) + 1
-
-            # Time patterns
-            if mem.created_at:
-                hour = mem.created_at.hour
-                time_patterns[hour] = time_patterns.get(hour, 0) + 1
-
-        return {
-            "category_distribution": categories,
-            "user_contributions": users,
-            "activity_patterns": time_patterns,
-            "total_memories": len(memories),
-        }
-
-    def _identify_knowledge_gaps(self, memories: list[Memory]) -> list[str]:
-        """Identify knowledge gaps based on team memories."""
-        # Simple heuristic: look for underrepresented categories
-        categories = set()
-        for mem in memories:
-            cat = mem.category.value if hasattr(mem.category, "value") else str(mem.category)
-            categories.add(cat)
-
-        all_categories = {
-            "technical",
-            "business",
-            "process",
-            "decision",
-            "learning",
-            "general",
-        }
-        missing_categories = all_categories - categories
-
-        gaps = []
-        if missing_categories:
-            gaps.extend(
-                [
-                    f"Consider documenting more {cat}-related information"
-                    for cat in missing_categories
-                ]
-            )
-
-        # Look for low activity areas
-        if len(memories) < 10:
-            gaps.append("Team knowledge base is still developing - encourage more documentation")
-
-        return gaps
-
-    def _analyze_collaboration_patterns(self, memories: list[Memory]) -> dict[str, Any]:
-        """Analyze collaboration patterns."""
-        user_interactions = {}
-        shared_memories = 0
-
-        for mem in memories:
-            if mem.team_id:
-                shared_memories += 1
-
-            if mem.user_id:
-                user_interactions[mem.user_id] = user_interactions.get(mem.user_id, 0) + 1
-
-        return {
-            "shared_memory_ratio": shared_memories / len(memories) if memories else 0,
-            "active_contributors": len(user_interactions),
-            "total_interactions": sum(user_interactions.values()),
-            "collaboration_score": min(1.0, shared_memories / max(1, len(memories))),
-        }
-
-    def _generate_team_insight_summary(
-        self, insights: dict[str, Any], memories: list[Memory]
-    ) -> str:
-        """Generate executive summary of team insights."""
-        total_memories = len(memories)
-        active_contributors = insights.get("collaboration", {}).get("active_contributors", 0)
-        collaboration_score = insights.get("collaboration", {}).get("collaboration_score", 0)
-
-        summary = f"Team has {total_memories} shared memories with {active_contributors} active contributors. "
-
-        if collaboration_score > 0.7:
-            summary += "Strong collaboration patterns detected. "
-        elif collaboration_score > 0.4:
-            summary += "Moderate collaboration levels. "
-        else:
-            summary += "Limited collaboration - encourage more knowledge sharing. "
-
-        top_category = max(
-            insights.get("patterns", {}).get("category_distribution", {}).items(),
-            key=lambda x: x[1],
-            default=(None, 0),
-        )[0]
-        if top_category:
-            summary += f"Primary focus area: {top_category}."
-
-        return summary
-
-    def _generate_team_recommendations(self, insights: dict[str, Any]) -> list[str]:
-        """Generate actionable recommendations for the team."""
-        recommendations = []
-
-        collaboration = insights.get("collaboration", {})
-        if collaboration.get("collaboration_score", 0) < 0.5:
-            recommendations.append(
-                "Increase knowledge sharing by documenting more team decisions and processes"
-            )
-
-        patterns = insights.get("patterns", {})
-        user_contributions = patterns.get("user_contributions", {})
-        if len(user_contributions) < 3:
-            recommendations.append(
-                "Encourage more team members to contribute to the knowledge base"
-            )
-
-        knowledge_gaps = insights.get("knowledge_gaps", [])
-        if knowledge_gaps:
-            recommendations.extend(knowledge_gaps[:2])
-
-        return recommendations[:5]  # Limit to 5 recommendations
-
-    def _calculate_collaboration_metrics(self, memories: list[Memory]) -> dict[str, float]:
-        """Calculate collaboration metrics."""
-        shared_memories = sum(1 for mem in memories if mem.team_id)
-        unique_users = len({mem.user_id for mem in memories if mem.user_id})
-
-        return {
-            "sharing_ratio": shared_memories / len(memories) if memories else 0,
-            "diversity_score": min(1.0, unique_users / max(1, len(memories))),
-            "engagement_level": unique_users / max(1, len(memories)),
-        }
-
-    def _identify_top_contributors(self, memories: list[Memory]) -> list[dict[str, Any]]:
-        """Identify top contributors to team knowledge."""
-        user_counts = {}
-        for mem in memories:
-            if mem.user_id:
-                user_counts[mem.user_id] = user_counts.get(mem.user_id, 0) + 1
-
-        # Sort by contribution count
-        sorted_contributors = sorted(user_counts.items(), key=lambda x: x[1], reverse=True)
-
-        return [
-            {"user_id": user_id, "contributions": count}
-            for user_id, count in sorted_contributors[:5]
-        ]
-
-    def _create_memory_summary(self, contents: list[str], _memories: list[Memory]) -> str:
-        """Create a summary of memory contents."""
-        if not contents:
-            return "No memories to summarize."
-
-        # Simple concatenation for now - can be enhanced with AI summarization
-        summary_parts = []
-        for _i, content in enumerate(contents[:5]):  # Limit to first 5
-            summary_parts.append(f"• {content[:100]}..." if len(content) > 100 else f"• {content}")
-
-        return "Key team memories:\n" + "\n".join(summary_parts)
-
-    def _extract_key_points(self, contents: list[str]) -> list[str]:
-        """Extract key points from memory contents."""
-        key_points = []
-        for content in contents[:10]:
-            # Simple heuristic: look for sentences with keywords
-            sentences = content.split(".")
-            for sentence in sentences[:2]:  # First 2 sentences per content
-                sentence = sentence.strip()
-                if len(sentence) > 20 and any(
-                    keyword in sentence.lower()
-                    for keyword in ["decision", "important", "key", "critical", "note"]
-                ):
-                    key_points.append(sentence)
-
-        return key_points[:10]  # Limit to 10 key points
-
-    def _analyze_memory_patterns(self, _contents: list[str], memories: list[Memory]) -> str:
-        """Analyze patterns in memory contents."""
-        analysis = []
-
-        # Category analysis
-        categories = {}
-        for mem in memories:
-            cat = mem.category.value if hasattr(mem.category, "value") else str(mem.category)
-            categories[cat] = categories.get(cat, 0) + 1
-
-        if categories:
-            top_category = max(categories.items(), key=lambda x: x[1])
-            analysis.append(f"Primary focus: {top_category[0]} ({top_category[1]} memories)")
-
-        # Time-based analysis
-        if memories:
-            recent_memories = sum(
-                1
-                for mem in memories
-                if mem.created_at and (datetime.now(UTC) - mem.created_at).days < 7
-            )
-            analysis.append(f"Recent activity: {recent_memories} memories in the last week")
-
-        return "\n".join(analysis) if analysis else "No significant patterns detected."
-
-    def _extract_analytical_points(self, memories: list[Memory]) -> list[str]:
-        """Extract analytical points from memories."""
-        points = []
-
-        # Look for high-importance memories
-        high_importance = [
-            mem
-            for mem in memories
-            if hasattr(mem, "importance") and str(mem.importance).lower() in ["high", "critical"]
-        ]
-
-        if high_importance:
-            points.append(f"{len(high_importance)} high-priority items identified")
-
-        # Look for recurring themes
-        contents = [mem.content.lower() for mem in memories]
-        common_words = {}
-        for content in contents:
-            words = content.split()
-            for word in words:
-                if len(word) > 5:  # Focus on meaningful words
-                    common_words[word] = common_words.get(word, 0) + 1
-
-        top_words = sorted(common_words.items(), key=lambda x: x[1], reverse=True)[:3]
-        if top_words:
-            points.append(f"Key themes: {', '.join([word for word, _ in top_words])}")
-
-        return points
-
-    def _generate_insights_synthesis(self, _contents: list[str], memories: list[Memory]) -> str:
-        """Generate insights synthesis."""
-        insights = []
-
-        # Team knowledge synthesis
-        total_contributors = len({mem.user_id for mem in memories if mem.user_id})
-        insights.append(f"Team knowledge built from {total_contributors} contributors")
-
-        # Knowledge scope analysis
-        categories = set()
-        for mem in memories:
-            cat = mem.category.value if hasattr(mem.category, "value") else str(mem.category)
-            categories.add(cat)
-
-        insights.append(
-            f"Knowledge spans {len(categories)} categories: {', '.join(list(categories)[:3])}"
-        )
-
-        # Activity level
-        if memories:
-            time_span = max(mem.created_at for mem in memories if mem.created_at) - min(
-                mem.created_at for mem in memories if mem.created_at
-            )
-            insights.append(f"Knowledge accumulated over {time_span.days} days")
-
-        return "\n".join(insights)
-
-    def _extract_insight_points(self, memories: list[Memory]) -> list[str]:
-        """Extract insight points from memories."""
-        points = []
-
-        # Collaboration insights
-        team_memories = sum(1 for mem in memories if mem.team_id)
-        if team_memories > 0:
-            points.append(f"{team_memories} memories shared with team")
-
-        # Knowledge diversity
-        categories = set()
-        for mem in memories:
-            cat = mem.category.value if hasattr(mem.category, "value") else str(mem.category)
-            categories.add(cat)
-        points.append(f"Knowledge diversity: {len(categories)} categories")
-
-        # Recent activity
-        recent = sum(
-            1
-            for mem in memories
-            if mem.created_at and (datetime.now(UTC) - mem.created_at).days < 7
-        )
-        points.append(f"Recent contributions: {recent} memories this week")
-
-        return points
-
-    def _generate_action_items(self, _synthesis: str, memories: list[Memory]) -> list[str]:
-        """Generate action items based on synthesis."""
-        action_items = []
-
-        # Based on memory volume
-        if len(memories) < 10:
-            action_items.append("Increase documentation frequency to build team knowledge base")
-
-        # Based on contributor diversity
-        contributors = len({mem.user_id for mem in memories if mem.user_id})
-        if contributors < 3:
-            action_items.append("Encourage more team members to share their knowledge")
-
-        # Based on recency
-        recent = sum(
-            1
-            for mem in memories
-            if mem.created_at and (datetime.now(UTC) - mem.created_at).days < 7
-        )
-        if recent < 2:
-            action_items.append("Schedule regular knowledge sharing sessions")
-
-        # Based on categories
-        categories = set()
-        for mem in memories:
-            cat = mem.category.value if hasattr(mem.category, "value") else str(mem.category)
-            categories.add(cat)
-
-        if len(categories) < 3:
-            action_items.append("Diversify knowledge documentation across different areas")
-
-        return action_items[:5]  # Limit to 5 action items
-
-    def _calculate_synthesis_confidence(self, _contents: list[str], memories: list[Memory]) -> float:
-        """Calculate confidence score for synthesis."""
-        if not memories:
-            return 0.0
-
-        confidence = 0.5  # Base confidence
-
-        # More memories = higher confidence
-        memory_factor = min(1.0, len(memories) / 50.0)
-        confidence += memory_factor * 0.3
-
-        # More contributors = higher confidence
-        contributors = len({mem.user_id for mem in memories if mem.user_id})
-        contributor_factor = min(1.0, contributors / 5.0)
-        confidence += contributor_factor * 0.2
-
-        return min(1.0, confidence)
-
-    # Analytics Methods (delegated to MemoryAdminService)
-    def _build_analytics_cache_key(self, *args, **kwargs) -> str:
-        """Delegates to MemoryAdminService."""
-        return self._get_admin_svc()._build_analytics_cache_key(*args, **kwargs)
-
-    async def get_analytics(self, *args, **kwargs) -> Analytics:
-        """Delegates to MemoryAdminService."""
-        return await self._get_admin_svc().get_analytics(*args, **kwargs)
-
-    async def _gather_session_analytics(self, *args, **kwargs):
-        """Delegates to MemoryAdminService."""
-        await self._get_admin_svc()._gather_session_analytics(*args, **kwargs)
-
-    async def _gather_memory_analytics(self, *args, **kwargs):
-        """Delegates to MemoryAdminService."""
-        await self._get_admin_svc()._gather_memory_analytics(*args, **kwargs)
-
-    async def _gather_operation_analytics(self, *args, **kwargs):
-        """Delegates to MemoryAdminService."""
-        await self._get_admin_svc()._gather_operation_analytics(*args, **kwargs)
-
-    async def _gather_pattern_analytics(self, *args, **kwargs):
-        """Delegates to MemoryAdminService."""
-        await self._get_admin_svc()._gather_pattern_analytics(*args, **kwargs)
-
-    async def aggregate_analytics(self, *args, **kwargs):
-        """Delegates to MemoryAdminService."""
-        return await self._get_admin_svc().aggregate_analytics(*args, **kwargs)
-
-    # Memory CRUD Parity (Mem0 + Postgres + Redis)
-    async def get_memory(self, *args, **kwargs):
-        """Delegates to MemoryCRUDService."""
-        return await self._get_crud_svc().get_memory(*args, **kwargs)
-
-    async def update_memory(self, *args, **kwargs):
-        """Delegates to MemoryCRUDService."""
-        return await self._get_crud_svc().update_memory(*args, **kwargs)
-
-    async def delete_memory(self, *args, **kwargs):
-        """Delegates to MemoryCRUDService."""
-        return await self._get_crud_svc().delete_memory(*args, **kwargs)
-
-    async def batch_create_memories(self, *args, **kwargs):
-        """Delegates to MemoryCRUDService."""
-        return await self._get_crud_svc().batch_create_memories(*args, **kwargs)
-
-    async def batch_update_memories(self, *args, **kwargs):
-        """Delegates to MemoryCRUDService."""
-        return await self._get_crud_svc().batch_update_memories(*args, **kwargs)
-
-    async def batch_delete_memories(self, *args, **kwargs):
-        """Delegates to MemoryCRUDService."""
-        return await self._get_crud_svc().batch_delete_memories(*args, **kwargs)
-
-    async def delete_memories_by_filter(self, *args, **kwargs):
-        """Delegates to MemoryCRUDService."""
-        return await self._get_crud_svc().delete_memories_by_filter(*args, **kwargs)
-
-    async def create_memory_export(self, *args, **kwargs):
-        """Delegates to MemoryAdminService."""
-        return await self._get_admin_svc().create_memory_export(*args, **kwargs)
-
-    async def get_memory_export(self, *args, **kwargs):
-        """Delegates to MemoryAdminService."""
-        return await self._get_admin_svc().get_memory_export(*args, **kwargs)
-
-    async def get_memory_history(self, *args, **kwargs):
-        """Delegates to MemoryAdminService."""
-        return await self._get_admin_svc().get_memory_history(*args, **kwargs)
-
-    async def submit_memory_feedback(self, *args, **kwargs):
-        """Delegates to MemoryAdminService."""
-        return await self._get_admin_svc().submit_memory_feedback(*args, **kwargs)
-
-    async def _record_mem0_fallback_metrics(self, search_mode: str) -> None:
-        """Delegates to MemorySearchService."""
-        await self._get_search_svc()._record_mem0_fallback_metrics(search_mode)
-
-    # Statistics helpers (TSK-4.07)
-
-    async def count_memories(self, *args, **kwargs) -> int:
-        """Delegates to MemoryAdminService."""
-        return await self._get_admin_svc().count_memories(*args, **kwargs)
-
-    async def count_active_sessions(self, *args, **kwargs) -> int:
-        """Delegates to MemoryAdminService."""
-        return await self._get_admin_svc().count_active_sessions(*args, **kwargs)
-
-    # Health Check
-    async def health_check(self, *args, **kwargs):
-        """Delegates to MemoryAdminService."""
-        return await self._get_admin_svc().health_check(*args, **kwargs)
-
-
-# Global service instance
-ai_memory_service = VDSAIMemoryService()
-
-
-async def get_ai_memory_service() -> VDSAIMemoryService:
-    """Get the global AI memory service instance."""
-    if not ai_memory_service._redis_service:
-        await ai_memory_service.initialize()
-    return ai_memory_service