@ngocsangairvds/vsaf 3.2.16 → 4.0.1

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

@@ -1,17 +0,0 @@
-"""Memory evolution instrumentation helpers."""
-
-from .config_loader import MemoryEvolutionSettings, load_evolution_settings
-from .tracker import MemoryEvolutionTracker, memory_evolution_tracker
-
-try:
-    from .processor import MemoryEvolutionProcessor
-except ImportError:
-    MemoryEvolutionProcessor = None  # type: ignore[assignment,misc]
-
-__all__ = [
-    "MemoryEvolutionSettings",
-    "load_evolution_settings",
-    "MemoryEvolutionTracker",
-    "memory_evolution_tracker",
-    "MemoryEvolutionProcessor",
-]

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

@@ -1,70 +0,0 @@
-"""Central Celery application for memory evolution workers."""
-
-from __future__ import annotations
-
-from celery import Celery
-from kombu import Queue
-
-from vds_memory_orchestrator.service.core.config import get_config
-
-DEFAULT_QUEUE_NAME = "memory_evolution.default"
-CONSOLIDATION_QUEUE_NAME = "memory_evolution.consolidation"
-
-
-def _create_celery_app() -> Celery:
-    settings = get_config()
-    app = Celery(
-        "memory_evolution",
-        broker=settings.celery_broker_url,
-        backend=settings.celery_broker_url,  # ADR-INF-5: Explicit Celery DB assignment
-    )
-    app.conf.update(
-        {
-            "task_serializer": "json",
-            "result_serializer": "json",
-            "accept_content": ["json"],
-            "timezone": "UTC",
-            "enable_utc": True,
-            "task_track_started": True,
-            "task_acks_late": True,
-            "worker_prefetch_multiplier": 1,
-            "task_default_queue": DEFAULT_QUEUE_NAME,
-            "task_default_exchange": DEFAULT_QUEUE_NAME,
-            "task_default_routing_key": DEFAULT_QUEUE_NAME,
-            # Route child-process print() calls as INFO instead of default WARNING.
-            # This avoids flooding alert channels with non-actionable noise from
-            # third-party libraries that print to stdout.
-            "worker_redirect_stdouts_level": "INFO",
-        }
-    )
-
-    app.conf.task_queues = (
-        Queue(DEFAULT_QUEUE_NAME, routing_key=DEFAULT_QUEUE_NAME),
-        Queue(CONSOLIDATION_QUEUE_NAME, routing_key=CONSOLIDATION_QUEUE_NAME),
-    )
-    app.conf.task_routes = {
-        "memory_evolution.process_memory_evolution_events": {"queue": DEFAULT_QUEUE_NAME},
-        "memory_evolution.run_consolidation_job": {"queue": CONSOLIDATION_QUEUE_NAME},
-        "memory_evolution.run_sweep": {"queue": DEFAULT_QUEUE_NAME},
-        "memory_evolution.replay_dlq": {"queue": DEFAULT_QUEUE_NAME},
-        "mem0.push_memory": {"queue": DEFAULT_QUEUE_NAME},
-        "mem0.resolve_pending_ids": {"queue": DEFAULT_QUEUE_NAME},
-        "mem0.repush_stalled": {"queue": DEFAULT_QUEUE_NAME},
-        "mem0.repush_local_only": {"queue": DEFAULT_QUEUE_NAME},
-    }
-
-    # ADR-14 retirement executed 2026-04-24: all 6 Celery Beat entries removed.
-    # Periodic scheduling is now owned exclusively by scheduler_orchestrator
-    # DBOS workflows (TSK-12.1..12.6 DBOS counterparts).
-    # The beat container is removed from compose.yaml in the same commit.
-
-    return app
-
-
-celery_app = _create_celery_app()
-
-__all__ = [
-    "celery_app",
-    "DEFAULT_QUEUE_NAME",
-    "CONSOLIDATION_QUEUE_NAME",
-]

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

