feat(core): introduce plugin architecture for OSS/PRO separation

- Core interfaces for importance scoring, conflict resolution, deduplication
- Default OSS implementations (baseline only)
- Dynamic plugin loader (synapse_memory_pro)
- AutoSaveEngine now strategy-driven
- SYNAPSE_MODE enforcement (oss/pro)
- Full test coverage for plugin behavior
- 265 tests passing, 95% coverage

Author: Ismael Marchi

README.md

@@ -265,6 +265,58 @@ See [mcp-autosave/](mcp-autosave/) for the production MCP Bridge with Supabase p
 
 ---
 
+## Plugin Architecture
+
+Synapse Layer uses a **strategy-driven plugin architecture** for clean OSS/PRO separation:
+
+```
+┌─────────────────────────────────────────────┐
+│              AutoSaveEngine                 │
+│  ┌──────────┐ ┌──────────┐ ┌────────────┐  │
+│  │ Importance│ │ Conflict │ │   Dedup    │  │
+│  │  Scorer   │ │ Resolver │ │  Strategy  │  │
+│  └─────┬────┘ └─────┬────┘ └─────┬──────┘  │
+│        │            │            │          │
+│   ┌────▼────────────▼────────────▼────┐     │
+│   │        Plugin Loader              │     │
+│   │   OSS defaults ← PRO override    │     │
+│   └───────────────────────────────────┘     │
+└─────────────────────────────────────────────┘
+```
+
+**Core Interfaces** (`synapse_memory.plugins`):
+- `ImportanceScorer` — Score event significance (0.0–1.0)
+- `ConflictResolver` — Resolve competing events
+- `DedupStrategy` — Detect duplicate memories
+- `RedactionStrategy` — Extensible content redaction
+
+**OSS** ships with simple, predictable defaults. **PRO** implementations are injected dynamically via `synapse-layer-pro` — no proprietary logic lives in this repo.
+
+```python
+# OSS mode (default) — uses built-in defaults
+engine = AutoSaveEngine(database=db, redactor=redact)
+
+# PRO mode — automatically loads synapse-layer-pro if installed
+# pip install synapse-layer-pro
+engine = AutoSaveEngine(database=db, redactor=redact, mode="pro")
+
+# Custom strategies — bring your own
+from synapse_memory.plugins import ImportanceScorer
+
+class MyScorer:
+    def score(self, event) -> float:
+        return 1.0 if "critical" in event.content else 0.5
+
+engine = AutoSaveEngine(
+    database=db, redactor=redact,
+    importance_scorer=MyScorer(),
+)
+```
+
+Set `SYNAPSE_MODE=pro` to enable PRO features. If `synapse-layer-pro` is not installed, a warning is emitted and OSS defaults are used.
+
+---
+
 ## Pricing
 
 | Plan | Price | Memories | Includes |

synapse_memory/__init__.py

@@ -24,6 +24,17 @@
     HandoverToken,
 )
 from .autosave import AutoSaveEngine, AutoSaveEvent, SaveResult
+from .plugins import (
+    ImportanceScorer,
+    ConflictResolver,
+    DedupStrategy,
+    RedactionStrategy,
+    SynapseProPlugin,
+    DefaultImportanceScorer,
+    DefaultConflictResolver,
+    DefaultDedupStrategy,
+    load_pro_plugin,
+)
 
 __version__ = "1.0.7"
 
@@ -63,4 +74,14 @@
     "AutoSaveEngine",
     "AutoSaveEvent",
     "SaveResult",
+    # Plugin Architecture
+    "ImportanceScorer",
+    "ConflictResolver",
+    "DedupStrategy",
+    "RedactionStrategy",
+    "SynapseProPlugin",
+    "DefaultImportanceScorer",
+    "DefaultConflictResolver",
+    "DefaultDedupStrategy",
+    "load_pro_plugin",
 ]

synapse_memory/autosave/engine.py

@@ -29,6 +29,18 @@
 from .triggers import TriggerDetector
 from .formatter import EventFormatter
 
+from synapse_memory.plugins.interfaces import (
+    ImportanceScorer,
+    ConflictResolver,
+    DedupStrategy,
+)
+from synapse_memory.plugins.defaults import (
+    DefaultImportanceScorer,
+    DefaultConflictResolver,
+    DefaultDedupStrategy,
+)
+from synapse_memory.plugins.plugin_loader import load_pro_plugin
+
 logger = logging.getLogger("synapse.autosave.engine")
 
 
@@ -100,6 +112,11 @@ def __init__(
         formatter: Optional[EventFormatter] = None,
         cache_maxsize: int = 100,
         cache_ttl: float = 60.0,
+        *,
+        importance_scorer: Optional[ImportanceScorer] = None,
+        conflict_resolver: Optional[ConflictResolver] = None,
+        dedup_strategy: Optional[DedupStrategy] = None,
+        mode: Optional[str] = None,
     ) -> None:
         self._db = database
         self._redactor = redactor
