Add fake external adapter packs

src/phase_memory/__init__.py

@@ -10,6 +10,18 @@ from .bridge import (
     package_response_envelope,
 )
 from .contracts import graph_from_markitect, profile_from_markitect
+from .external_adapters import (
+    ExternalAdapterPack,
+    FakeExternalEventLog,
+    FakeExternalGraphStore,
+    FakeExternalPolicyGateway,
+    FakeExternalSemanticIndex,
+    FakeKontextualRuntimeRegistry,
+    FakeMarkitectPackageCompiler,
+    FakeTelemetryAuditSink,
+    fake_external_adapter_pack,
+    fake_external_runtime_config,
+)
 from .lifecycle import (
     LifecycleRuleConfig,
     PhaseTransitionRule,
@@ -58,6 +70,14 @@ from .runtime import PhaseMemoryRuntime
 __all__ = [
     "ActivationPlan",
     "Diagnostic",
+    "ExternalAdapterPack",
+    "FakeExternalEventLog",
+    "FakeExternalGraphStore",
+    "FakeExternalPolicyGateway",
+    "FakeExternalSemanticIndex",
+    "FakeKontextualRuntimeRegistry",
+    "FakeMarkitectPackageCompiler",
+    "FakeTelemetryAuditSink",
     "LifecycleAction",
     "LifecycleActionKind",
     "LifecycleState",
@@ -101,6 +121,8 @@ __all__ = [
     "plan_retention",
     "plan_retention_from_rules",
     "profile_from_markitect",
+    "fake_external_adapter_pack",
+    "fake_external_runtime_config",
     "path_event",
     "package_request_from_selection",
     "package_response_envelope",

src/phase_memory/external_adapters.py

@@ -0,0 +1,160 @@
+"""Fake external adapter pack for service-readiness integration tests."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any
+
+from .adapters import InMemoryMemoryEventLog, InMemoryMemoryGraphStore, InMemorySemanticIndex
+from .models import PolicyDecision
+from .service import RuntimeConfig
+from .utils import stable_digest
+
+
+@dataclass(frozen=True)
+class ExternalAdapterPack:
+    name: str
+    adapters: dict[str, Any]
+    capabilities: tuple[str, ...] = ()
+    metadata: dict[str, Any] = field(default_factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "name": self.name,
+            "adapters": {key: value.__class__.__name__ for key, value in sorted(self.adapters.items())},
+            "capabilities": list(self.capabilities),
+            "metadata": dict(self.metadata),
+        }
+
+
+class FakeExternalGraphStore(InMemoryMemoryGraphStore):
+    """Kontextual-shaped graph store fake backed by deterministic memory."""
+
+
+class FakeExternalEventLog(InMemoryMemoryEventLog):
+    """Kontextual-shaped event log fake backed by deterministic memory."""
+
+
+class FakeExternalSemanticIndex(InMemorySemanticIndex):
+    """Permission-aware retrieval fake with the local deterministic index shape."""
+
+
+class FakeMarkitectPackageCompiler:
+    def compile_selection(self, selection: dict[str, Any]) -> dict[str, Any]:
+        selection_id = str(selection.get("id") or "selection")
+        package_id = f"fake-markitect:{stable_digest(selection)}"
+        return {
+            "package_id": package_id,
+            "package_ref": package_id,
+            "compiler": self.__class__.__name__,
+            "selection_id": selection_id,
+            "item_count": len(selection.get("nodes", ())) + len(selection.get("events", ())),
+            "diagnostics": [],
+            "selection": dict(selection),
+        }
+
+
+class FakeExternalPolicyGateway:
+    def __init__(self, *, deny_actions: tuple[str, ...] = ()) -> None:
+        self.deny_actions = set(deny_actions)
+
+    def authorize(self, *, action: str, resource: str, context: dict[str, Any] | None = None) -> PolicyDecision:
+        allowed = action not in self.deny_actions
+        return PolicyDecision(
+            allowed,
+            reason="fake external policy allowed" if allowed else "fake external policy denied",
+            metadata={
+                "adapter": self.__class__.__name__,
+                "action": action,
+                "resource": resource,
+                "context": context or {},
+            },
+        )
+
+
+class FakeTelemetryAuditSink:
+    def __init__(self, *, retention_days: int = 30) -> None:
+        self.retention_days = retention_days
+        self.events: list[dict[str, Any]] = []
+
+    def record(self, event: dict[str, Any]) -> dict[str, Any]:
+        external_ref = f"fake-audit:{stable_digest([len(self.events), event])}"
+        stored = {
+            **dict(event),
+            "external_ref": external_ref,
+            "retention_days": self.retention_days,
+        }
+        self.events.append(stored)
+        return {
+            "recorded": True,
+            "external_ref": external_ref,
+            "retention_days": self.retention_days,
+            "event": stored,
+        }
+
+    def query(self, *, operation: str | None = None) -> list[dict[str, Any]]:
+        if operation is None:
+            return list(self.events)
+        return [event for event in self.events if event.get("operation") == operation]
+
+
+class FakeKontextualRuntimeRegistry:
+    def __init__(self) -> None:
+        self._envelopes: dict[str, dict[str, Any]] = {}
+
+    def publish_runtime_envelope(self, envelope: dict[str, Any]) -> dict[str, Any]:
+        reference = f"fake-kontextual:{stable_digest(envelope)}"
+        stored = dict(envelope)
+        self._envelopes[reference] = stored
+        return {
+            "published": True,
+            "reference": reference,
+            "adapter": self.__class__.__name__,
+            "envelope": stored,
+        }
+
+    def fetch_runtime_envelope(self, reference: str) -> dict[str, Any]:
+        return dict(self._envelopes[reference])
+
+
+def fake_external_adapter_pack() -> ExternalAdapterPack:
+    return ExternalAdapterPack(
+        name="fake-external",
+        adapters={
+            "graph_store": FakeExternalGraphStore(),
+            "event_log": FakeExternalEventLog(),
+            "policy_gateway": FakeExternalPolicyGateway(),
+            "audit_sink": FakeTelemetryAuditSink(),
+            "package_compiler": FakeMarkitectPackageCompiler(),
+            "semantic_index": FakeExternalSemanticIndex(),
+            "runtime_registry": FakeKontextualRuntimeRegistry(),
+        },
+        capabilities=(
+            "markitect.package.compile",
+            "kontextual.runtime.registry",
+            "kontextual.graph-store.fake",
+            "telemetry.audit.fake",
+            "semantic-index.fake",
+        ),
+        metadata={"intended_for": "local conformance and integration tests"},
+    )
+
+
+def fake_external_runtime_config() -> RuntimeConfig:
+    return RuntimeConfig(
+        adapter_registry={
+            "graph_store": "external",
+            "event_log": "external",
+            "policy_gateway": "external",
+            "audit_sink": "external",
+            "package_compiler": "external",
+            "semantic_index": "external",
+            "runtime_registry": "external",
+        },
+        policy_mode="external",
+        audit_sink_mode="external",
+        package_compiler_mode="external",
+        semantic_index_mode="external",
+        runtime_registry_mode="external",
+        trust_zone_labels=("external",),
+    )