kore-memory 3.0.2__tar.gz → 3.0.4__tar.gz

kore_memory-3.0.4/.dockerignore

@@ -0,0 +1,20 @@
+.git
+.venv
+.pytest_cache
+.ruff_cache
+__pycache__
+*.pyc
+data/
+logs/
+dist/
+.coverage
+.env
+.env.*
+tests/
+docs/
+sdk/
+scripts/
+examples/
+.github/
+*.md
+!README.md

{kore_memory-3.0.2 → kore_memory-3.0.4}/.github/workflows/ci.yml

@@ -144,7 +144,9 @@ jobs:
           python-version: "3.12"
 
       - name: Install tools
-        run: pip install bandit pip-audit -e ".[dev]"
+        run: |
+          pip install --upgrade pip
+          pip install bandit pip-audit -e ".[dev]"
 
       - name: Run bandit (SAST)
         run: bandit -r kore_memory/ -c pyproject.toml

{kore_memory-3.0.2 → kore_memory-3.0.4}/.gitignore

@@ -37,11 +37,13 @@ logs/
 .coverage
 htmlcov/
 
-# Piani di lavoro
-PLAN-*.md
-
-# Claude Code (local only)
+# Internal docs (local only)
 CLAUDE.md
+MIGRATION-*.md
+article-*.md
+docs/
+PLAN-*.md
+.openclaude-profile.json
 
 # SDK JS
 sdk/js/node_modules/

{kore_memory-3.0.2 → kore_memory-3.0.4}/CHANGELOG.md

@@ -11,6 +11,57 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ---
 
+## [3.0.4] - 2026-05-15
+
+### Theme: "CI Fixes"
+
+Bug-fix release for CI pipeline: lint errors and test failures on GitHub Actions.
+
+### Fixed
+
+- **Lint errors**: Fixed import sorting in `main.py`, `repository/__init__.py`, `repository/memory.py`
+- **Unused imports**: Removed `get_index` unused import in `repository/graph.py`
+- **Format errors**: Applied `ruff format` to 5 files (`cache.py`, `compressor.py`, `main.py`, `ranking.py`, `repository/memory.py`)
+- **Test failures**: Fixed `test_compressor.py` to use `pytest.importorskip("numpy")` for optional dependency
+
+### Changed
+
+- Version bumped to 3.0.4 across `pyproject.toml`, `config.py`, and `sdk/js/package.json`
+
+---
+
+## [3.0.3] - 2026-05-15
+
+### Theme: "Redis Caching Layer"
+
+Optional Redis caching for improved performance on repeated queries. Fully backward compatible — disabled by default.
+
+### Added — Caching
+
+- **Optional Redis cache layer** (`kore_memory/cache.py`): Lazy-loaded client, graceful degradation if Redis unavailable
+- **SearchCache**: Caches `/search` results (queries without cursor pagination)
+- **GraphCache**: Caches `/graph/traverse`, `/graph/subgraph`, `/graph/hubs` responses
+- **AnalyticsCache**: Caches `/analytics` endpoint
+- **Automatic invalidation**: Cache invalidated on save, delete, archive, restore, compress
+- **Configuration**: `KORE_REDIS_ENABLED`, `KORE_REDIS_HOST`, `KORE_REDIS_PORT`, `KORE_REDIS_PREFIX`, `KORE_REDIS_TTL`, `KORE_REDIS_SEARCH_TTL`, `KORE_REDIS_GRAPH_TTL`, `KORE_REDIS_ANALYTICS_TTL`
+
+### Changed
+
+- Search endpoint skips cache when cursor provided (preserves pagination correctness)
+- Archive/restore endpoints invalidate cache appropriately
+
+### Tests
+
+- 53 new tests in `tests/test_cache.py` (with and without Redis)
+- All 925 tests pass with Redis enabled
+
+### Technical
+
+- Pydantic model serialization in cache (handles nested models)
+- No hard dependency on redis-py (imported lazily)
+
+---
+
 ## [3.0.2] - 2026-04-28
 
 ### Theme: "Hardening & Bug Sweep"

kore_memory-3.0.4/Dockerfile

