Complete adapter conformance coverage

src/phase_memory/adapters.py

@@ -260,6 +260,43 @@ class JsonlAuditSink:
         return {"recorded": True, "index": index, "event": stored}
 
 
+class InMemorySemanticIndex:
+    def __init__(self) -> None:
+        self._nodes_by_graph: dict[str, list[MemoryNode]] = {}
+
+    def upsert_nodes(self, nodes: list[MemoryNode]) -> dict[str, Any]:
+        for node in nodes:
+            graph_id = str(node.metadata.get("graph_id") or "local")
+            existing = [item for item in self._nodes_by_graph.get(graph_id, []) if item.node_id != node.node_id]
+            existing.append(node)
+            self._nodes_by_graph[graph_id] = sorted(existing, key=lambda item: item.node_id)
+        return {"upserted": len(nodes)}
+
+    def query(self, *, graph_id: str, query: str, limit: int = 10) -> list[dict[str, Any]]:
+        terms = {term.lower() for term in query.split() if term.strip()}
+        results: list[dict[str, Any]] = []
+        for node in self._nodes_by_graph.get(graph_id, []):
+            text = f"{node.kind} {node.text}".lower()
+            score = sum(1 for term in terms if term in text)
+            if score:
+                results.append({"id": node.node_id, "score": score, "kind": node.kind})
+        return sorted(results, key=lambda item: (-item["score"], item["id"]))[:limit]
+
+
+class InMemoryRuntimeRegistry:
+    def __init__(self) -> None:
+        self._envelopes: dict[str, dict[str, Any]] = {}
+
+    def publish_runtime_envelope(self, envelope: dict[str, Any]) -> dict[str, Any]:
+        reference = str(envelope.get("operation_id") or envelope.get("id") or f"envelope:{len(self._envelopes)}")
+        stored = dict(envelope)
+        self._envelopes[reference] = stored
+        return {"published": True, "reference": reference, "envelope": stored}
+
+    def fetch_runtime_envelope(self, reference: str) -> dict[str, Any]:
+        return dict(self._envelopes[reference])
+
+
 def _safe_name(identifier: str) -> str:
     safe = "".join(char if char.isalnum() or char in ("-", "_", ".") else "_" for char in identifier)
     return safe or "anonymous"

src/phase_memory/service.py

@@ -5,7 +5,15 @@ from __future__ import annotations
 from dataclasses import dataclass, field
 from typing import Any
 
-from .adapters import AllowAllPolicyGateway, InMemoryMemoryEventLog, InMemoryMemoryGraphStore, NoopContextPackageCompiler, RecordingAuditSink
+from .adapters import (
+    AllowAllPolicyGateway,
+    InMemoryMemoryEventLog,
+    InMemoryMemoryGraphStore,
+    InMemoryRuntimeRegistry,
+    InMemorySemanticIndex,
+    NoopContextPackageCompiler,
+    RecordingAuditSink,
+)
 from .models import Diagnostic, MemoryEvent, MemoryNode, PolicyDecision, ProfileIntent
 from .runtime import PhaseMemoryRuntime
 
@@ -179,6 +187,22 @@ def assert_audit_sink_conformance(sink) -> None:
     assert receipt.get("recorded") is True
 
 
+def assert_semantic_index_conformance(index) -> None:
+    node = MemoryNode("node.semantic", "decision", "Conformance search target", metadata={"graph_id": "graph.conformance"})
+    receipt = index.upsert_nodes([node])
+    results = index.query(graph_id="graph.conformance", query="search target", limit=5)
+    assert receipt.get("upserted") == 1
+    assert results and results[0]["id"] == node.node_id
+
+
+def assert_runtime_registry_conformance(registry) -> None:
+    envelope = {"operation_id": "op.conformance", "operation": "conformance"}
+    receipt = registry.publish_runtime_envelope(envelope)
+    fetched = registry.fetch_runtime_envelope(receipt["reference"])
+    assert receipt["published"] is True
+    assert fetched["operation_id"] == "op.conformance"
+
+
 def default_conformance_adapters() -> dict[str, Any]:
     return {
         "graph_store": InMemoryMemoryGraphStore(),
@@ -186,4 +210,6 @@ def default_conformance_adapters() -> dict[str, Any]:
         "context_compiler": NoopContextPackageCompiler(),
         "policy_gateway": AllowAllPolicyGateway(),
         "audit_sink": RecordingAuditSink(),
+        "semantic_index": InMemorySemanticIndex(),
+        "runtime_registry": InMemoryRuntimeRegistry(),
     }