agmem 0.2.0__py3-none-any.whl → 0.2.1__py3-none-any.whl

{agmem-0.2.0.dist-info → agmem-0.2.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agmem
-Version: 0.2.0
+Version: 0.2.1
 Summary: Agentic Memory Version Control System - Git for AI agent memories
 Home-page: https://github.com/vivek-tiwari-vt/agmem
 Author: agmem Team
@@ -137,14 +137,15 @@ agmem solves all of these problems with a familiar Git-like interface.
 - ✅ **Tamper-evident audit trail** — Append-only hash-chained log (init, add, commit, checkout, merge, push, pull, config); `agmem audit` and `agmem audit --verify`
 - ✅ **Multi-agent trust** — Trust store (full / conditional / untrusted) per public key; applied on pull/merge; clone copies remote keys
 - ✅ **Conflict resolution** — `agmem resolve` with ours/theirs/both; conflicts persisted in `.mem/merge/`; path-safe
-- ✅ **Differential privacy** — Epsilon/delta budget in `.mem/privacy_budget.json`; `--private` on `agmem distill` and `agmem garden`; noise applied to counts and frontmatter
+- ✅ **Differential privacy** — Epsilon/delta budget in `.mem/privacy_budget.json`; `--private` on `agmem distill` and `agmem garden`; noise applies to fact-level data only (metadata fields excluded)
 - ✅ **Pack files & GC** — `agmem gc [--repack]` (reachable from refs, prune loose, optional pack file + index); ObjectStore reads from pack when loose missing
 - ✅ **Multi-provider LLM** — OpenAI and Anthropic via `memvcs.core.llm`; config/repo or env; used by gardener, distiller, consistency, merge
 - ✅ **Temporal querying** — Point-in-time and range queries in temporal index; frontmatter timestamps
-- ✅ **Federated collaboration** — `agmem federated push|pull`; real summaries (topic counts, fact hashes); optional DP on outbound; coordinator API in docs/FEDERATED.md
+- ✅ **Federated collaboration** — `agmem federated push|pull`; protocol-compliant summaries (agent_id, timestamp, topic_counts, fact_hashes); optional DP on outbound; coordinator API in docs/FEDERATED.md
 - ✅ **Zero-knowledge proofs** — `agmem prove` (hash/signature-based): keyword containment (Merkle set membership), memory freshness (signed timestamp). **Note:** Current implementation is proof-of-knowledge with known limitations; see docs for migration to true zk-SNARKs.
 - ✅ **Daemon health** — 4-point health monitoring (storage, redundancy, staleness, graph consistency) with periodic checks; visible warnings and JSON reports
-- ✅ **Delta encoding** — 5-10x compression for similar objects using Levenshtein distance and SequenceMatcher; optional feature in pack files
+- ✅ **Delta encoding** — 5-10x compression for similar objects using Levenshtein distance and SequenceMatcher; enabled in GC repack with multi-tier similarity filtering
+- ✅ **Performance safeguards** — Multi-tier similarity filter (length ratio + SimHash) avoids O(n²×m²) worst-case comparisons
 - ✅ **GPU acceleration** — Vector store detects GPU for embedding model when available
 - ✅ **Optional** — `serve`, `daemon` (watch + auto-commit), `garden` (episode archival), MCP server; install extras as needed
 

{agmem-0.2.0.dist-info → agmem-0.2.1.dist-info}/RECORD

@@ -1,6 +1,6 @@
-agmem-0.2.0.dist-info/licenses/LICENSE,sha256=X_S6RBErW-F0IDbM3FAEoDB-zxExFnl2m8640rTXphM,1067
-memvcs/__init__.py,sha256=pheWPxubHVcp2N6vk6M7hGXgkJQ06KajbWgCpOlUSJ8,193
-memvcs/cli.py,sha256=YF06oMNjKWUmiNahILmfjrIXgoXzU-5BJFmbunSb8Sc,6075
+agmem-0.2.1.dist-info/licenses/LICENSE,sha256=X_S6RBErW-F0IDbM3FAEoDB-zxExFnl2m8640rTXphM,1067
+memvcs/__init__.py,sha256=PwF2IkjOfw5nZCDcZdsNKns-h-FEvRahAqNd37Ti8_8,193
+memvcs/cli.py,sha256=WPjhbevcOc_w_7SEXV5oitbEA5kYY5lHWgyTOq6x8sU,6075
 memvcs/commands/__init__.py,sha256=A2D6xWaO6epU7iV4QSvqvF5TspnwRyDN7NojmGatPrE,510
 memvcs/commands/add.py,sha256=k9eM7qf2NFvneiJkFQNiAYFB2GgKmyPw_NXmkCxblQE,8736
 memvcs/commands/audit.py,sha256=E6m54B726tqDQR3rrgRXWrjE-seu2UocqrFxN1aHkY4,1680
@@ -47,10 +47,11 @@ memvcs/commands/tree.py,sha256=vdULq4vIXA_4gNfMnHn_Y78BwE0sJoeTBOnFJR3WsZ4,4927
 memvcs/commands/verify.py,sha256=04CVW5NYWkUlPJ5z1Kci6dfQFM6UmPTGZh9ZextFLMc,3887
 memvcs/commands/when.py,sha256=bxG_tEYnZNBTl2IPkoxpc2LUEbO_5ev1hRvEzxQQDmc,4773
 memvcs/coordinator/__init__.py,sha256=XJEXEXJFvvhtRInPeyAC9bFNXGbshSrtuK6wZo3wS6g,139
-memvcs/coordinator/server.py,sha256=-kCEyqUi7eLC45qqkH1KCk8zZk8T1NdJyffOY8133ec,7045
+memvcs/coordinator/server.py,sha256=M0wnww0EbtxuDaunP29LJDCnsTm1mcOn7h_fqZbQy5c,7550
 memvcs/core/__init__.py,sha256=dkIC-4tS0GhwV2mZIbofEe8xR8uiFwrxslGf1aXwhYg,493
 memvcs/core/access_index.py,sha256=HhacnzSUASzRV2jhDHkwRFoPS3rtqh9n9yE1VV7JXpk,5596
 memvcs/core/audit.py,sha256=8APkm9Spl_-1rIdyRQz1elyxOeK3nlpwm0CLkpLlhTE,3732
+memvcs/core/compression_metrics.py,sha256=0JrbkCGr0hnaKlmPLqv5WVLwO3emOEz2iFhdMTDNTNY,9835
 memvcs/core/compression_pipeline.py,sha256=Vzr5v_0pgAG20C8znC0-Ho5fEwBoaTOLddxMTldd64M,5564
 memvcs/core/config_loader.py,sha256=j-jgLDp2TRzWN9ZEZebfWSfatevBNYs0FEb3ud1SIR8,8277
 memvcs/core/consistency.py,sha256=YOG8xhqZLKZCLbai2rdcP0KxYPNGFv5RRMwrQ6qCeyc,7462
@@ -59,18 +60,21 @@ memvcs/core/crypto_verify.py,sha256=DTuC7Kfx6z2b8UWOWziBTqP633LrjXbdtGmBBqrJTF0,
 memvcs/core/decay.py,sha256=ROGwnqngs7eJNkbKmwyOdij607m73vpmoJqzrIDLBzk,6581
 memvcs/core/delta.py,sha256=obXzojUSc2HaEUqH3L_1LF-GcJ63Wr_yYvIPM8iyeSg,7865
 memvcs/core/diff.py,sha256=koEHTLciIUxYKVJVuvmY0GDXMgDgGZP_qg5RayhF-iE,13226
-memvcs/core/distiller.py,sha256=QA4acLc005cLac09IvIaog1fJt5IGXWRiSdZq_Ya27g,14086
+memvcs/core/distiller.py,sha256=wwY3xQVRBjVfxnOUIwMsQCSeQ2tlG68w2-KiCwkF9yo,13844
 memvcs/core/encryption.py,sha256=epny_nlW6ylllv1qxs1mAcFq-PrLIisgfot4llOoAqw,5289
-memvcs/core/federated.py,sha256=vUYMZ0xv80hqGDRKq645Od1i8N33l-pIAkklJbJUlVg,5445
-memvcs/core/gardener.py,sha256=lBWkyE72O-JMiHM-oqrnex9k_xSv7FvztjkOdLdB0Kk,18610
+memvcs/core/fast_similarity.py,sha256=phgjxkSchJg7om9AFFSMbtP6bSidyRy-vVrR3XyMmDQ,13934
+memvcs/core/federated.py,sha256=qwvfhNgga-lHadbinAfKPI4oAl0RMn5ab01ChmQTP1s,5863
+memvcs/core/gardener.py,sha256=bpoJbK6PJ6nvK3ytj23jpMUBUB7Nn_fB80Ap1E7-Nv8,17041
 memvcs/core/hooks.py,sha256=XF9z8J5sWjAcuOyWQ2nuvEzK0UV8s4ThrcltaBZttzw,5448
 memvcs/core/ipfs_remote.py,sha256=xmEO14bn_7Ej-W5jhx2QJyBd-ljj9S2COOxMmcZBiTs,6643
 memvcs/core/knowledge_graph.py,sha256=GY27e1rgraF2zMpz_jsumdUtpgTRk48yH5CAEQ3TDl4,16416
 memvcs/core/merge.py,sha256=x2eSaxr4f63Eq00FCJ6DDe2TZU8H5yHQpzKzMhYsaFw,19871
 memvcs/core/objects.py,sha256=Xgw1IpQnJLCG5o_7gDHVQ-TNGR9CSpDYWRXzLgLSuec,11006
-memvcs/core/pack.py,sha256=Kq0hyMNroT0MwiS4pVJVuJO9nZ04P3wssep2tADvnpQ,15950
+memvcs/core/pack.py,sha256=jtbeBh625K6nshPgBGf7zelU-BhvK5-t5NYBJPoYfgs,15961
 memvcs/core/pii_scanner.py,sha256=T6gQ1APFrSDk980fjnv4ZMF-UztbJgmUFSwGrwWixEw,10802
 memvcs/core/privacy_budget.py,sha256=fOPlxoKEAmsKtda-OJCrSaKjTyw7ekcqdN7KfRBw1CY,2113
+memvcs/core/privacy_validator.py,sha256=g3l1zxSIxkjMYJMwL5yfuDY5FFjmkm6HZ2Wo4xBiEkQ,6795
+memvcs/core/protocol_builder.py,sha256=b_5FphgmMdp7qP34ws3U2agXEoeYzTBjSgsQqd2Jx6Y,7713
 memvcs/core/refs.py,sha256=4Nx2ZVRa_DzfUZ4O1AwzOHEjoGAEICJKqSd9GxaiD_g,16754
 memvcs/core/remote.py,sha256=sZbAO9JEaDJM96PylB0CjpmR5UxWYdoXlq86sj3R2gU,22228
 memvcs/core/repository.py,sha256=NzC2UFPv6ePxi5lfiSKyZFLclH4bJpWJz88pY7tDiv4,20605
@@ -104,8 +108,8 @@ memvcs/retrieval/recaller.py,sha256=8KY-XjMUz5_vcKf46zI64uk1DEM__u7wM92ShukOtsY,
 memvcs/retrieval/strategies.py,sha256=26yxQQubQfjxWQXknfVMxuzPHf2EcZxJg_B99BEdl5c,11458
 memvcs/utils/__init__.py,sha256=8psUzz4Ntv2GzbRebkeVsoyC6Ck-FIwi0_lfYdj5oho,185
 memvcs/utils/helpers.py,sha256=37zg_DcQ2y99b9NSLqxFkglHe13rJXKhFDpEbQ7iLhM,4121
-agmem-0.2.0.dist-info/METADATA,sha256=Oh9LOeoQR_A9ZXrdrkt-sTFoiYA-peWVHvpVaUYncns,42100
-agmem-0.2.0.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
-agmem-0.2.0.dist-info/entry_points.txt,sha256=at7eWycgjqOo1wbUMECnXUsNo3gpCkJTU71OzrGLHu0,42
-agmem-0.2.0.dist-info/top_level.txt,sha256=HtMMsKuwLKLOdgF1GxqQztqFM54tTJctVdJuOec6B-4,7
-agmem-0.2.0.dist-info/RECORD,,
+agmem-0.2.1.dist-info/METADATA,sha256=6UV86NAOpGnnqpRJJE_9XkU-7j2aoLSIf3TB1oQ3dC0,42320
+agmem-0.2.1.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+agmem-0.2.1.dist-info/entry_points.txt,sha256=at7eWycgjqOo1wbUMECnXUsNo3gpCkJTU71OzrGLHu0,42
+agmem-0.2.1.dist-info/top_level.txt,sha256=HtMMsKuwLKLOdgF1GxqQztqFM54tTJctVdJuOec6B-4,7
+agmem-0.2.1.dist-info/RECORD,,

memvcs/__init__.py

@@ -4,6 +4,6 @@ agmem - Agentic Memory Version Control System
 A Git-inspired version control system for AI agent memory artifacts.
 """
 
-__version__ = "0.1.6"
+__version__ = "0.2.1"
 __author__ = "agmem Team"
 __license__ = "MIT"

memvcs/cli.py

@@ -141,7 +141,7 @@ For more information: https://github.com/vivek-tiwari-vt/agmem
         """,
     )
 
