@ngocsangairvds/vsaf 3.2.15 → 4.0.0

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

@@ -1,1469 +0,0 @@
-"""MemoryCRUDService — create/read/update/delete memory operations.
-
-Extracted from VDSAIMemoryService as part of VAMI-008 Sub-Wave B decomposition.
-Accept dependencies via constructor injection; delegate from the facade.
-"""
-
-import asyncio
-import contextlib
-import json
-import logging
-from datetime import UTC, datetime, timedelta
-from typing import Any
-from uuid import uuid4
-
-from sqlalchemy import text
-
-from vds_memory_orchestrator.service.core.ai_memory_exceptions import (
-    MemoryRevisionConflictError,
-    NotFoundError,
-    ServiceUnavailableError,
-)
-from vds_memory_orchestrator.service.core.config import REDIS_MEMORY_CACHE_DB
-from vds_memory_orchestrator.service.database.postgres_manager import database_service
-from vds_memory_orchestrator.service.database.redis_manager import redis_manager
-from vds_memory_orchestrator.service.integrations.memory_transformer import DataModelTransformer
-from vds_memory_orchestrator.service.models.ai_memory_models import (
-    ImportanceLevel,
-    Memory,
-    MemoryBatchCreateRequest,
-    MemoryBatchDeleteRequest,
-    MemoryBatchUpdateRequest,
-    MemoryCreateRequest,
-    MemoryDeleteRequest,
-    MemoryStatus,
-    MemoryUpdateRequest,
-    SessionUpdateRequest,
-    ToolType,
-)
-from vds_memory_orchestrator.service.services.analytics_events import record_memory_event
-from vds_memory_orchestrator.service.services.embedding_service import (
-    embedding_service as _global_embedding_service,
-)
-from vds_memory_orchestrator.service.services.storage_strategy import StorageTier
-from vds_memory_orchestrator.service.services.storage_strategy.storage_engine import MemoryFeatures
-
-logger = logging.getLogger(__name__)
-
-# Constants shared with ai_memory_service
-INDEX_MEMORY_MIN_CHARS = 1200
-INDEX_MEMORY_IMPORTANT_MIN_CHARS = 600
-INDEX_MEMORY_SHORT_MIN_CHARS = 400
-INDEX_MEMORY_MAX_CHARS = 1200
-INDEX_MEMORY_MAX_LINES = 12
-
-
-class MemoryCRUDService:
-    """Handles memory create/read/update/delete and batch operations."""
-
-    def __init__(
-        self,
-        config: Any,
-        mem0_sync: Any,
-        redis_service: Any,
-        session_loader: Any = None,
-        session_updater: Any = None,
-        emit_operation_fn: Any = None,
-        storage_engine: Any = None,
-        evolution_tracker: Any = None,
-    ) -> None:
-        self.config = config
-        self._mem0_sync = mem0_sync
-        self._redis_service = redis_service
-        self._session_loader = session_loader
-        self._session_updater = session_updater
-        self._emit_fn = emit_operation_fn
-        self._storage_engine = storage_engine
-        self._memory_evolution_tracker = evolution_tracker
-        self._embedding_service = _global_embedding_service
-        # Mutable scope state preserved from facade (used by Mem0 lookup filters)
-        self._last_user_id: str | None = None
-        self._last_app_id: str | None = None
-        self._last_session_id: str | None = None
-
-    @property
-    def _mem0_client(self) -> Any:
-        if self._mem0_sync is not None:
-            return self._mem0_sync._mem0_client
-        return None
-
-    async def _mem0_call(self, method_name: str, **kwargs: Any) -> Any:
-        """Delegate mem0 call to Mem0SyncService."""
-        if self._mem0_sync is not None:
-            return await self._mem0_sync.mem0_call(method_name, **kwargs)
-        raise ServiceUnavailableError("Mem0 client not initialized")
-
-    async def get_session(self, session_id: str) -> Any:
-        """Delegate to injected session loader."""
-        if self._session_loader is not None:
-            return await self._session_loader(session_id)
-        return None
-
-    async def update_session(self, request: Any) -> bool:
-        """Delegate to injected session updater."""
-        if self._session_updater is not None:
-            return await self._session_updater(request)
-        return False
-
-    async def _emit_operation(self, **kwargs: Any) -> None:
-        """Delegate to injected emit function."""
-        if self._emit_fn is not None:
-            await self._emit_fn(**kwargs)
-
-    def _derive_org_id(self, *sources: Any) -> str | None:
-        """Extract an org/team identifier from the provided sources if available."""
-        candidate_keys = ("org_id", "organization_id", "team_id", "tenant_id")
-        for source in sources:
-            if not source:
-                continue
-            payload = source
-            model_dump = getattr(payload, "model_dump", None)
-            if callable(model_dump):
-                try:
-                    payload = model_dump()
-                except Exception:  # pragma: no cover - defensive guardrail
-                    payload = None
-            if isinstance(payload, dict):
-                for key in candidate_keys:
-                    value = payload.get(key)
-                    if value:
-                        return str(value)
-        return getattr(self.config.service, "default_org_id", None)
-
-    async def _invalidate_semantic_cache(self, user_id: str | None) -> None:
-        """Invalidate semantic cache entries for a user (best effort)."""
-        if not user_id:
-            return
-        try:
-            from vds_memory_orchestrator.service.services.semantic_cache_service import (
-                get_semantic_cache_service,
-            )
-
-            semantic_cache = await get_semantic_cache_service()
-            await semantic_cache.invalidate_cache(f"semantic_cache:{user_id}:*")
-        except Exception as exc:  # pragma: no cover - best effort
-            logger.debug("Semantic cache invalidation skipped: %s", exc)
-
-    def _should_create_index_memory(self, *, content: str, category: str, importance: str) -> bool:
-        if not content:
-            return False
-        normalized_category = category.replace("_", "-").lower()
-        normalized_importance = importance.lower()
-        index_categories = {
-            "document",
-            "business-logic",
-            "session-summary",
-            "hook-insight",
-            "project",
-            "reference",
-            "research",
-        }
-        if len(content) >= INDEX_MEMORY_MIN_CHARS:
-            return True
-        if normalized_category in index_categories and len(content) >= INDEX_MEMORY_SHORT_MIN_CHARS:
-            return True
-        return (
-            normalized_importance in {"high", "critical"}
-            and len(content) >= INDEX_MEMORY_IMPORTANT_MIN_CHARS
-        )
-
-    def _build_index_memory_content(
-        self,
-        *,
-        content: str,
-        category: str,
-        importance: str,
-        canonical_id: str,
-        session_id: str | None,
-        project_domain: str | None,
-        tags: list[str] | None = None,
-    ) -> str:
-        lines: list[str] = []
-        lines.append("INDEX MEMORY")
-        lines.append(f"canonical_id: {canonical_id}")
-        lines.append(f"category: {category}")
-        lines.append(f"importance: {importance}")
-        if project_domain:
-            lines.append(f"project_domain: {project_domain}")
-        if session_id:
-            lines.append(f"session_id: {session_id}")
-        if tags:
-            lines.append(f"tags: {', '.join(tags)}")
-
-        excerpt_lines: list[str] = []
-        for raw in content.splitlines():
-            stripped = raw.strip()
-            if not stripped:
-                continue
-            if stripped.startswith(("#", "-", "*", "1.", "2.", "3.")):
-                excerpt_lines.append(stripped[:160])
-            if len(excerpt_lines) >= INDEX_MEMORY_MAX_LINES:
-                break
-
-        if excerpt_lines:
-            lines.append("excerpt:")
-            lines.extend(excerpt_lines)
-        else:
-            snippet = content.strip().replace("\n", " ")
-            lines.append("excerpt:")
-            lines.append(snippet[:INDEX_MEMORY_MAX_CHARS])
-
-        index_content = "\n".join(lines)
-        if len(index_content) > INDEX_MEMORY_MAX_CHARS:
-            index_content = index_content[:INDEX_MEMORY_MAX_CHARS].rstrip()
-        return index_content
-
-    async def _create_index_memory(
-        self,
-        *,
-        index_content: str,
-        metadata: dict[str, Any],
-        user_id: str,
-        session_id: str | None,
-    ) -> str | None:
-        """Delegate to Mem0SyncService."""
-        if self._mem0_sync is None:
-            return None
-        return await self._mem0_sync.create_index_memory(
-            index_content=index_content,
-            metadata=metadata,
-            user_id=user_id,
-            session_id=session_id,
-        )
-
-    async def _resolve_mem0_id_from_event(
-        self, event_id: str, memory_id: str, metadata: dict | None
-    ) -> str | None:
-        """Delegate to Mem0SyncService."""
-        if self._mem0_sync is None:
-            return None
-        return await self._mem0_sync.resolve_mem0_id_from_event(event_id, memory_id, metadata)
-
-    async def _resolve_mem0_id_by_search(self, memory_id: str) -> str | None:
-        """Delegate to Mem0SyncService, passing current scope context."""
-        if self._mem0_sync is None:
-            return None
-        return await self._mem0_sync.resolve_mem0_id_by_search(
-            memory_id,
-            user_id=self._last_user_id,
-            session_id=self._last_session_id,
-            app_id=self._last_app_id,
-        )
-
-    async def _record_evolution_event(
-        self,
-        event_type: str,
-        *,
-        session_id: str,
-        user_id: str,
-        org_id: str | None = None,
-        memory_id: str | None = None,
-        importance: str | None = None,
-        storage_tier: str | None = None,
-        payload: dict[str, Any] | None = None,
-        metadata: dict[str, Any] | None = None,
-    ) -> None:
-        tracker = getattr(self, "_memory_evolution_tracker", None)
-        if not tracker:
-            return
-        try:
-            await tracker.record_event(
-                event_type,
-                session_id=session_id,
-                user_id=user_id,
-                org_id=org_id,
-                memory_id=memory_id,
-                importance=importance,
-                storage_tier=storage_tier,
-                payload=payload,
-                metadata=metadata,
-                source="ai_memory_service",
-            )
-        except Exception as exc:  # pragma: no cover - telemetry guardrail
-            logger.debug("Memory evolution tracker suppressed error: %s", exc)
-
-    # Session Management Methods
-
-    async def create_memory(self, request: MemoryCreateRequest) -> str:
-        """Create a new memory with intelligent storage routing."""
-        from datetime import UTC, datetime
-
-        start_time = datetime.now(UTC)
-        error_msg = None
-        memory_id = (
-            (request.metadata or {}).get("memory_id") if hasattr(request, "metadata") else None
-        )
-
-        try:
-            # Enhance memory data with session context
-            session_data = await self.get_session(request.session_id)
-            enhanced_memory = DataModelTransformer.enhance_memory_with_session(
-                request, session_data
-            )
-
-            # Apply optional TTL / conversation_id to metadata for scoping
-            if getattr(request, "ttl_minutes", None):
-                expires_at = datetime.now(UTC) + timedelta(minutes=int(request.ttl_minutes))
-                enhanced_memory.metadata.setdefault("expires_at", expires_at.isoformat())
-                enhanced_memory.expires_at = expires_at
-            if getattr(request, "conversation_id", None):
-                enhanced_memory.metadata.setdefault("conversation_id", request.conversation_id)
-
-            # Cache last scope for Mem0 lookup filters
-            self._last_user_id = enhanced_memory.user_id or (enhanced_memory.metadata or {}).get(
-                "user_id"
-            )
-            self._last_app_id = getattr(request.project_domain, "value", request.project_domain)
-            self._last_session_id = request.session_id
-
-            # Storage Strategy Classification (analytics only; writes are PG-first)
-            storage_tier = StorageTier.REDIS  # Default fallback
-            if self._storage_engine:
-                try:
-                    import re
-                    from datetime import UTC, datetime
-
-                    now = datetime.now(UTC)
-                    content_lower = enhanced_memory.content.lower()
-
-                    importance_to_role = {
-                        ImportanceLevel.CRITICAL: 0.95,
-                        ImportanceLevel.HIGH: 0.85,
-                        ImportanceLevel.MEDIUM: 0.65,
-                        ImportanceLevel.LOW: 0.45,
-                    }
-                    user_role_importance = importance_to_role.get(request.importance, 0.5)
-
-                    features = MemoryFeatures(
-                        content_length=len(enhanced_memory.content),
-                        word_count=len(enhanced_memory.content.split()),
-                        sentence_count=len(re.split(r"[.!?]+", enhanced_memory.content)),
-                        has_solution_pattern=any(
-                            word in content_lower
-                            for word in [
-                                "solution",
-                                "fix",
-                                "resolve",
-                                "implement",
-                                "solved",
-                            ]
-                        ),
-                        has_decision_pattern=any(
-                            word in content_lower
-                            for word in [
-                                "decided",
-                                "chose",
-                                "selected",
-                                "adopted",
-                                "approved",
-                            ]
-                        ),
-                        has_code_pattern="```" in enhanced_memory.content
-                        or any(
-                            word in content_lower
-                            for word in ["function", "class", "algorithm", "code"]
-                        ),
-                        has_question_pattern="?" in enhanced_memory.content
-                        or any(
-                            word in content_lower
-                            for word in ["what", "how", "why", "when", "where"]
-                        ),
-                        has_procon_pattern=any(
-                            word in content_lower
-                            for word in [
-                                "pros",
-                                "cons",
-                                "advantage",
-                                "disadvantage",
-                                "tradeoff",
-                            ]
-                        ),
-                        business_domain=session_data.project_domain.value
-                        if session_data and hasattr(session_data.project_domain, "value")
-                        else "general",
-                        memory_category=request.category.value
-                        if hasattr(request.category, "value")
-                        else str(request.category),
-                        user_role_importance=user_role_importance,
-                        session_recency_score=session_data.total_operations / 50
-                        if session_data and session_data.total_operations
-                        else 0.0,
-                        interaction_count=session_data.total_operations if session_data else 0,
-                        tool_used=request.tool_used.value
-                        if getattr(request, "tool_used", None)
-                        else None,
-                        created_at=now,
-                        hour_of_day=now.hour,
-                        day_of_week=now.weekday(),
-                    )
-                    classification = await self._storage_engine.classify_storage(features)
-                    storage_tier = classification.tier
-                    logger.info(f"Storage strategy classified as {storage_tier} for memory content")
-                except Exception as e:
-                    logger.warning(f"Storage classification failed, using REDIS fallback: {e}")
-
-            # Override rule: all high/critical decisions go to Mem0 by default
-            importance_value = ""
-            if request.importance:
-                base_value = (
-                    request.importance.value
-                    if hasattr(request.importance, "value")
-                    else str(request.importance)
-                )
-                importance_value = str(base_value).lower()
-            if not importance_value and getattr(request, "metadata", None):
-                importance_value = str(request.metadata.get("importance", "")).lower()
-            if not importance_value and enhanced_memory.metadata:
-                importance_value = str(enhanced_memory.metadata.get("importance", "")).lower()
-            category_value = (
-                request.category.value.lower()
-                if hasattr(request.category, "value")
-                else str(request.category or "").lower()
-            )
-            if not category_value and getattr(request, "metadata", None):
-                category_value = str(request.metadata.get("category", "")).lower()
-            if not category_value and enhanced_memory.metadata:
-                category_value = str(enhanced_memory.metadata.get("category", "")).lower()
-            category_value = category_value.replace("_", "-")
-            content_lower = enhanced_memory.content.lower()
-            # Route to Mem0 for high/critical, session-summary, or force_mem0
-            force_mem0 = bool(getattr(request, "force_mem0", False))
-            mem0_eligible = False
-            if force_mem0 or (
-                importance_value in {"high", "critical"} or category_value == "session-summary"
-            ):
-                mem0_eligible = bool(self._mem0_client)
-
-            if mem0_eligible:
-                storage_tier = StorageTier.MEM0_PRO
-            elif storage_tier not in {StorageTier.POSTGRES, StorageTier.REDIS}:
-                storage_tier = StorageTier.POSTGRES
-
-            logger.info(
-                "Mem0 eligibility: %s (importance=%s category=%s force=%s)",
-                mem0_eligible,
-                importance_value,
-                category_value,
-                getattr(request, "force_mem0", False),
-            )
-
-            # Generate embedding once for PG vector + Mem0 reuse
-            embedding_vector = None
-            try:
-                embedding_vector = await self._embedding_service.generate_embedding(
-                    enhanced_memory.content
-                )
-            except Exception as embed_err:
-                logger.warning(
-                    "Embedding generation failed, continuing without vector: %s",
-                    embed_err,
-                )
-
-            memory_id = memory_id or f"pg_{uuid4()}"
-            org_id = self._derive_org_id(
-                getattr(request, "metadata", None),
-                session_data.context_metadata if session_data else None,
-            )
-            if org_id and enhanced_memory.metadata is not None:
-                enhanced_memory.metadata.setdefault("org_id", org_id)
-            if enhanced_memory.metadata is not None:
-                enhanced_memory.metadata.setdefault("canonical_id", memory_id)
-
-            index_content = None
-            index_metadata: dict[str, Any] | None = None
-            if (
-                mem0_eligible
-                and self._mem0_client
-                and self._should_create_index_memory(
-                    content=enhanced_memory.content,
-                    category=category_value,
-                    importance=importance_value,
-                )
-            ):
-                tags = None
-                if isinstance(enhanced_memory.metadata, dict):
-                    tags = enhanced_memory.metadata.get("tags")
-                    if isinstance(tags, str):
-                        tags = [tags]
-                index_content = self._build_index_memory_content(
-                    content=enhanced_memory.content,
-                    category=category_value,
-                    importance=importance_value,
-                    canonical_id=memory_id,
-                    session_id=request.session_id,
-                    project_domain=(
-                        session_data.project_domain.value
-                        if session_data and hasattr(session_data.project_domain, "value")
-                        else None
-                    ),
-                    tags=tags if isinstance(tags, list) else None,
-                )
-                index_metadata = {
-                    "memory_id": memory_id,
-                    "canonical_id": memory_id,
-                    "external_id": f"index-{memory_id}",
-                    "kind": "index",
-                    "category": category_value,
-                    "importance": importance_value,
-                    "source": "vds-ai-memory-service",
-                }
-                if org_id:
-                    index_metadata["org_id"] = org_id
-                if enhanced_memory.metadata:
-                    if enhanced_memory.metadata.get("agent_id"):
-                        index_metadata["agent_id"] = enhanced_memory.metadata.get("agent_id")
-                    if enhanced_memory.metadata.get("team_id"):
-                        index_metadata["team_id"] = enhanced_memory.metadata.get("team_id")
-
-            # Persist to PostgreSQL first (canonical + pgvector mirror when enabled)
-            mem0_status = (
-                "pending"
-                if mem0_eligible and self._mem0_client
-                else ("skipped" if mem0_eligible else "local-only")
-            )
-            postgres = database_service.postgres
-            pgvector_enabled = getattr(postgres, "_pgvector_enabled", False)
-            pgvector_id = None
-
-            memory_doc = {
-                "content": enhanced_memory.content,
-                "user_id": request.user_id or "system",
-                "session_id": request.session_id,
-                "category": request.category.value
-                if hasattr(request.category, "value")
-                else str(request.category),
-                "importance": request.importance.value
-                if hasattr(request.importance, "value")
-                else str(request.importance),
-                "team_id": getattr(request, "team_id", None),
-                "project_domain": session_data.project_domain.value
-                if session_data and hasattr(session_data.project_domain, "value")
-                else None,
-                "storage_tier": storage_tier.value
-                if hasattr(storage_tier, "value")
-                else str(storage_tier),
-                "source": "vds-ai-memory-service",
-                "mem0_status": mem0_status,
-                "mem0_push_attempts": 0,
-                "mem0_policy": "eligible" if mem0_eligible else "skipped",
-            }
-
-            if pgvector_enabled and embedding_vector is not None:
-                try:
-                    pgvector_id = await postgres.insert_document(
-                        title=f"Memory_{memory_id}",
-                        content=memory_doc["content"],
-                        embedding=embedding_vector,
-                        user_id=memory_doc["user_id"],
-                        team_id=memory_doc.get("team_id"),
-                        metadata=memory_doc,
-                    )
-                    memory_doc["pgvector_id"] = pgvector_id
-                    logger.info("Memory mirrored to pgvector: %s", pgvector_id)
-                except Exception as pgvec_err:
-                    logger.warning(
-                        "pgvector mirror failed (will continue with canonical only): %s",
-                        pgvec_err,
-                    )
-
-            if getattr(database_service, "postgres", None) and getattr(
-                database_service.postgres, "engine", None
-            ):
-                canonical_metadata = (enhanced_memory.metadata or {}).copy()
-                canonical_metadata.update(memory_doc)
-                if embedding_vector is not None:
-                    canonical_metadata["embedding"] = embedding_vector
-                await database_service.upsert_memory_record(
-                    memory_id=memory_id,
-                    user_id=request.user_id or "system",
-                    session_id=request.session_id,
-                    team_id=getattr(request, "team_id", None),
-                    content=enhanced_memory.content,
-                    category=request.category.value
-                    if hasattr(request.category, "value")
-                    else str(request.category),
-                    importance=request.importance.value
-                    if hasattr(request.importance, "value")
-                    else str(request.importance),
-                    metadata=canonical_metadata,
-                    storage_tier=storage_tier.value
-                    if hasattr(storage_tier, "value")
-                    else str(storage_tier),
-                )
-            else:
-                logger.warning("PostgreSQL not initialized; skipping canonical upsert (test mode)")
-
-            if (
-                pgvector_enabled
-                and embedding_vector is not None
-                and getattr(database_service, "postgres", None)
-                and getattr(database_service.postgres, "engine", None)
-            ):
-                try:
-                    query_embedding_str = f"[{','.join(str(x) for x in embedding_vector)}]"
-                    async with database_service.postgres.engine.begin() as conn:
-                        await conn.execute(
-                            text(
-                                """
-                                INSERT INTO memory_vectors (memory_id, embedding, created_at, updated_at)
-                                VALUES (:memory_id, :embedding, NOW(), NOW())
-                                ON CONFLICT (memory_id)
-                                DO UPDATE SET embedding = EXCLUDED.embedding, updated_at = NOW()
-                                """
-                            ),
-                            {
-                                "memory_id": memory_id,
-                                "embedding": query_embedding_str,
-                            },
-                        )
-                except Exception as exc:
-                    logger.warning("memory_vectors upsert failed: %s", exc)
-
-            meta_current = enhanced_memory.metadata or {}
-
-            if mem0_eligible:
-                if not self._mem0_client:
-                    logger.warning(
-                        "Mem0 eligible but client not initialized; skipping inline push",
-                    )
-                elif getattr(self.config.mem0, "store_async_mode", False):
-                    # VAMI-017 Phase B T-A3 — async path. Memory row + embedding
-                    # already persisted above. Skip the inline mem0 add +
-                    # event-polling block; queue via Celery for background
-                    # resolution. Clients poll GET /memories/{id}/status to
-                    # observe terminal state.
-                    logger.info(
-                        "Mem0 async-mode ON: queueing mem0.push_memory for %s (no inline add)",
-                        memory_id,
-                    )
-                    try:
-                        await self._enqueue_mem0_push(
-                            memory_id,
-                            enhanced_memory,
-                            embedding_vector,
-                            session_data,
-                        )
-                        # Stamp metadata to signal queued state to /status endpoint.
-                        # VAMI-018 T-F1-3: use update_memory_if_not_terminal to
-                        # avoid clobbering a concurrent Celery-worker terminal
-                        # writeback. The worker may finish before this stamp
-                        # commits; without the guard, "pending" would overwrite
-                        # the just-written "synced"/"stalled" state and /status
-                        # would stay at "queued" forever. (ADR-19)
-                        try:
-                            if getattr(database_service, "postgres", None) and getattr(
-                                database_service.postgres, "engine", None
-                            ):
-                                async with database_service.postgres.engine.begin() as conn:
-                                    meta = enhanced_memory.metadata or {}
-                                    meta["mem0_status"] = "pending"
-                                    meta["mem0_reason"] = "async_mode_queued"
-                                    new_version = (
-                                        await database_service.update_memory_if_not_terminal(
-                                            conn,
-                                            memory_id,
-                                            {
-                                                "metadata": meta,
-                                                "storage_tier": "mem0_pro",
-                                            },
-                                        )
-                                    )
-                                    if new_version is None:
-                                        logger.info(
-                                            "async-mode stamp skipped: %s already in terminal mem0_status",
-                                            memory_id,
-                                        )
-                                    meta_current = meta
-                        except Exception as meta_err:  # pragma: no cover - defensive
-                            logger.debug("async-mode metadata stamp skipped: %s", meta_err)
-                    except Exception as enqueue_err:  # pragma: no cover - defensive
-                        logger.warning(
-                            "async-mode enqueue failed for %s: %s (memory persisted locally)",
-                            memory_id,
-                            enqueue_err,
-                        )
-                else:
-                    mem0_id: str | None = None
-                    mem0_event_id: str | None = None
-                    try:
-                        logger.info(
-                            "Mem0 eligible create: memory_id=%s ext_id=%s",
-                            memory_id,
-                            memory_id,
-                        )
-                        messages = (
-                            [{"role": "user", "content": enhanced_memory.content}]
-                            if isinstance(enhanced_memory.content, str)
-                            else enhanced_memory.content
-                        )
-                        payload_metadata = {
-                            **(enhanced_memory.metadata or {}),
-                            "memory_id": memory_id,
-                            "session_id": request.session_id,
-                            "external_id": memory_id,
-                            "created_at": enhanced_memory.created_at.isoformat(),
-                            "updated_at": enhanced_memory.updated_at.isoformat(),
-                        }
-                        add_result = await self._mem0_call(
-                            "add",
-                            messages=messages,
-                            user_id=enhanced_memory.user_id or "system",
-                            agent_id=(enhanced_memory.metadata or {}).get("agent_id")
-                            or (enhanced_memory.metadata or {}).get("team_id"),
-                            run_id=request.session_id,
-                            metadata=payload_metadata,
-                        )
-                        body = add_result or {}
-                        logger.info(
-                            "Mem0 add response body=%s",
-                            {
-                                k: v
-                                for k, v in body.items()
-                                if isinstance(body, dict) and k != "results"
-                            }
-                            if isinstance(body, dict)
-                            else body,
-                        )
-                        results = []
-                        if isinstance(body, dict):
-                            results = body.get("results") or []
-                            mem0_id = body.get("id") or body.get("memory_id")
-                            mem0_event_id = body.get("event_id")
-                        if results:
-                            first = results[0] or {}
-                            if isinstance(first, dict):
-                                mem0_id = mem0_id or first.get("id") or first.get("memory_id")
-                                mem0_event_id = (
-                                    mem0_event_id or first.get("event_id") or first.get("event")
-                                )
-
-                        # Bounded poll via SDK if only event id is present (sync mode only).
-                        # get_event is cloud-only in mem0 2.0.0 and is exposed by
-                        # Mem0Adapter as a passthrough only when the cloud client
-                        # is active. Skip the event-poll loop entirely when the
-                        # method is absent to avoid ServiceUnavailableError noise;
-                        # the metadata fallback below will mark the record pending.
-                        # See phase175 diagnosis.
-                        supports_get_event = self._mem0_client is not None and hasattr(
-                            self._mem0_client, "get_event"
-                        )
-                        if not mem0_id and mem0_event_id and supports_get_event:
-                            for delay in (0.25, 0.5, 1, 2, 3):
-                                await asyncio.sleep(delay)
-                                try:
-                                    ev = await self._mem0_call("get_event", event_id=mem0_event_id)
-                                    if ev and ev.get("status") == "SUCCEEDED":
-                                        res_hits = ev.get("results") or []
-                                        if res_hits:
-                                            mem0_id = res_hits[0].get("id") or res_hits[0].get(
-                                                "memory_id"
-                                            )
-                                            break
-                                except Exception as ev_err:
-                                    logger.warning("Mem0 event poll failed: %s", ev_err)
-
-                        if getattr(database_service, "postgres", None) and getattr(
-                            database_service.postgres, "engine", None
-                        ):
-                            async with database_service.postgres.engine.begin() as conn:
-                                meta = meta_current or {}
-                                if mem0_id:
-                                    meta["mem0_id"] = mem0_id
-                                    meta["mem0_status"] = "synced"
-                                    meta.pop("mem0_event_id", None)
-                                    meta.pop("mem0_reason", None)
-                                else:
-                                    meta["mem0_status"] = "pending"
-                                    meta["mem0_reason"] = "mem0_add_no_id_returned"
-                                    if mem0_event_id:
-                                        meta["mem0_event_id"] = mem0_event_id
-                                        meta["mem0_reason"] = "awaiting_event_materialization"
-                                await database_service.update_memory(
-                                    conn,
-                                    memory_id,
-                                    {"metadata": meta, "storage_tier": "mem0_pro"},
-                                )
-                                meta_current = meta
-                        else:
-                            logger.debug(
-                                "PostgreSQL not initialized; skipping Mem0 metadata update"
-                            )
-                        if not mem0_id:
-                            logger.info(
-                                "Mem0 id not resolved inline for %s (event_id=%s); worker resolver will retry",
-                                memory_id,
-                                mem0_event_id,
-                            )
-                            await self._enqueue_mem0_push(
-                                memory_id,
-                                enhanced_memory,
-                                embedding_vector,
-                                session_data,
-                            )
-                    except Exception as push_err:
-                        logger.warning("Failed Mem0 inline push for %s: %s", memory_id, push_err)
-                        try:
-                            if getattr(database_service, "postgres", None) and getattr(
-                                database_service.postgres, "engine", None
-                            ):
-                                async with database_service.postgres.engine.begin() as conn:
-                                    meta = meta_current or {}
-                                    meta["mem0_status"] = "pending"
-                                    meta["mem0_reason"] = (
-                                        f"mem0_add_exception:{type(push_err).__name__}"
-                                    )
-                                    await database_service.update_memory(
-                                        conn,
-                                        memory_id,
-                                        {"metadata": meta, "storage_tier": "mem0_pro"},
-                                    )
-                                    meta_current = meta
-                        except Exception:
-                            pass
-                        await self._enqueue_mem0_push(
-                            memory_id,
-                            enhanced_memory,
-                            embedding_vector,
-                            session_data,
-                        )
-
-            # ensure downstream cache sees latest metadata
-            enhanced_memory.metadata = meta_current
-
-            if index_content and index_metadata and mem0_eligible:
-                index_metadata.setdefault("session_id", request.session_id)
-                index_metadata.setdefault("user_id", enhanced_memory.user_id)
-                await self._create_index_memory(
-                    index_content=index_content,
-                    metadata=index_metadata,
-                    user_id=enhanced_memory.user_id or "system",
-                    session_id=request.session_id,
-                )
-
-            if storage_tier == StorageTier.REDIS:
-                memory_id = memory_id or f"redis_{datetime.now(UTC).timestamp()}"
-                logger.info(f"Memory stored in Redis (fallback): {memory_id}")
-            # Always cache in Redis for fast retrieval (regardless of primary storage)
-            payload_key = f"memory:{memory_id}:payload"
-            memory_data = enhanced_memory.model_dump(mode="json")
-            memory_data.update(
-                {
-                    "memory_id": memory_id,
-                    "storage_tier": storage_tier.value,
-                    "created_at": enhanced_memory.created_at.isoformat(),
-                }
-            )
-            await self._redis_service.set_json(
-                payload_key, memory_data, ttl=self.config.cache.memory_ttl
-            )
-
-            importance_value = (
-                request.importance.value
-                if hasattr(request.importance, "value")
-                else str(request.importance)
-            )
-            try:
-                await record_memory_event(
-                    memory_id,
-                    storage_tier.value if hasattr(storage_tier, "value") else str(storage_tier),
-                    importance_value,
-                )
-            except Exception as analytics_error:  # pragma: no cover - best effort metrics
-                logger.debug("Failed to record memory analytics event: %s", analytics_error)
-
-            await self._record_evolution_event(
-                "memory_created",
-                session_id=request.session_id,
-                user_id=request.user_id or "system",
-                org_id=self._derive_org_id(
-                    getattr(request, "metadata", None),
-                    session_data.context_metadata if session_data else None,
-                ),
-                memory_id=memory_id,
-                importance=importance_value,
-                storage_tier=storage_tier.value
-                if hasattr(storage_tier, "value")
-                else str(storage_tier),
-                payload={
-                    "category": request.category.value
-                    if hasattr(request.category, "value")
-                    else str(request.category),
-                    "operation_type": getattr(request, "operation_type", "create"),
-                    "force_mem0": getattr(request, "force_mem0", False),
-                },
-                metadata={
-                    "shadow_reason": "stage0_observation",
-                    "session_total_operations": getattr(session_data, "total_operations", None)
-                    if session_data
-                    else None,
-                },
-            )
-
-            # Add to session's memory list (only if memory_id is not None)
-            if memory_id is not None:
-                session_cache_key = f"session:{request.session_id}:memories:ids"
-                cached_ids = await self._redis_service.get_list(session_cache_key)
-                cached_ids.append(memory_id)
-                await self._redis_service.set_list(
-                    session_cache_key, cached_ids, ttl=self.config.cache.session_ttl
-                )
-
-            # Update session statistics
-            if session_data:
-                await self.update_session(
-                    SessionUpdateRequest(
-                        session_id=request.session_id,
-                        updates={
-                            "total_memories": session_data.total_memories + 1,
-                            "last_memory_content": enhanced_memory.content[:200],
-                            "last_accessed": datetime.now(UTC),
-                        },
-                    )
-                )
-
-            # Emit success operation
-            duration_ms = int((datetime.now(UTC) - start_time).total_seconds() * 1000)
-            await self._emit_operation(
-                session_id=request.session_id,
-                operation_type="create",
-                status="success",
-                duration_ms=duration_ms,
-                metadata={
-                    "memory_id": memory_id,
-                    "category": request.category.value
-                    if hasattr(request.category, "value")
-                    else str(request.category),
-                },
-                user_id=request.user_id,
-                tool_used=getattr(request, "tool_used", None) or ToolType.WRITE,
-            )
-
-            logger.info(f"Memory created and cached successfully: {memory_id}")
-            with contextlib.suppress(Exception):
-                await self._redis_service.cross_invalidate(request.session_id)
-                await self._redis_service.invalidate_search_scope(
-                    org_id=getattr(request, "org_id", None)
-                    or (
-                        session_data.context_metadata.get("org_id")
-                        if session_data and getattr(session_data, "context_metadata", None)
-                        else None
-                    ),
-                    user_id=request.user_id,
-                    session_id=request.session_id,
-                )
-                await self._invalidate_semantic_cache(
-                    request.user_id or (session_data.user_id if session_data else None)
-                )
-            return memory_id
-
-        except Exception as e:
-            error_msg = str(e)
-
-            # Emit error operation
-            duration_ms = int((datetime.now(UTC) - start_time).total_seconds() * 1000)
-            await self._emit_operation(
-                session_id=request.session_id,
-                operation_type="create",
-                status="error",
-                duration_ms=duration_ms,
-                error=error_msg,
-                metadata={
-                    "category": request.category.value
-                    if hasattr(request.category, "value")
-                    else str(request.category)
-                },
-                user_id=request.user_id,
-                tool_used=getattr(request, "tool_used", None) or ToolType.WRITE,
-            )
-
-            logger.exception(f"Error creating memory: {e}")
-            raise
-
-    async def _enqueue_mem0_push(
-        self,
-        memory_id: str,
-        enhanced_memory,
-        embedding_vector,
-        session_data,
-    ) -> None:
-        """Queue an async Mem0 push task with cached payload for reuse."""
-        try:
-            from vds_memory_orchestrator.service.services.memory_evolution.celery_app import (
-                celery_app,
-            )
-        except Exception as exc:  # pragma: no cover - defensive import
-            logger.warning("Celery app unavailable, skipping Mem0 enqueue: %s", exc)
-            return
-
-        payload = {
-            "memory_id": memory_id,
-            "content": enhanced_memory.content,
-            "user_id": enhanced_memory.user_id,
-            "session_id": enhanced_memory.session_id,
-            "team_id": getattr(enhanced_memory, "team_id", None),
-            "category": getattr(enhanced_memory, "category", None),
-            "importance": getattr(enhanced_memory, "importance", None),
-            "metadata": enhanced_memory.metadata or {},
-            "project_domain": None,
-            "embedding": embedding_vector,
-        }
-        # Derive project_domain from session or metadata safely
-        try:
-            if session_data and getattr(session_data, "project_domain", None):
-                payload["project_domain"] = (
-                    session_data.project_domain.value
-                    if hasattr(session_data.project_domain, "value")
-                    else session_data.project_domain
-                )
-            elif payload["metadata"] and isinstance(payload["metadata"], dict):
-                pd = payload["metadata"].get("project_domain")
-                if pd:
-                    payload["project_domain"] = pd
-        except Exception:
-            payload["project_domain"] = None
-        cache_key = f"mem0:push:{memory_id}"
-        with contextlib.suppress(Exception):
-            await self._redis_service.set_json(
-                cache_key,
-                payload,
-                ttl=self.config.cache.memory_ttl,
-            )
-        try:
-            celery_app.send_task(
-                "mem0.push_memory",
-                args=[memory_id],
-                kwargs={"cache_key": cache_key},
-            )
-            logger.info("Queued Mem0 push task for %s", memory_id)
-        except Exception as exc:
-            logger.warning("Failed to send Mem0 push task: %s", exc)
-
-    async def get_memory(self, memory_id: str) -> Memory | None:
-        """Fetch a single memory with transparency fields."""
-        # 1) Redis cache
-        payload_key = f"memory:{memory_id}:payload"
-        cached = await self._redis_service.get_json(payload_key)
-        if cached:
-            try:
-                return Memory(**cached)
-            except Exception:
-                logger.debug("Cached memory parse failed, falling back to stores")
-
-        # 2) Postgres canonical
-        try:
-            mem = await database_service.get_memory(memory_id)
-            if mem:
-                await self._redis_service.set_json(
-                    payload_key,
-                    mem.model_dump(mode="json"),
-                    ttl=self.config.cache.memory_ttl,
-                )
-                return mem
-        except Exception as exc:
-            logger.warning("Postgres get_memory failed for %s: %s", memory_id, exc)
-
-        # 3) Mem0 (best-effort)
-        if self._mem0_client:
-            for method_name in ("get_memory", "get"):
-                try:
-                    result = await self._mem0_call(
-                        method_name,
-                        memory_id=memory_id,
-                    )
-                    if not result:
-                        continue
-                    metadata = result.get("metadata", {}) or {}
-                    mem = Memory(
-                        memory_id=result.get("id", memory_id),
-                        content=result.get("memory", result.get("content", "")),
-                        category=metadata.get("category", "general"),
-                        importance=metadata.get("importance", "medium"),
-                        session_id=metadata.get("session_id", "unknown"),
-                        user_id=metadata.get("user_id") or result.get("user_id"),
-                        team_id=metadata.get("team_id"),
-                        conversation_id=metadata.get("conversation_id"),
-                        metadata=metadata,
-                        created_at=metadata.get("created_at")
-                        or result.get("created_at", datetime.now(UTC)),
-                        updated_at=metadata.get("updated_at")
-                        or result.get("updated_at", datetime.now(UTC)),
-                        relations=result.get("relations", []),
-                        storage_tier=metadata.get("storage_tier", StorageTier.MEM0_PRO.value),
-                    )
-                    await self._redis_service.set_json(
-                        payload_key,
-                        mem.model_dump(mode="json"),
-                        ttl=self.config.cache.memory_ttl,
-                    )
-                    return mem
-                except Exception as exc:
-                    logger.debug("Mem0 get failed via %s: %s", method_name, exc)
-        return None
-
-    async def update_memory(self, request: MemoryUpdateRequest) -> Memory:
-        """Update memory content/metadata and propagate to Mem0 + caches."""
-        now = datetime.now(UTC)
-        updates: dict[str, Any] = {}
-        metadata_patch = request.metadata or {}
-
-        existing = await database_service.get_memory(request.memory_id)
-        if not existing:
-            raise NotFoundError(f"Memory not found: {request.memory_id}")
-        base_metadata = existing.metadata if existing else {}
-        merged_metadata = {**base_metadata, **metadata_patch}
-
-        if request.content:
-            updates["content"] = request.content
-        if request.category:
-            updates["category"] = (
-                request.category.value if hasattr(request.category, "value") else request.category
-            )
-            merged_metadata.setdefault("category", updates["category"])
-        if request.importance:
-            updates["importance"] = (
-                request.importance.value
-                if hasattr(request.importance, "value")
-                else request.importance
-            )
-            merged_metadata.setdefault("importance", updates["importance"])
-        if request.tags:
-            merged_metadata["tags"] = request.tags
-        if request.conversation_id:
-            merged_metadata["conversation_id"] = request.conversation_id
-        if request.ttl_minutes:
-            expires_at = now + timedelta(minutes=int(request.ttl_minutes))
-            merged_metadata["expires_at"] = expires_at.isoformat()
-            updates["expires_at"] = expires_at
-        if request.session_id:
-            updates["session_id"] = request.session_id
-        if request.user_id:
-            updates["user_id"] = request.user_id
-        if request.team_id:
-            updates["team_id"] = request.team_id
-
-        updates["metadata"] = merged_metadata
-
-        # Postgres canonical update
-        try:
-            async with database_service.postgres.engine.begin() as conn:
-                await database_service.update_memory(
-                    conn,
-                    request.memory_id,
-                    updates,
-                    expected_current_version_number=request.expected_current_version_number,
-                )
-        except MemoryRevisionConflictError:
-            raise
-        except ValueError as exc:
-            if "not found for update" in str(exc):
-                raise NotFoundError(f"Memory not found: {request.memory_id}") from exc
-            raise
-        except Exception as exc:
-            logger.warning("Postgres update_memory failed for %s: %s", request.memory_id, exc)
-            raise
-
-        # Mem0 update (best-effort)
-        if self._mem0_client:
-            mem0_kwargs = {
-                "memory_id": request.memory_id,
-                "text": request.content,
-                "metadata": merged_metadata,
-            }
-            try:
-                await self._mem0_call("update", **mem0_kwargs)
-            except Exception as exc:
-                logger.debug("Mem0 update failed via update: %s", exc)
-                with contextlib.suppress(Exception):
-                    await self._mem0_call("update_memory", **mem0_kwargs)
-
-        # Redis cache refresh (best effort)
-        try:
-            async with redis_manager.get_redis(REDIS_MEMORY_CACHE_DB) as conn:
-                await conn.delete(f"memory:{request.memory_id}:payload")
-        except Exception:
-            logger.debug("Redis cache delete failed for %s", request.memory_id)
-
-        with contextlib.suppress(Exception):
-            await self._redis_service.invalidate_search_scope(
-                org_id=self._derive_org_id(merged_metadata),
-                user_id=request.user_id or getattr(existing, "user_id", None),
-                session_id=request.session_id or getattr(existing, "session_id", None),
-            )
-            await self._invalidate_semantic_cache(
-                request.user_id or getattr(existing, "user_id", None)
-            )
-
-        refreshed = await self.get_memory(request.memory_id)
-        if refreshed:
-            return refreshed
-        canonical = await database_service.get_memory(request.memory_id)
-        if canonical:
-            return canonical
-        raise NotFoundError(f"Memory not found after update: {request.memory_id}")
-
-    async def delete_memory(self, request: MemoryDeleteRequest) -> bool:
-        """Delete a memory across Mem0, Postgres, pgvector mirror, Redis."""
-        memory_id = request.memory_id
-        mem0_id: str | None = None
-        mem_user_id: str | None = None
-        mem_session_id: str | None = None
-        mem_metadata: dict[str, Any] | None = None
-        found = False
-        # Capture Mem0 ID before deleting the canonical record (best-effort).
-        try:
-            mem_record = await database_service.get_memory(memory_id)
-            if mem_record:
-                mem_user_id = getattr(mem_record, "user_id", None)
-                mem_session_id = getattr(mem_record, "session_id", None)
-            metadata = getattr(mem_record, "metadata_dict", None) or getattr(
-                mem_record, "metadata", {}
-            )
-            if isinstance(metadata, str):
-                try:
-                    metadata = json.loads(metadata)
-                except Exception:
-                    metadata = {}
-            if isinstance(metadata, dict):
-                mem0_id = metadata.get("mem0_id")
-                mem_metadata = metadata
-        except Exception as exc:
-            logger.debug("Mem0 metadata lookup failed for %s: %s", memory_id, exc)
-        # Postgres delete or soft-delete
-        try:
-            if request.hard_delete:
-                async with database_service.postgres.engine.begin() as conn:
-                    await conn.execute(
-                        text("DELETE FROM memories WHERE memory_id = :memory_id"),
-                        {"memory_id": memory_id},
-                    )
-            else:
-                async with database_service.postgres.engine.begin() as conn:
-                    await database_service.update_memory(
-                        conn, memory_id, {"status": MemoryStatus.DELETED.value}
-                    )
-            found = True
-        except Exception as exc:
-            logger.warning("Postgres delete failed for %s: %s", memory_id, exc)
-
-        # Mem0 delete (best effort)
-        if self._mem0_client:
-            delete_ids = [mem0_id, memory_id] if mem0_id and mem0_id != memory_id else [memory_id]
-            mem0_deleted = False
-            for delete_id in delete_ids:
-                for method_name in ("delete", "delete_memory"):
-                    try:
-                        await self._mem0_call(method_name, memory_id=delete_id)
-                        mem0_deleted = True
-                        break
-                    except Exception as exc:
-                        logger.debug("Mem0 %s failed for %s: %s", method_name, delete_id, exc)
-                if mem0_deleted:
-                    break
-
-        # Redis cleanup
-        with contextlib.suppress(Exception):
-            await self._redis_service.delete(f"memory:{memory_id}:payload")
-            await self._redis_service.delete(f"mem0:push:{memory_id}")
-        with contextlib.suppress(Exception):
-            await self._redis_service.invalidate_search_scope(
-                org_id=self._derive_org_id(mem_metadata or {}),
-                user_id=mem_user_id,
-                session_id=mem_session_id,
-            )
-            await self._invalidate_semantic_cache(mem_user_id)
-
-        return found
-
-    async def batch_create_memories(self, request: MemoryBatchCreateRequest) -> dict[str, Any]:
-        """Batch create memories using parallel async writes."""
-        max_concurrency = min(10, len(request.memories))
-        semaphore = asyncio.Semaphore(max_concurrency)
-
-        async def _create(index: int, payload: MemoryCreateRequest) -> dict[str, Any]:
-            async with semaphore:
-                try:
-                    memory_id = await self.create_memory(payload)
-                    return {
-                        "index": index,
-                        "memory_id": memory_id,
-                        "status": "created",
-                    }
-                except Exception as exc:
-                    logger.warning("Batch create failed for index %s: %s", index, exc)
-                    return {
-                        "index": index,
-                        "status": "error",
-                        "error": str(exc),
-                    }
-
-        tasks = [
-            asyncio.create_task(_create(index, payload))
-            for index, payload in enumerate(request.memories)
-        ]
-        results = await asyncio.gather(*tasks)
-        created = sum(1 for result in results if result.get("status") == "created")
-        return {
-            "results": results,
-            "created": created,
-            "failed": len(results) - created,
-        }
-
-    async def batch_update_memories(self, request: MemoryBatchUpdateRequest) -> dict[str, Any]:
-        """Batch update memories; forwards to Mem0 where supported."""
-        results: list[dict[str, Any]] = []
-        for upd in request.updates:
-            try:
-                await self.update_memory(upd)
-                results.append({"memory_id": upd.memory_id, "status": "updated"})
-            except Exception as exc:
-                logger.warning("Batch update failed for %s: %s", upd.memory_id, exc)
-                results.append({"memory_id": upd.memory_id, "status": "error", "error": str(exc)})
-
-        if self._mem0_client:
-            try:
-                mem0_updates = [
-                    {
-                        "id": upd.memory_id,
-                        "text": upd.content,
-                        "metadata": (upd.metadata or {}),
-                    }
-                    for upd in request.updates
-                ]
-                await self._mem0_call(
-                    "batch_update",
-                    updates=mem0_updates,
-                    upsert=bool(request.upsert),
-                )
-            except Exception as exc:
-                logger.debug("Mem0 batch_update failed: %s", exc)
-
-        return {"results": results}
-
-    async def batch_delete_memories(self, request: MemoryBatchDeleteRequest) -> int:
-        """Batch delete by IDs or filters."""
-        deleted = 0
-        ids = request.memory_ids or []
-        if ids:
-            for mem_id in ids:
-                if await self.delete_memory(
-                    MemoryDeleteRequest(memory_id=mem_id, hard_delete=False)
-                ):
-                    deleted += 1
-        deleted += await self.delete_memories_by_filter(request)
-        return deleted
-
-    async def delete_memories_by_filter(self, request: MemoryBatchDeleteRequest) -> int:
-        """Delete memories matching filter criteria."""
-        clauses = []
-        params: dict[str, Any] = {}
-        if request.user_id:
-            clauses.append("user_id = :user_id")
-            params["user_id"] = request.user_id
-        if request.session_id:
-            clauses.append("session_id = :session_id")
-            params["session_id"] = request.session_id
-        if request.conversation_id:
-            clauses.append("metadata->>'conversation_id' = :conversation_id")
-            params["conversation_id"] = request.conversation_id
-        if request.project_domain:
-            clauses.append("metadata->>'project_domain' = :project_domain")
-            params["project_domain"] = getattr(
-                request.project_domain, "value", request.project_domain
-            )
-        if request.category:
-            clauses.append("category = :category")
-            params["category"] = getattr(request.category, "value", request.category)
-        if request.importance:
-            clauses.append("importance = :importance")
-            params["importance"] = getattr(request.importance, "value", request.importance)
-        if not clauses:
-            logger.warning("delete_memories_by_filter called without filters; skipping")
-            return 0
-        where_sql = " AND ".join(clauses)
-        rows = 0
-        try:
-            async with database_service.postgres.engine.begin() as conn:
-                result = await conn.execute(
-                    text(f"DELETE FROM memories WHERE {where_sql}"),
-                    params,
-                )
-                rows = result.rowcount or 0
-        except Exception as exc:
-            logger.warning("Filter delete failed: %s", exc)
-
-        # Mem0 delete by filters (best-effort)
-        if self._mem0_client and clauses:
-            filters = {}
-            if request.user_id:
-                filters["user_id"] = request.user_id
-            meta_filters = {}
-            if request.session_id:
-                meta_filters["session_id"] = request.session_id
-            if request.conversation_id:
-                meta_filters["conversation_id"] = request.conversation_id
-            if request.project_domain:
-                meta_filters["project_domain"] = (
-                    request.project_domain.value
-                    if hasattr(request.project_domain, "value")
-                    else str(request.project_domain)
-                )
-            if request.category:
-                meta_filters["category"] = (
-                    request.category.value
-                    if hasattr(request.category, "value")
-                    else str(request.category)
-                )
-            if request.importance:
-                meta_filters["importance"] = (
-                    request.importance.value
-                    if hasattr(request.importance, "value")
-                    else str(request.importance)
-                )
-            if meta_filters:
-                filters["metadata"] = meta_filters
-            if request.tags:
-                filters["keywords"] = {"in": request.tags}
-            # Guardrail: require at least one filter before batch_delete
-            if not filters:
-                logger.debug("Skipping Mem0 batch_delete: no filters supplied")
-            else:
-                try:
-                    await self._mem0_call("batch_delete", filters=filters or None)
-                except Exception as exc:
-                    logger.debug("Mem0 batch_delete failed: %s", exc)
-
-        # Cache purge (best-effort wildcard delete per session/user)
-        if request.session_id:
-            with contextlib.suppress(Exception):
-                await self._redis_service.delete(f"session:{request.session_id}:memories:ids")
-        return rows
-
-    # Mem0 admin/ops helpers
-
-    async def create_memory_export(self, *args, **kwargs):
-        """Moved to MemoryAdminService (VAMI-008 TSK-8.07)."""
-        raise NotImplementedError(
-            "create_memory_export has been moved to MemoryAdminService."
-            " Access it via the facade or MemoryAdminService directly."
-        )
-
-    async def get_memory_export(self, *args, **kwargs):
-        """Moved to MemoryAdminService (VAMI-008 TSK-8.07)."""
-        raise NotImplementedError(
-            "get_memory_export has been moved to MemoryAdminService."
-            " Access it via the facade or MemoryAdminService directly."
-        )
-
-    async def get_memory_history(self, *args, **kwargs):
-        """Moved to MemoryAdminService (VAMI-008 TSK-8.07)."""
-        raise NotImplementedError(
-            "get_memory_history has been moved to MemoryAdminService."
-            " Access it via the facade or MemoryAdminService directly."
-        )
-
-    async def submit_memory_feedback(self, *args, **kwargs):
-        """Moved to MemoryAdminService (VAMI-008 TSK-8.07)."""
-        raise NotImplementedError(
-            "submit_memory_feedback has been moved to MemoryAdminService."
-            " Access it via the facade or MemoryAdminService directly."
-        )