@@ -108,6 +125,34 @@ def __init__(
         self._formatter = formatter or EventFormatter()
         self._cache = _LRUCache(maxsize=cache_maxsize, ttl=cache_ttl)
 
+        # ── Plugin Architecture (OSS/PRO separation) ───────────────
+        plugin = load_pro_plugin(mode=mode)
+
+        self.importance_scorer: ImportanceScorer = (
+            importance_scorer
+            or (plugin.importance_scorer if plugin else None)
+            or DefaultImportanceScorer()
+        )
+        self.conflict_resolver: ConflictResolver = (
+            conflict_resolver
+            or (plugin.conflict_resolver if plugin else None)
+            or DefaultConflictResolver()
+        )
+        self.dedup_strategy: DedupStrategy = (
+            dedup_strategy
+            or (plugin.dedup_strategy if plugin else None)
+            or DefaultDedupStrategy()
+        )
+
+        self._plugin_loaded = plugin is not None
+        logger.info(
+            "AutoSaveEngine initialized: plugin=%s, scorer=%s, resolver=%s, dedup=%s",
+            "PRO" if self._plugin_loaded else "OSS",
+            type(self.importance_scorer).__name__,
+            type(self.conflict_resolver).__name__,
+            type(self.dedup_strategy).__name__,
+        )
+
     # ── Public API ─────────────────────────────────────────────────────
 
     def save(self, event: AutoSaveEvent) -> SaveResult:

synapse_memory/plugins/__init__.py

@@ -0,0 +1,46 @@
+"""
+Synapse Layer — Core Abstractions & Plugin Architecture
+
+Immutable contracts for extensibility:
+    - ImportanceScorer
+    - ConflictResolver
+    - DedupStrategy
+    - RedactionStrategy
+
+Default OSS implementations provided. PRO implementations
+injected dynamically via ``synapse_memory_pro`` package.
+
+Author : Security & Architecture Team @ Synapse Layer
+License: Apache 2.0
+"""
+
+from .interfaces import (
+    ImportanceScorer,
+    ConflictResolver,
+    DedupStrategy,
+    RedactionStrategy,
+    RedactionResult,
+    SynapseProPlugin,
+)
+from .defaults import (
+    DefaultImportanceScorer,
+    DefaultConflictResolver,
+    DefaultDedupStrategy,
+)
+from .plugin_loader import load_pro_plugin
+
+__all__ = [
+    # Interfaces
+    "ImportanceScorer",
+    "ConflictResolver",
+    "DedupStrategy",
+    "RedactionStrategy",
+    "RedactionResult",
+    "SynapseProPlugin",
+    # Defaults
+    "DefaultImportanceScorer",
+    "DefaultConflictResolver",
+    "DefaultDedupStrategy",
+    # Loader
+    "load_pro_plugin",
+]

synapse_memory/plugins/defaults.py

@@ -0,0 +1,80 @@
+"""
+Synapse Layer — Default OSS Implementations
+
+Baseline strategies that provide predictable, "good enough" behavior
+without any proprietary logic. Designed for transparency and simplicity.
+
+PRO implementations (ML-powered scoring, semantic dedup, conflict
+resolution) are available via ``synapse-layer-pro``.
+
+Author : Security & Architecture Team @ Synapse Layer
+License: Apache 2.0
+"""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import re
+from typing import List
+
+from synapse_memory.autosave.types import AutoSaveEvent
+
+
+class DefaultImportanceScorer:
+    """Baseline importance scorer.
+
+    Normalizes the integer importance (0–5) to a 0.0–1.0 float.
+    No heuristics, no ML — pure linear mapping.
+    """
+
+    def score(self, event: AutoSaveEvent) -> float:
+        """Return event.importance / 5.0, clamped to [0.0, 1.0]."""
+        raw = max(0, min(5, event.importance))
+        return round(raw / 5.0, 2)
+
+
+class DefaultConflictResolver:
+    """Baseline conflict resolver.
+
+    When multiple events compete, keeps the most recent one
+    (highest importance as tiebreaker).
+    """
+
+    def resolve(self, events: List[AutoSaveEvent]) -> AutoSaveEvent:
+        """Return the event with highest importance; last wins on tie."""
+        if not events:
+            raise ValueError("Cannot resolve empty event list")
+        return max(events, key=lambda e: (e.importance, id(e)))
+
+
+class DefaultDedupStrategy:
+    """Baseline deduplication via SHA-256 content hash.
+
+    Compares normalized (project + content + type) hashes.
+    No semantic analysis, no embedding similarity.
+    """
+
+    def is_duplicate(
+        self,
+        event: AutoSaveEvent,
+        recent_events: List[AutoSaveEvent],
+    ) -> bool:
+        """True if any recent event has identical normalized hash."""
+        event_hash = self._hash(event)
+        return any(self._hash(r) == event_hash for r in recent_events)
+
+    @staticmethod
+    def _hash(event: AutoSaveEvent) -> str:
+        """SHA-256 of normalized project + content + type."""
+        normalized = re.sub(r'\s+', ' ', event.content.strip().lower())
+        payload = json.dumps(
+            {
+                "project": event.project.upper(),
+                "content": normalized,
+                "type": event.type,
+            },
+            sort_keys=True,
+            ensure_ascii=False,
+        )
+        return hashlib.sha256(payload.encode()).hexdigest()