-    parser.add_argument("--version", "-v", action="version", version="%(prog)s 0.1.0")
+    parser.add_argument("--version", "-v", action="version", version="%(prog)s 0.2.1")
 
     parser.add_argument("--verbose", action="store_true", help="Enable verbose output")
 

memvcs/coordinator/server.py

@@ -21,6 +21,7 @@ from typing import Dict, List, Optional, Any
 from pathlib import Path
 import json
 import hashlib
+import re
 
 try:
     from fastapi import FastAPI, HTTPException, Request
@@ -39,10 +40,25 @@ except ImportError:
         return None
 
 
+def _get_version() -> str:
+    """Get agmem version from pyproject.toml. Falls back to 0.2.1 if not found."""
+    try:
+        pyproject_path = Path(__file__).parent.parent.parent / "pyproject.toml"
+        if pyproject_path.exists():
+            content = pyproject_path.read_text()
+            match = re.search(r'version\s*=\s*"([^"]+)"', content)
+            if match:
+                return match.group(1)
+    except Exception:
+        pass
+    return "0.2.1"
+
+
 # Storage: In-memory for simplicity (use Redis/PostgreSQL for production)
 summaries_store: Dict[str, List[Dict[str, Any]]] = {}
+_version = _get_version()
 metadata_store: Dict[str, Any] = {
-    "coordinator_version": "0.1.6",
+    "coordinator_version": _version,
     "started_at": datetime.now(timezone.utc).isoformat(),
     "total_pushes": 0,
     "total_agents": 0,
@@ -79,7 +95,7 @@ if FASTAPI_AVAILABLE:
     app = FastAPI(
         title="agmem Federated Coordinator",
         description="Minimal coordinator for federated agent memory collaboration",
-        version="0.1.6",
+        version=_version,
     )
 
     @app.get("/")

memvcs/core/compression_metrics.py

@@ -0,0 +1,248 @@
+"""
+Delta compression metrics and observability.
+
+Tracks compression effectiveness across object types to enable future
+optimization and auto-tuning of delta encoding parameters.
+
+Provides:
+- DeltaCompressionMetrics: Tracks compression ratio, object types, benefits
+- CompressionHeatmap: Visualizes which types compress best
+- Statistics reporting for gc --repack operations
+"""
+
+from dataclasses import dataclass, field
+from typing import Dict, List, Any, Optional, Tuple
+from collections import defaultdict
+
+
+@dataclass
+class ObjectCompressionStats:
+    """Statistics for a single object's compression."""
+
+    object_id: str
+    object_type: str  # "semantic", "episodic", "procedural"
+    original_size: int  # bytes
+    compressed_size: int  # bytes after delta encoding
+    compression_ratio: float  # compressed_size / original_size (0.0 = 100% compression)
+    delta_used: bool  # Whether delta encoding was applied
+    compression_benefit: float  # original_size - compressed_size
+
+
+@dataclass
+class TypeCompressionStats:
+    """Aggregated statistics for an object type."""
+
+    object_type: str
+    count: int = 0
+    total_original_size: int = 0
+    total_compressed_size: int = 0
+    avg_compression_ratio: float = 0.0
+    total_benefit: int = 0  # Total bytes saved
+    objects_with_delta: int = 0  # How many used delta encoding
+    min_ratio: float = 1.0
+    max_ratio: float = 0.0
+
+    def update_from_object(self, obj_stats: ObjectCompressionStats) -> None:
+        """Update type stats with a single object's stats."""
+        self.count += 1
+        self.total_original_size += obj_stats.original_size
+        self.total_compressed_size += obj_stats.compressed_size
+        self.total_benefit += int(obj_stats.compression_benefit)
+        if obj_stats.delta_used:
+            self.objects_with_delta += 1
+        self.min_ratio = min(self.min_ratio, obj_stats.compression_ratio)
+        self.max_ratio = max(self.max_ratio, obj_stats.compression_ratio)
+
+        # Recalculate average
+        if self.total_original_size > 0:
+            self.avg_compression_ratio = self.total_compressed_size / self.total_original_size
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert to dict for reporting."""
+        savings_pct = 0.0
+        if self.total_original_size > 0:
+            savings_pct = (self.total_benefit / self.total_original_size) * 100
+
+        return {
+            "object_type": self.object_type,
+            "count": self.count,
+            "total_original_bytes": self.total_original_size,
+            "total_compressed_bytes": self.total_compressed_size,
+            "avg_compression_ratio": round(self.avg_compression_ratio, 3),
+            "compression_range": f"{self.min_ratio:.1%} - {self.max_ratio:.1%}",
+            "total_bytes_saved": self.total_benefit,
+            "savings_percentage": round(savings_pct, 1),
+            "objects_using_delta": self.objects_with_delta,
+            "delta_adoption_rate": (
+                round((self.objects_with_delta / self.count * 100), 1) if self.count > 0 else 0
+            ),
+        }
+
+
+class DeltaCompressionMetrics:
+    """Tracks delta compression statistics across all objects.
+
+    Usage:
+        metrics = DeltaCompressionMetrics()
+        # ... during packing ...
+        metrics.record_object(ObjectCompressionStats(...))
+        # ... after packing ...
+        report = metrics.get_report()
+    """
+
+    def __init__(self):
+        self.objects: List[ObjectCompressionStats] = []
+        self.type_stats: Dict[str, TypeCompressionStats] = {}
+        self.total_original_size: int = 0
+        self.total_compressed_size: int = 0
+
+    def record_object(self, obj_stats: ObjectCompressionStats) -> None:
+        """Record compression stats for a single object."""
+        self.objects.append(obj_stats)
+        self.total_original_size += obj_stats.original_size
+        self.total_compressed_size += obj_stats.compressed_size
+
+        # Update type-specific stats
+        if obj_stats.object_type not in self.type_stats:
+            self.type_stats[obj_stats.object_type] = TypeCompressionStats(
+                object_type=obj_stats.object_type
+            )
+        self.type_stats[obj_stats.object_type].update_from_object(obj_stats)
+
+    def get_type_stats(self, object_type: str) -> Optional[TypeCompressionStats]:
+        """Get stats for a specific object type."""
+        return self.type_stats.get(object_type)
+
+    def get_overall_ratio(self) -> float:
+        """Get overall compression ratio across all objects."""
+        if self.total_original_size == 0:
+            return 0.0
+        return self.total_compressed_size / self.total_original_size
+
+    def get_overall_savings(self) -> int:
+        """Get total bytes saved across all objects."""
+        return self.total_original_size - self.total_compressed_size
+
+    def get_report(self) -> Dict[str, Any]:
+        """Generate a comprehensive compression report."""
+        overall_ratio = self.get_overall_ratio()
+        overall_savings = self.get_overall_savings()
+        savings_pct = (
+            (overall_savings / self.total_original_size * 100)
+            if self.total_original_size > 0
+            else 0
+        )
+
+        return {
+            "timestamp": None,  # Set by caller if needed
+            "total_objects": len(self.objects),
+            "total_original_bytes": self.total_original_size,
+            "total_compressed_bytes": self.total_compressed_size,
+            "overall_compression_ratio": round(overall_ratio, 3),
+            "total_bytes_saved": overall_savings,
+            "compression_percentage": round(savings_pct, 1),
+            "type_statistics": {otype: stats.to_dict() for otype, stats in self.type_stats.items()},
+            "recommendations": self._generate_recommendations(),
+        }
+
+    def _generate_recommendations(self) -> List[str]:
+        """Generate optimization recommendations based on compression stats."""
+        recommendations = []
+
+        # Check if delta encoding is worth it
+        objects_with_delta = sum(s.objects_with_delta for s in self.type_stats.values())
+        if objects_with_delta == 0:
+            recommendations.append("No objects used delta encoding. Check similarity thresholds.")
+
+        # Check for types with poor compression
+        for otype, stats in self.type_stats.items():
+            if stats.count > 0 and stats.avg_compression_ratio > 0.9:
+                recommendations.append(
+                    f"Type '{otype}' compresses poorly (ratio: {stats.avg_compression_ratio:.1%}). "
+                    f"Consider increasing similarity threshold or reducing delta cost."
+                )
+
+        # Check for types with excellent compression
+        for otype, stats in self.type_stats.items():
+            if stats.count > 0 and stats.avg_compression_ratio < 0.5:
+                recommendations.append(
+                    f"Type '{otype}' compresses very well (ratio: {stats.avg_compression_ratio:.1%}). "
+                    f"Consider aggressive delta encoding or reduced threshold."
+                )
+
+        if not recommendations:
+            recommendations.append("Compression is operating normally.")
+
+        return recommendations
+
+    def get_heatmap(self) -> str:
+        """Generate a text-based compression heatmap."""
+        lines = ["Delta Compression Heatmap", "=" * 50]
+
+        if not self.type_stats:
+            lines.append("No compression data available")
+            return "\n".join(lines)
+
+        # Sort by compression ratio
+        sorted_types = sorted(
+            self.type_stats.values(),
+            key=lambda s: s.avg_compression_ratio,
+        )
+
+        for stats in sorted_types:
+            if stats.count == 0:
+                continue
+            ratio = stats.avg_compression_ratio
+            # Create a simple bar chart
+            bar_width = 30
+            filled = int(bar_width * ratio)
+            bar = "█" * filled + "░" * (bar_width - filled)
+            saved_pct = (
+                (stats.total_benefit / stats.total_original_size * 100)
+                if stats.total_original_size > 0
+                else 0
+            )
+            lines.append(
+                f"{stats.object_type:12} {bar} {saved_pct:5.1f}% saved ({stats.objects_with_delta}/{stats.count} using delta)"
+            )
+
+        return "\n".join(lines)
+
+    def log_report(self, logger: Any = None) -> None:
+        """Log the compression report."""
+        report = self.get_report()
+        heatmap = self.get_heatmap()
+
+        output = [
+            "=" * 70,
+            "Delta Compression Report",
+            "=" * 70,
+            f"Total Objects: {report['total_objects']}",
+            f"Total Original: {report['total_original_bytes']:,} bytes",
+            f"Total Compressed: {report['total_compressed_bytes']:,} bytes",
+            f"Overall Ratio: {report['overall_compression_ratio']:.1%}",
+            f"Bytes Saved: {report['total_bytes_saved']:,} ({report['compression_percentage']:.1f}%)",
+            "",
+            heatmap,
+            "",
+            "Type Breakdown:",
+        ]
+
+        for otype, stats in sorted(report["type_statistics"].items()):
+            output.append(f"  {otype}:")
+            output.append(f"    Count: {stats['count']}")
+            output.append(f"    Compression: {stats['avg_compression_ratio']:.1%}")
+            output.append(f"    Saved: {stats['total_bytes_saved']:,} bytes")
+            output.append(f"    Delta adoption: {stats['delta_adoption_rate']:.0f}%")
+
+        output.extend(["", "Recommendations:"])
+        for rec in report["recommendations"]:
+            output.append(f"  - {rec}")
+
+        output.append("=" * 70)
+
+        full_output = "\n".join(output)
+        if logger:
+            logger.info(full_output)
+        else:
+            print(full_output)

memvcs/core/distiller.py

@@ -211,7 +211,6 @@ class Distiller:
         # Sample facts with noise - prevents any single episode from dominating
         import random
 
-        random.seed(42)  # Deterministic but different per cluster due to content
         sampled = random.sample(facts, min(noisy_count, len(facts)))
 
         # Optional: Add slight noise to fact embeddings if vector store available
@@ -233,17 +232,9 @@ class Distiller:
             out_path = self.target_dir / f"consolidated-{ts}.md"
 
         confidence_score = self.config.extraction_confidence_threshold
-        if (
-            self.config.use_dp
-            and self.config.dp_epsilon is not None
-            and self.config.dp_delta is not None
-        ):
-            from .privacy_budget import add_noise
-
-            confidence_score = add_noise(
-                confidence_score, 0.1, self.config.dp_epsilon, self.config.dp_delta
-            )
-            confidence_score = max(0.0, min(1.0, confidence_score))
+        # Metadata noise removed: confidence_score is a metadata field (threshold setting),
+        # not an individual fact. Adding noise to metadata doesn't provide meaningful
+        # privacy guarantees. See privacy_validator.py for the distinction.
         frontmatter = {
             "schema_version": "1.0",
             "last_updated": datetime.utcnow().isoformat() + "Z",