@@ -0,0 +1,33 @@
+FROM python:3.12-slim AS base
+
+LABEL maintainer="Auriti Labs <info@auritidesign.it>"
+LABEL org.opencontainers.image.source="https://github.com/Auriti-Labs/kore-memory"
+LABEL org.opencontainers.image.description="Kore Memory — the memory layer that thinks like a human"
+
+# Prevent Python from writing .pyc and enable unbuffered output
+ENV PYTHONDONTWRITEBYTECODE=1 \
+    PYTHONUNBUFFERED=1
+
+WORKDIR /app
+
+# Install only production deps first (cache layer)
+COPY pyproject.toml hatch_build.py README.md LICENSE ./
+COPY kore_memory/ kore_memory/
+COPY assets/ assets/
+
+RUN pip install --no-cache-dir ".[semantic,mcp,watcher]"
+
+# Runtime config
+ENV KORE_HOST=0.0.0.0 \
+    KORE_PORT=8765 \
+    KORE_LOCAL_ONLY=0 \
+    KORE_DB_PATH=/data/memory.db
+
+VOLUME /data
+EXPOSE 8765 8766
+
+HEALTHCHECK --interval=30s --timeout=5s --start-period=10s --retries=3 \
+    CMD python -c "import httpx; r=httpx.get('http://127.0.0.1:8765/health'); r.raise_for_status()"
+
+# Default: run REST API server
+CMD ["kore", "--host", "0.0.0.0", "--port", "8765"]