@@ -1,15 +0,0 @@
-"""Celery entrypoint that breaks circular import by importing in correct order.
-
-This module is used by compose.yaml to start Celery worker/beat.
-It imports tasks without triggering the circular import between:
-- celery_app -> worker -> processor -> celery_app
-
-The solution is to import only what's needed, and let Python handle
-the lazy import when tasks are actually called.
-"""
-
-# Explicitly import worker module to register all tasks
-# This happens AFTER celery_app is fully initialized, avoiding circular import
-from vds_memory_orchestrator.service.services.memory_evolution.celery_app import celery_app
-
-__all__ = ["celery_app"]

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

@@ -1,275 +0,0 @@
-"""Configuration loader for memory evolution instrumentation."""
-
-from __future__ import annotations
-
-import logging
-import tomllib
-from collections.abc import Iterable
-from dataclasses import dataclass, field
-from pathlib import Path
-from typing import Any
-
-import toml as toml_lib
-
-logger = logging.getLogger(__name__)
-
-
-DEFAULT_CONFIG_PATH = Path(__file__).resolve().parents[3] / "config" / "memory_evolution.toml"
-
-
-IMPORTANCE_ORDER = ["low", "medium", "high", "critical"]
-
-
-@dataclass(slots=True)
-class MemoryEvolutionSettings:
-    """Declarative settings controlling memory evolution instrumentation."""
-
-    enabled: bool = False
-    shadow_mode: bool = True
-    pilot_shadow_override: bool = False
-    log_payload_samples: int = 25
-    pilot_orgs: frozenset[str] = field(default_factory=frozenset)
-    max_consolidations_per_session: int = 10
-    max_events_per_session: int = 250
-    log_sample_rate: float = 1.0
-    min_importance: str = "medium"
-    tracked_events: frozenset[str] = field(
-        default_factory=lambda: frozenset(
-            {
-                "session_created",
-                "session_closed",
-                "memory_created",
-                "session_consolidated",
-                "dedup_requested",
-                "feedback_received",
-            }
-        )
-    )
-    metadata: dict[str, Any] = field(default_factory=dict)
-    cross_org_policies: dict[str, frozenset[str]] = field(default_factory=dict)
-
-    def should_log_event(self, event_type: str) -> bool:
-        return event_type in self.tracked_events
-
-    def importance_allowed(self, importance: str | None) -> bool:
-        if not importance:
-            return True
-        importance = importance.lower()
-        if importance not in IMPORTANCE_ORDER:
-            return True
-        try:
-            threshold_idx = IMPORTANCE_ORDER.index(self.min_importance.lower())
-        except ValueError:
-            threshold_idx = IMPORTANCE_ORDER.index("medium")
-        return IMPORTANCE_ORDER.index(importance) >= threshold_idx
-
-    def is_cross_org_allowed(self, source_org: str | None, target_org: str | None) -> bool:
-        if not target_org or not source_org:
-            return True
-        source_org = source_org.lower()
-        target_org = target_org.lower()
-        allowed = self.cross_org_policies.get(source_org)
-        if not allowed:
-            return False
-        return target_org in allowed
-
-    def is_pilot_org(self, org_id: str | None) -> bool:
-        """Check if an org is enrolled in the evolution pilot.
-
-        Wildcard " *" matches ALL orgs (graduation from explicit list to production).
-        """
-        if not org_id:
-            return False
-        org_id = str(org_id).strip()
-        if not org_id:
-            return False
-        # Wildcard = all orgs are pilot orgs
-        if "*" in self.pilot_orgs:
-            return True
-        return org_id in self.pilot_orgs
-
-
-def _ensure_iterable(value: Any) -> Iterable[str]:
-    if isinstance(value, (list, tuple, set, frozenset)):
-        return value
-    if isinstance(value, str):
-        return [value]
-    return []
-
-
-def load_evolution_settings(
-    config_path: Path | None = None,
-) -> MemoryEvolutionSettings:
-    """Load settings from TOML with defensive defaults."""
-
-    base = MemoryEvolutionSettings()
-    target = config_path or DEFAULT_CONFIG_PATH
-    if not target.exists():
-        logger.info("memory_evolution.toml not found at %s; using defaults", target)
-        return base
-
-    try:
-        with target.open("rb") as handle:
-            data = tomllib.load(handle)
-    except Exception as exc:  # pragma: no cover - defensive guardrail
-        logger.warning("Failed to parse %s: %s", target, exc)
-        return base
-
-    flags = data.get("flags", {}) or {}
-    sampling = data.get("event_sampling", {}) or {}
-    triggers = data.get("event_triggers", {}) or {}
-    policies = data.get("policies", {}) or {}
-
-    tracked_events = {
-        name for name, enabled in triggers.items() if isinstance(enabled, bool) and enabled
-    } or set(base.tracked_events)
-
-    raw_pilot_orgs = flags.get("pilot_orgs", [])
-    iterable = [raw_pilot_orgs] if isinstance(raw_pilot_orgs, str) else _ensure_iterable(raw_pilot_orgs)
-    pilot_orgs = frozenset(
-        str(org).strip() for org in iterable if isinstance(org, str) and str(org).strip()
-    )
-
-    # Clamp numeric values to safe ranges
-    max_events = int(sampling.get("max_events_per_session", base.max_events_per_session))
-    max_events = max(max_events, 0)
-
-    sample_rate = float(sampling.get("log_sample_rate", base.log_sample_rate))
-    sample_rate = max(0.0, min(1.0, sample_rate))
-
-    min_importance = str(sampling.get("min_importance", base.min_importance)).lower()
-    if min_importance not in IMPORTANCE_ORDER:
-        min_importance = base.min_importance
-
-    log_payload_samples = int(
-        flags.get("log_payload_samples", base.log_payload_samples) or base.log_payload_samples
-    )
-    if log_payload_samples < 0:
-        log_payload_samples = base.log_payload_samples
-
-    max_consolidations = int(
-        flags.get("max_consolidations_per_session", base.max_consolidations_per_session)
-    )
-    max_consolidations = max(1, min(1000, max_consolidations))
-
-    enabled_flag = bool(flags.get("enabled", base.enabled))
-    shadow_flag = bool(flags.get("shadow_mode", base.shadow_mode))
-
-    cross_org_sharing_raw = policies.get("cross_org_sharing", {}) or {}
-    cross_org_policies: dict[str, frozenset[str]] = {}
-    for source, targets in cross_org_sharing_raw.items():
-        source_key = str(source).strip().lower()
-        if not source_key:
-            continue
-        target_iterable = _ensure_iterable(targets)
-        normalized_targets = {
-            str(target).strip().lower()
-            for target in target_iterable
-            if isinstance(target, str) and str(target).strip()
-        }
-        if normalized_targets:
-            cross_org_policies[source_key] = frozenset(normalized_targets)
-
-    metadata = {
-        "config_path": str(target),
-        "raw_flags": flags,
-        "raw_policies": policies,
-    }
-
-    try:  # pragma: no cover - avoids heavy config wiring in small unit tests
-        from vds_memory_orchestrator.service.core.config import get_config
-
-        service_cfg = get_config().service
-        override_pilots = getattr(service_cfg, "memory_evolution_pilot_orgs", []) or []
-        if override_pilots:
-            pilot_orgs = frozenset(str(org).strip() for org in override_pilots if str(org).strip())
-        enabled_override = getattr(service_cfg, "memory_evolution_enabled_override", None)
-        if enabled_override is not None:
-            enabled_flag = bool(enabled_override)
-        shadow_override = getattr(service_cfg, "memory_evolution_shadow_mode_override", None)
-        if shadow_override is not None:
-            shadow_flag = bool(shadow_override)
-    except Exception as exc:  # pragma: no cover - defensive guardrail
-        logger.debug("Memory evolution overrides unavailable: %s", exc)
-
-    return MemoryEvolutionSettings(
-        enabled=enabled_flag,
-        shadow_mode=shadow_flag,
-        pilot_shadow_override=bool(flags.get("pilot_shadow_override", base.pilot_shadow_override)),
-        log_payload_samples=log_payload_samples,
-        pilot_orgs=pilot_orgs,
-        max_consolidations_per_session=max_consolidations,
-        max_events_per_session=max_events,
-        log_sample_rate=sample_rate,
-        min_importance=min_importance,
-        tracked_events=frozenset(tracked_events),
-        metadata=metadata,
-        cross_org_policies=cross_org_policies,
-    )
-
-
-# ---------------------------------------------------------------------------
-# TOML write helpers for shadow-soak promotion (Phase 232 FR-232.4)
-# ---------------------------------------------------------------------------
-
-
-def _get_toml_path() -> Path:
-    """Return the memory_evolution.toml path, checking env override first."""
-    env_path = Path(__file__).resolve().parents[3] / "config" / "memory_evolution.toml"
-    return env_path
-
-
-def write_evolution_config(
-    shadow_mode: bool | None = None,
-    pilot_orgs: list[str] | None = None,
-) -> dict[str, Any]:
-    """Write runtime changes to memory_evolution.toml.
-
-    Only writes keys that are explicitly provided (partial update).
-    Raises OSError if the file cannot be written.
-
-    Returns:
-        dict with 'written': True/False and keys changed.
-    """
-    toml_path = _get_toml_path()
-    if not toml_path.exists():
-        raise FileNotFoundError(f"memory_evolution.toml not found at {toml_path}")
-
-    try:
-        raw = toml_path.read_text(encoding="utf-8")
-    except OSError as exc:
-        raise OSError(f"Cannot read {toml_path}: {exc}") from exc
-
-    try:
-        data = toml_lib.loads(raw)
-    except Exception as exc:
-        raise OSError(f"Cannot parse {toml_path}: {exc}") from exc
-
-    flags = data.setdefault("flags", {})
-    changed: list[str] = []
-
-    if shadow_mode is not None:
-        old = flags.get("shadow_mode")
-        if old != shadow_mode:
-            flags["shadow_mode"] = shadow_mode
-            changed.append("shadow_mode")
-
-    if pilot_orgs is not None:
-        old = flags.get("pilot_orgs", [])
-        if old != pilot_orgs:
-            flags["pilot_orgs"] = pilot_orgs
-            changed.append("pilot_orgs")
-
-    if not changed:
-        logger.debug("No TOML changes needed")
-        return {"written": False, "changed": [], "path": str(toml_path)}
-
-    try:
-        new_raw = toml_lib.dumps(data)
-        toml_path.write_text(new_raw, encoding="utf-8")
-        logger.info("Written to %s: %s", toml_path, changed)
-    except OSError as exc:
-        raise OSError(f"Cannot write {toml_path}: {exc}") from exc
-
-    return {"written": True, "changed": changed, "path": str(toml_path)}
-

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