{kore_memory-3.0.2 → kore_memory-3.0.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kore-memory
-Version: 3.0.2
+Version: 3.0.4
 Summary: The memory layer that thinks like a human: remembers what matters, forgets what doesn't, and never calls home.
 Project-URL: Homepage, https://github.com/auriti-labs/kore-memory
 Project-URL: Documentation, https://auritidesign.it/docs
@@ -65,7 +65,7 @@ Remembers what matters. Forgets what doesn't. Never calls home.
 [![License: MIT](https://img.shields.io/badge/license-MIT-green?style=flat-square)](LICENSE)
 [![Zero Cloud](https://img.shields.io/badge/cloud-zero-orange?style=flat-square)]()
 [![Multilingual](https://img.shields.io/badge/languages-50%2B-purple?style=flat-square)]()
-[![Tests](https://img.shields.io/badge/tests-648-brightgreen?style=flat-square)]()
+[![Tests](https://img.shields.io/badge/tests-788-brightgreen?style=flat-square)]()
 [![Coverage](https://img.shields.io/badge/coverage-80%25-yellow?style=flat-square)]()
 
 <br/>
@@ -114,6 +114,8 @@ Every AI agent memory tool has the same problem: they remember everything foreve
 
 ## ✨ What's New in v3.0 — Cognitive Runtime
 
+> **v3.0.2** (2026-04-28) — Hardening release: 24 bug fixes including critical data integrity fix in compressor, auth bypass prevention behind reverse proxy, full pipeline parity for batch save, and 14 dashboard fixes. See [CHANGELOG.md](CHANGELOG.md).
+
 Wave 3 is complete. Kore Memory is now a full **Cognitive Runtime** for AI agents.
 
 | Feature | Since |
@@ -262,7 +264,7 @@ pip install 'kore-memory[semantic,mcp,watcher,nlp]'
 
 ```bash
 kore
-# → Kore Memory v3.0.0 running on http://localhost:8765
+# → Kore Memory v3.0.2 running on http://localhost:8765
 # → Dashboard: http://localhost:8765/dashboard
 # → API docs:  http://localhost:8765/docs
 ```
@@ -702,6 +704,7 @@ All configuration via environment variables. No config file needed.
 ## 🔐 Security
 
 - **API key** — auto-generated on first run, stored in `data/.api_key` (chmod 600). Override via `KORE_API_KEY`
+- **Reverse proxy detection** — when `X-Forwarded-For` or `X-Real-IP` headers are present, `LOCAL_ONLY` mode requires API key authentication (prevents auth bypass behind nginx/Caddy)
 - **Agent isolation** — all queries are scoped to `agent_id`. Agents cannot read each other's memories without explicit ACL grant
 - **Parameterized queries** — no SQL injection possible; all DB queries use placeholders
 - **Timing-safe comparison** — `secrets.compare_digest` for API key validation
@@ -737,7 +740,7 @@ All configuration via environment variables. No config file needed.
 
 **Wave 4 — In Planning**
 
-- [ ] Lifecycle Policy Engine (auto-archive rules, importance decay overrides)
+- [x] Lifecycle Policy Engine (auto-archive rules, importance decay overrides)
 - [ ] Ranking Profiles per-Agent (persistent custom weights)
 - [ ] Temporal Graph (relations with valid_from/to)
 - [ ] Explainable Graph Retrieval (graph_path in context package)
@@ -747,6 +750,33 @@ All configuration via environment variables. No config file needed.
 
 ---
 
+## 🐳 Docker
+
+```bash
+# Quick start
+docker compose up -d
+
+# Or build and run manually
+docker build -t kore-memory .
+docker run -d -p 8765:8765 -v kore-data:/data \
+  -e KORE_API_KEY=$(python3 -c "import secrets; print(secrets.token_urlsafe(32))") \
+  kore-memory
+```
+
+Dashboard at `http://localhost:8765/dashboard`, API docs at `http://localhost:8765/docs`.
+
+Set `KORE_API_KEY` for authentication (required when `KORE_LOCAL_ONLY=0`). Data persists in the `kore-data` volume.
+
+To also run the MCP HTTP server, override the command:
+
+```bash
+docker run -d -p 8766:8766 -v kore-data:/data \
+  -e KORE_MCP_TOKEN=your-token \
+  kore-memory kore-mcp --transport streamable-http --host 0.0.0.0
+```
+
+---
+
 ## 🛠️ Development
 
 ```bash
@@ -758,7 +788,7 @@ pip install -e ".[semantic,dev,mcp,watcher]"
 # Run server
 kore --reload
 
-# Run all 648 tests
+# Run all 788 tests
 pytest tests/ -v
 
 # Run with coverage

{kore_memory-3.0.2 → kore_memory-3.0.4}/README.md

@@ -16,7 +16,7 @@ Remembers what matters. Forgets what doesn't. Never calls home.
 [![License: MIT](https://img.shields.io/badge/license-MIT-green?style=flat-square)](LICENSE)
 [![Zero Cloud](https://img.shields.io/badge/cloud-zero-orange?style=flat-square)]()
 [![Multilingual](https://img.shields.io/badge/languages-50%2B-purple?style=flat-square)]()
-[![Tests](https://img.shields.io/badge/tests-648-brightgreen?style=flat-square)]()
+[![Tests](https://img.shields.io/badge/tests-788-brightgreen?style=flat-square)]()
 [![Coverage](https://img.shields.io/badge/coverage-80%25-yellow?style=flat-square)]()
 
 <br/>
@@ -65,6 +65,8 @@ Every AI agent memory tool has the same problem: they remember everything foreve
 
 ## ✨ What's New in v3.0 — Cognitive Runtime
 
+> **v3.0.2** (2026-04-28) — Hardening release: 24 bug fixes including critical data integrity fix in compressor, auth bypass prevention behind reverse proxy, full pipeline parity for batch save, and 14 dashboard fixes. See [CHANGELOG.md](CHANGELOG.md).
+
 Wave 3 is complete. Kore Memory is now a full **Cognitive Runtime** for AI agents.
 
 | Feature | Since |
@@ -213,7 +215,7 @@ pip install 'kore-memory[semantic,mcp,watcher,nlp]'
 
 ```bash
 kore
-# → Kore Memory v3.0.0 running on http://localhost:8765
+# → Kore Memory v3.0.2 running on http://localhost:8765
 # → Dashboard: http://localhost:8765/dashboard
 # → API docs:  http://localhost:8765/docs
 ```
@@ -653,6 +655,7 @@ All configuration via environment variables. No config file needed.
 ## 🔐 Security
 
 - **API key** — auto-generated on first run, stored in `data/.api_key` (chmod 600). Override via `KORE_API_KEY`
+- **Reverse proxy detection** — when `X-Forwarded-For` or `X-Real-IP` headers are present, `LOCAL_ONLY` mode requires API key authentication (prevents auth bypass behind nginx/Caddy)
 - **Agent isolation** — all queries are scoped to `agent_id`. Agents cannot read each other's memories without explicit ACL grant
 - **Parameterized queries** — no SQL injection possible; all DB queries use placeholders
 - **Timing-safe comparison** — `secrets.compare_digest` for API key validation
@@ -688,7 +691,7 @@ All configuration via environment variables. No config file needed.
 
 **Wave 4 — In Planning**
 
-- [ ] Lifecycle Policy Engine (auto-archive rules, importance decay overrides)
+- [x] Lifecycle Policy Engine (auto-archive rules, importance decay overrides)
 - [ ] Ranking Profiles per-Agent (persistent custom weights)
 - [ ] Temporal Graph (relations with valid_from/to)
 - [ ] Explainable Graph Retrieval (graph_path in context package)
@@ -698,6 +701,33 @@ All configuration via environment variables. No config file needed.
 
 ---
 
+## 🐳 Docker
+
+```bash
+# Quick start
+docker compose up -d
+
+# Or build and run manually
+docker build -t kore-memory .
+docker run -d -p 8765:8765 -v kore-data:/data \
+  -e KORE_API_KEY=$(python3 -c "import secrets; print(secrets.token_urlsafe(32))") \
+  kore-memory
+```
+
+Dashboard at `http://localhost:8765/dashboard`, API docs at `http://localhost:8765/docs`.
+
+Set `KORE_API_KEY` for authentication (required when `KORE_LOCAL_ONLY=0`). Data persists in the `kore-data` volume.
+
+To also run the MCP HTTP server, override the command:
+
+```bash
+docker run -d -p 8766:8766 -v kore-data:/data \
+  -e KORE_MCP_TOKEN=your-token \
+  kore-memory kore-mcp --transport streamable-http --host 0.0.0.0
+```
+
+---
+
 ## 🛠️ Development
 
 ```bash
@@ -709,7 +739,7 @@ pip install -e ".[semantic,dev,mcp,watcher]"
 # Run server
 kore --reload
 
-# Run all 648 tests
+# Run all 788 tests
 pytest tests/ -v
 
 # Run with coverage

kore_memory-3.0.4/docker-compose.yml

@@ -0,0 +1,27 @@
+services:
+  kore:
+    build: .
+    image: ghcr.io/auriti-labs/kore-memory:latest
+    ports:
+      - "8765:8765"   # REST API + Dashboard
+      - "8766:8766"   # MCP HTTP transport (optional)
+    volumes:
+      - kore-data:/data
+    environment:
+      - KORE_LOCAL_ONLY=0
+      # Generate a key: python3 -c "import secrets; print(secrets.token_urlsafe(32))"
+      # - KORE_API_KEY=your-secret-key-here
+      # - KORE_MCP_TOKEN=your-mcp-token-here
+      # - KORE_EMBED_MODEL=paraphrase-multilingual-MiniLM-L12-v2
+      # - KORE_AUDIT_LOG=1
+      # - KORE_ENTITY_EXTRACTION=1
+    restart: unless-stopped
+    healthcheck:
+      test: ["CMD", "python", "-c", "import httpx; httpx.get('http://127.0.0.1:8765/health').raise_for_status()"]
+      interval: 30s
+      timeout: 5s
+      retries: 3
+      start_period: 15s
+
+volumes:
+  kore-data:

{kore_memory-3.0.2 → kore_memory-3.0.4}/kore_memory/auth.py

@@ -68,9 +68,7 @@ def _is_local(request: Request) -> bool:
         return False
     # Detect reverse proxy: if X-Forwarded-For is present, the real client
     # is NOT local — require auth even if socket peer is localhost
-    if request.headers.get("X-Forwarded-For") or request.headers.get("X-Real-IP"):
-        return False
-    return True
+    return not (request.headers.get("X-Forwarded-For") or request.headers.get("X-Real-IP"))
 
 
 def _local_only_mode() -> bool:

kore_memory-3.0.4/kore_memory/cache.py

@@ -0,0 +1,290 @@
+"""
+Kore — Optional Redis Cache Layer
+Provides caching for search results, graph data, and analytics.
+Disabled by default — activate with KORE_REDIS_ENABLED=1.
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+from typing import Any
+
+from . import config
+
+logger = logging.getLogger(__name__)
+
+# ── Redis client (lazy-loaded) ────────────────────────────────────────────────
+
+_redis_client = None
+_redis_available = False
+
+
+def _get_redis_client():
+    """Lazy-load Redis client to avoid hard dependency."""
+    global _redis_client, _redis_available
+
+    if not config.REDIS_ENABLED:
+        return None
+
+    if _redis_client is not None:
+        return _redis_client
+
+    try:
+        import redis
+        from redis.exceptions import ConnectionError, TimeoutError
+
+        _redis_client = redis.Redis(
+            host=config.REDIS_HOST,
+            port=config.REDIS_PORT,
+            db=config.REDIS_DB,
+            password=config.REDIS_PASSWORD or None,
+            decode_responses=True,
+            socket_connect_timeout=5,
+            socket_timeout=5,
+        )
+        # Test connection
+        _redis_client.ping()
+        _redis_available = True
+        logger.info(
+            "Redis cache enabled: %s:%d/%d (prefix=%s)",
+            config.REDIS_HOST,
+            config.REDIS_PORT,
+            config.REDIS_DB,
+            config.REDIS_PREFIX,
+        )
+        return _redis_client
+
+    except ImportError:
+        logger.warning("Redis cache requested but redis-py not installed (pip install redis)")
+        _redis_available = False
+        return None
+
+    except (ConnectionError, TimeoutError) as e:
+        logger.warning("Redis connection failed: %s — cache disabled", e)
+        _redis_available = False
+        return None
+
+    except Exception as e:
+        logger.warning("Redis unexpected error: %s — cache disabled", e)
+        _redis_available = False
+        return None
+
+
+def is_available() -> bool:
+    """Check if Redis cache is available and connected."""
+    if not config.REDIS_ENABLED:
+        return False
+    if _redis_available:
+        return True
+    # Try to connect
+    return _get_redis_client() is not None
+
+
+# ── Cache helpers ─────────────────────────────────────────────────────────────
+
+
+def _key(name: str) -> str:
+    """Build cache key with prefix."""
+    return f"{config.REDIS_PREFIX}{name}"
+
+
+def _serialize(value: Any) -> str:
+    """Serialize value to JSON string, handling Pydantic models."""
+
+    def _default(o):
+        # Handle Pydantic v2 models
+        if hasattr(o, "model_dump"):
+            return o.model_dump()
+        if hasattr(o, "dict"):
+            # Pydantic v1 fallback
+            return o.dict()
+        return str(o)
+
+    return json.dumps(value, default=_default)
+
+
+def _deserialize(value: str | None) -> Any | None:
+    """Deserialize JSON string to Python value."""
+    if value is None:
+        return None
+    try:
+        return json.loads(value)
+    except (json.JSONDecodeError, TypeError):
+        return None
+
+
+# ── Cache operations ──────────────────────────────────────────────────────────
+
+
+def get(name: str) -> Any | None:
+    """Get value from cache by name."""
+    client = _get_redis_client()
+    if not client:
+        return None
+
+    try:
+        value = client.get(_key(name))
+        return _deserialize(value)
+    except Exception as e:
+        logger.debug("Cache get error for %s: %s", name, e)
+        return None
+
+
+def set(name: str, value: Any, ttl: int | None = None) -> bool:
+    """Set value in cache with optional TTL."""
+    client = _get_redis_client()
+    if not client:
+        return False
+
+    try:
+        key = _key(name)
+        serialized = _serialize(value)
+        if ttl is None:
+            ttl = config.REDIS_TTL
+        if ttl > 0:
+            client.setex(key, ttl, serialized)
+        else:
+            client.set(key, serialized)
+        return True
+    except Exception as e:
+        logger.debug("Cache set error for %s: %s", name, e)
+        return False
+
+
+def delete(name: str) -> bool:
+    """Delete value from cache."""
+    client = _get_redis_client()
+    if not client:
+        return False
+
+    try:
+        client.delete(_key(name))
+        return True
+    except Exception as e:
+        logger.debug("Cache delete error for %s: %s", name, e)
+        return False
+
+
+def clear_pattern(pattern: str) -> int:
+    """Clear all keys matching pattern (e.g., 'search:*'). Returns count deleted."""
+    client = _get_redis_client()
+    if not client:
+        return 0
+
+    try:
+        full_pattern = _key(pattern)
+        keys = list(client.scan_iter(match=full_pattern))
+        if keys:
+            return client.delete(*keys)
+        return 0
+    except Exception as e:
+        logger.debug("Cache clear error for %s: %s", pattern, e)
+        return 0
+
+
+# ── High-level cache wrappers ─────────────────────────────────────────────────
+
+
+class SearchCache:
+    """Cache wrapper for search results."""
+
+    @staticmethod
+    def _cache_key(query: str, agent_id: str, semantic: bool, limit: int) -> str:
+        return f"search:{agent_id}:{'sem' if semantic else 'fts'}:{limit}:{hash(query)}"
+
+    @classmethod
+    def get(cls, query: str, agent_id: str, semantic: bool, limit: int) -> list[dict] | None:
+        """Get cached search results."""
+        key = cls._cache_key(query, agent_id, semantic, limit)
+        result = get(key)
+        if result is not None:
+            logger.debug("Cache HIT for search: %s", query[:50])
+        return result
+
+    @classmethod
+    def set(cls, query: str, agent_id: str, semantic: bool, limit: int, results: list[dict]) -> bool:
+        """Cache search results."""
+        key = cls._cache_key(query, agent_id, semantic, limit)
+        return set(key, results, ttl=config.REDIS_SEARCH_TTL)
+
+    @classmethod
+    def invalidate(cls, agent_id: str) -> int:
+        """Invalidate all search cache for an agent."""
+        return clear_pattern(f"search:{agent_id}:*")
+
+
+class GraphCache:
+    """Cache wrapper for graph data."""
+
+    @staticmethod
+    def _cache_key(kind: str, **params) -> str:
+        param_str = ":".join(f"{k}={v}" for k, v in sorted(params.items()))
+        return f"graph:{kind}:{param_str}"
+
+    @classmethod
+    def get(cls, kind: str, **params) -> dict | None:
+        """Get cached graph data."""
+        key = cls._cache_key(kind, **params)
+        return get(key)
+
+    @classmethod
+    def set(cls, kind: str, data: dict, **params) -> bool:
+        """Cache graph data."""
+        key = cls._cache_key(kind, **params)
+        return set(key, data, ttl=config.REDIS_GRAPH_TTL)
+
+    @classmethod
+    def invalidate(cls) -> int:
+        """Invalidate all graph cache."""
+        return clear_pattern("graph:*")
+
+
+class AnalyticsCache:
+    """Cache wrapper for analytics data."""
+
+    @staticmethod
+    def _cache_key(agent_id: str, kind: str) -> str:
+        return f"analytics:{agent_id}:{kind}"
+
+    @classmethod
+    def get(cls, agent_id: str, kind: str) -> dict | None:
+        """Get cached analytics."""
+        key = cls._cache_key(agent_id, kind)
+        return get(key)
+
+    @classmethod
+    def set(cls, agent_id: str, kind: str, data: dict) -> bool:
+        """Cache analytics data."""
+        key = cls._cache_key(agent_id, kind)
+        return set(key, data, ttl=config.REDIS_ANALYTICS_TTL)
+
+    @classmethod
+    def invalidate(cls, agent_id: str) -> int:
+        """Invalidate all analytics cache for an agent."""
+        return clear_pattern(f"analytics:{agent_id}:*")
+
+
+# ── Cache invalidation hooks ──────────────────────────────────────────────────
+
+
+def invalidate_on_save(agent_id: str) -> None:
+    """Invalidate relevant caches when a memory is saved."""
+    SearchCache.invalidate(agent_id)
+    AnalyticsCache.invalidate(agent_id)
+    # Graph may need invalidation if entities/tags changed
+    GraphCache.invalidate()
+
+
+def invalidate_on_delete(agent_id: str) -> None:
+    """Invalidate relevant caches when a memory is deleted."""
+    SearchCache.invalidate(agent_id)
+    AnalyticsCache.invalidate(agent_id)
+    GraphCache.invalidate()
+
+
+def invalidate_on_compress(agent_id: str) -> None:
+    """Invalidate all caches after compression (many memories changed)."""
+    SearchCache.invalidate(agent_id)
+    AnalyticsCache.invalidate(agent_id)
+    GraphCache.invalidate()

{kore_memory-3.0.2 → kore_memory-3.0.4}/kore_memory/compressor.py

@@ -93,7 +93,7 @@ def _load_compressible_memories(agent_id: str = "default") -> list[dict]:
     with get_connection() as conn:
         rows = conn.execute(
             """
-            SELECT id, content, category, importance, embedding
+            SELECT id, content, category, importance, embedding, agent_id
             FROM memories
             WHERE compressed_into IS NULL AND archived_at IS NULL AND embedding IS NOT NULL AND agent_id = ?
             """,
@@ -310,6 +310,13 @@ def _merge_cluster(cluster: list[dict], agent_id: str = "default") -> int | None
     if not cluster:
         return None
 
+    # Sicurezza: verifica agent isolation nel cluster (difesa in profondità)
+    cluster_agent_ids = {m.get("agent_id") for m in cluster if "agent_id" in m}
+    if len(cluster_agent_ids) > 1:
+        # Cluster cross-agent rilevato — skip per sicurezza
+        print(f"[COMPRESSIONE] WARNING: cluster cross-agent rilevato: {cluster_agent_ids}. Skip per sicurezza.")
+        return None
+
     # Build merged content: combine unique sentences
     # Split on sentence boundaries (. ! ? followed by space/end) instead of pipe
     combined_parts = []