@@ -1,309 +0,0 @@
-"""Stage 3 consolidation executor."""
-
-from __future__ import annotations
-
-import logging
-from collections.abc import Iterable
-from dataclasses import dataclass, field
-from typing import Any
-from uuid import UUID
-
-from pydantic import BaseModel, Field
-from sqlalchemy import select
-
-from vds_memory_orchestrator.service.database.postgres_manager import DatabaseService
-from vds_memory_orchestrator.service.models.database import MemoryEvolutionAction, MemoryRecord
-from vds_memory_orchestrator.service.services.embedding_service import embedding_service
-
-try:
-# from vds_agent_core.config import LLMRuntimeConfig
-
-    from vds_memory_orchestrator.agents import agents_enabled
-    from vds_memory_orchestrator.agents.consolidation import (
-        ConsolidationAnalysis,
-        make_consolidation_agent,
-    )
-
-    _AGENTS_IMPORTABLE = True
-except ImportError:
-    _AGENTS_IMPORTABLE = False
-
-logger = logging.getLogger(__name__)
-
-
-class ConsolidationJob(BaseModel):
-    """Payload describing a consolidation request."""
-
-    event_id: str | None = None
-    memory_id: str
-    user_id: str
-    metadata: dict[str, Any] = Field(default_factory=dict)
-    rate_limit_allowed: bool = True
-
-
-@dataclass(slots=True)
-class ConsolidationDecision:
-    action: str
-    reason: str
-    confidence: float
-    conflict_memory_ids: list[str] = field(default_factory=list)
-
-
-@dataclass(slots=True)
-class NeighborMemory:
-    memory_id: str
-    user_id: str
-    content: str
-    importance: str = "medium"
-
-
-class MemoryConsolidationExecutor:
-    """Evaluates recently stored memories and records consolidation actions."""
-
-    def __init__(
-        self,
-        db_service: DatabaseService | None = None,
-        llm_config: Any | None = None,
-    ) -> None:
-        self._db_override = db_service
-        self._db: DatabaseService | None = None
-        self._llm_config = llm_config
-
-    async def process(
-        self, job: ConsolidationJob, db_service: DatabaseService | None = None
-    ) -> dict[str, Any]:
-        """Entry point used by services or Celery tasks."""
-
-        db = db_service or await self._get_db_service()
-        memory = await db.get_memory(job.memory_id)
-        if not memory:
-            raise ValueError(f"Memory {job.memory_id} not found for consolidation")
-
-        similar = await self._fetch_similar_memories(db, memory, limit=5, metadata=job.metadata)
-        decision = await self._evaluate_decision(memory, similar, job.metadata)
-        await self._record_action(db, job, decision, similar)
-        logger.debug(
-            "Consolidation job for memory %s evaluated action=%s conflicts=%s",
-            job.memory_id,
-            decision.action,
-            decision.conflict_memory_ids,
-        )
-        return {
-            "action": decision.action,
-            "reason": decision.reason,
-            "confidence": round(decision.confidence, 3),
-            "conflict_ids": decision.conflict_memory_ids,
-        }
-
-    async def _fetch_similar_memories(
-        self,
-        db: DatabaseService,
-        memory: MemoryRecord,
-        limit: int,
-        metadata: dict[str, Any],
-    ) -> list[NeighborMemory]:
-        neighbors: list[NeighborMemory] = []
-        vector = await self._resolve_embedding_vector(memory, metadata)
-
-        if vector:
-            try:
-                vector_results = await db.postgres.vector_search(
-                    query_embedding=vector,
-                    user_id=memory.user_id,
-                    team_id=getattr(memory, "team_id", None),
-                    limit=limit,
-                    similarity_threshold=0.75,
-                    search_type="knowledge_documents",
-                    query_text=memory.content,
-                )
-                for result in vector_results:
-                    meta = result.get("metadata") or {}
-                    candidate_id = meta.get("memory_id") or str(result.get("id"))
-                    if candidate_id == memory.memory_id:
-                        continue
-                    neighbors.append(
-                        NeighborMemory(
-                            memory_id=candidate_id,
-                            user_id=meta.get("user_id") or memory.user_id,
-                            content=result.get("content") or "",
-                            importance=str(meta.get("importance") or "medium"),
-                        )
-                    )
-            except Exception as exc:  # pragma: no cover - optional dependency
-                logger.debug("Vector search unavailable, falling back to recency: %s", exc)
-
-        if len(neighbors) >= limit:
-            return neighbors[:limit]
-
-        async with db.get_session() as session:
-            stmt = (
-                select(MemoryRecord)
-                .where(
-                    MemoryRecord.user_id == memory.user_id,
-                    MemoryRecord.memory_id != memory.memory_id,
-                    MemoryRecord.status == "active",
-                )
-                .order_by(MemoryRecord.updated_at.desc())
-                .limit(max(limit - len(neighbors), 0))
-            )
-            result = await session.execute(stmt)
-            for record in result.scalars().all():
-                neighbors.append(
-                    NeighborMemory(
-                        memory_id=record.memory_id,
-                        user_id=record.user_id,
-                        content=record.content,
-                        importance=record.importance,
-                    )
-                )
-
-        return neighbors
-
-    async def _evaluate_decision(
-        self,
-        memory: MemoryRecord,
-        candidates: Iterable[NeighborMemory],
-        metadata: dict[str, Any] | None,
-    ) -> ConsolidationDecision:
-        """Evaluate consolidation decision, using LLM agent when available."""
-        # Agent-powered path: richer conflict detection via LLM
-        if _AGENTS_IMPORTABLE and self._llm_config is not None and agents_enabled(self._llm_config):
-            try:
-                candidate_list = list(candidates)
-                agent = make_consolidation_agent(self._llm_config)
-                prompt = (
-                    f"Memory to consolidate:\n{memory.content}\n\n"
-                    f"Existing memories:\n"
-                    + "\n".join(f"- [{c.memory_id}] {c.content}" for c in candidate_list)
-                )
-                result = await agent.run(prompt)
-                analysis: ConsolidationAnalysis = result.output
-                action = (
-                    "merge"
-                    if analysis.conflict_memory_ids or analysis.duplicate_memory_ids
-                    else "noop"
-                )
-                conflict_ids = analysis.conflict_memory_ids + analysis.duplicate_memory_ids
-                return ConsolidationDecision(
-                    action=action,
-                    reason=analysis.summary,
-                    confidence=analysis.confidence,
-                    conflict_memory_ids=conflict_ids,
-                )
-            except Exception as exc:
-                logger.debug("Agent-based consolidation failed, falling back to rules: %s", exc)
-
-        return self._evaluate_decision_rules(memory, candidates, metadata)
-
-    def _evaluate_decision_rules(
-        self,
-        memory: MemoryRecord,
-        candidates: Iterable[NeighborMemory],
-        metadata: dict[str, Any] | None,
-    ) -> ConsolidationDecision:
-        """Rule-based fallback consolidation decision."""
-        metadata = metadata or {}
-        normalized_content = self._normalize(memory.content)
-        candidate_list = list(candidates)
-        duplicate_ids = [
-            candidate.memory_id
-            for candidate in candidate_list
-            if self._normalize(candidate.content) == normalized_content and normalized_content
-        ]
-
-        if duplicate_ids:
-            return ConsolidationDecision(
-                action="merge",
-                reason="duplicate_content_detected",
-                confidence=0.9,
-                conflict_memory_ids=duplicate_ids,
-            )
-
-        importance = (metadata.get("importance") or getattr(memory, "importance", "") or "").lower()
-        if importance in {"high", "critical"} and candidate_list:
-            return ConsolidationDecision(
-                action="update",
-                reason="high_importance_memory_requires_consolidation",
-                confidence=0.75,
-                conflict_memory_ids=[candidate_list[0].memory_id],
-            )
-
-        if metadata.get("decision") == "dedup_only" and candidate_list:
-            first_candidate = candidate_list[0]
-            return ConsolidationDecision(
-                action="review",
-                reason="rule_engine_requested_dedup_only",
-                confidence=0.6,
-                conflict_memory_ids=[first_candidate.memory_id],
-            )
-
-        return ConsolidationDecision(
-            action="noop",
-            reason="no_similar_memories_detected",
-            confidence=0.2,
-        )
-
-    async def _record_action(
-        self,
-        db: DatabaseService,
-        job: ConsolidationJob,
-        decision: ConsolidationDecision,
-        neighbors: list[NeighborMemory],
-    ) -> None:
-        async with db.get_session() as session:
-            action = MemoryEvolutionAction(
-                event_id=self._safe_uuid(job.event_id),
-                memory_id=job.memory_id,
-                user_id=job.user_id,
-                action_type=decision.action,
-                confidence=decision.confidence,
-                reason=decision.reason,
-                metadata_dict={
-                    "input_metadata": job.metadata,
-                    "neighbor_ids": [neighbor.memory_id for neighbor in neighbors],
-                    "conflict_memory_ids": decision.conflict_memory_ids,
-                },
-            )
-            session.add(action)
-            await session.commit()
-
-    async def _resolve_embedding_vector(
-        self, memory: MemoryRecord, metadata: dict[str, Any]
-    ) -> list[float] | None:
-        vector = metadata.get("embedding_vector")
-        if isinstance(vector, list) and vector:
-            return vector
-        try:
-            return await embedding_service.generate_embedding(memory.content or "")
-        except Exception as exc:  # pragma: no cover - embedding fallback
-            logger.debug("Embedding generation failed: %s", exc)
-            return None
-
-    async def _get_db_service(self) -> DatabaseService:
-        if self._db_override is not None:
-            return self._db_override
-        if self._db is None:
-            self._db = DatabaseService()
-            await self._db.initialize()
-        return self._db
-
-    @staticmethod
-    def _normalize(content: str | None) -> str:
-        return (content or "").strip().lower()
-
-    @staticmethod
-    def _safe_uuid(value: str | None) -> UUID | None:
-        if not value:
-            return None
-        try:
-            return UUID(str(value))
-        except ValueError:
-            logger.debug("Invalid UUID provided for memory evolution action: %s", value)
-            return None
-
-
-async def run_consolidation_job(job: ConsolidationJob) -> dict[str, Any]:
-    """Convenience async helper used by future Celery tasks."""
-
-    executor = MemoryConsolidationExecutor()
-    return await executor.process(job)