prismcortex 0.2.1__tar.gz

prismcortex-0.2.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Amin Parva / Insight IT Solutions LLC
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

prismcortex-0.2.1/PKG-INFO

@@ -0,0 +1,175 @@
+Metadata-Version: 2.4
+Name: prismcortex
+Version: 0.2.1
+Summary: Deterministic, auditable, self-consolidating memory for AI agents
+Author-email: Amin Parva <info@insightits.com>
+Maintainer-email: Insight IT Solutions LLC <info@insightits.com>
+License: MIT License
+        
+        Copyright (c) 2026 Amin Parva / Insight IT Solutions LLC
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+        
+Project-URL: Homepage, https://www.insightits.com/products/prismcortex.html
+Project-URL: Documentation, https://github.com/insightitsGit/PrismCortex#readme
+Project-URL: Repository, https://github.com/insightitsGit/PrismCortex
+Project-URL: Bug Tracker, https://github.com/insightitsGit/PrismCortex/issues
+Keywords: llm,memory,agents,knowledge-graph,deterministic,rag,bitemporal,audit,agent-memory,compliance
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pydantic>=2.5
+Requires-Dist: numpy>=1.24
+Requires-Dist: cryptography>=42
+Provides-Extra: prism
+Requires-Dist: prismlang>=0.1.1; extra == "prism"
+Requires-Dist: prismlib>=0.4.0; extra == "prism"
+Requires-Dist: prismrag-patch>=0.2.1; extra == "prism"
+Requires-Dist: prismresonance>=0.3.0; extra == "prism"
+Provides-Extra: gemini
+Requires-Dist: google-genai>=0.3.0; extra == "gemini"
+Provides-Extra: server
+Requires-Dist: fastapi>=0.110; extra == "server"
+Requires-Dist: uvicorn[standard]>=0.27; extra == "server"
+Provides-Extra: dev
+Requires-Dist: pytest>=7; extra == "dev"
+Requires-Dist: google-genai>=0.3.0; extra == "dev"
+Requires-Dist: fastapi>=0.110; extra == "dev"
+Requires-Dist: uvicorn[standard]>=0.27; extra == "dev"
+Requires-Dist: httpx>=0.27; extra == "dev"
+Provides-Extra: bench
+Requires-Dist: mem0ai>=2.0; extra == "bench"
+Requires-Dist: zep-cloud>=2.0; extra == "bench"
+Dynamic: license-file
+
+# PrismCortex
+
+**Deterministic, auditable, self-consolidating memory for AI agents.**
+
+Most agent "memory" is an append-only chat log that you stuff back into the context
+window until it overflows. PrismCortex does what a brain does instead: it **digests**
+each turn into a knowledge graph, **consolidates** uncertain facts in the background
+(like sleep), and demotes the LLM from *thinker* to *renderer* — it only paints the
+facts you hand it. Change the memory and only the affected answers change; everything
+is traceable to the exact facts and source events behind it.
+
+It's the orchestration layer over five shipped Insight ITS packages — PrismLang,
+PrismRAG, PrismResonance, PrismLib, and Chorus Fabric — behind one tiny API.
+
+```python
+from prismcortex import reference_memory
+
+mem = reference_memory(cache_path=".prismcortex_cache/demo.json")
+
+mem.digest("My production deploy budget is $40,000.")
+print(mem.recall("What's my deploy budget?").answer)        # → "$40,000"
+
+mem.digest("Correction: my deploy budget is now $55,000.")  # fast-tracked (ALERT)
+print(mem.recall("What's my deploy budget?").answer)        # → "$55,000"
+# …and the $40,000 fact is still on record, time-stamped, for audit/time-travel.
+```
+
+## Why it's different
+
+| | Append-only RAG | PrismCortex |
+|---|---|---|
+| Storage | every chat turn | graph topology (the *gist*) |
+| Updates | append + hope retrieval ranks it | bitemporal: invalidate old, add new, keep history |
+| Determinism | none (logs + LLM both drift) | content-addressed render cache, replay-identical |
+| Cost | re-extract context every call | salience-gated writes, cached reads |
+| Audit | grep the logs | every answer → exact facts + source events |
+
+## What you get that a vector store can't
+
+| Capability | What it does |
+|---|---|
+| **Explainability** (`/explain`) | Every answer returns its **evidence trail** — the exact facts, their source events, and confidence. A vector store returns memories; only a provenance graph returns *evidence*. |
+| **Confidence + freshness** | Each recall reports how reinforced its facts are (0–1) and when they were last confirmed. |
+| **Time-travel / audit** | Corrections invalidate but **retain** the old fact as a queryable bitemporal record (a paid feature in Mem0 OSS). |
+| **Bounded memory** | `sleep()` prunes the coldest facts to a cap — the active set **plateaus** instead of growing forever; pruned facts are kept for audit. |
+| **~12× smaller index** | 128-dim vectors vs the 1536–3072-dim default elsewhere; plus entity-dedup. |
+| **Sovereign** | Self-hosted, your data, offline-keyed — no third-party SaaS. |
+
+These are validated in `benchmarks/` (incl. a fair head-to-head vs Mem0 in `vs_mem0.py`).
+
+## Determinism, honestly
+
+We do **not** claim "temperature 0 → identical output" — that's false for any shared
+API model (batching + floating-point non-associativity flip near-tied tokens). Instead:
+
+- **Content-addressed rendering.** The cache key is a hash of the exact retrieved
+  subgraph + query + template + **pinned model snapshot**. The model is invoked at most
+  once per unique (query, memory-version); its answer is frozen and replayed
+  byte-for-byte. A changed fact changes the key, so a stale answer is *unreachable* —
+  invalidation and determinism are the same mechanism.
+- **Extractive facts.** Numbers, names, ids, and dates are substituted from the graph,
+  not generated, and a verification pass rejects fabricated values — so the *facts* are
+  deterministic even on the first render; only prose phrasing can vary (then it's frozen).
+
+Scope: replay-determinism, pinned model snapshot, snapshot sources (not live feeds).
+First-render *token* determinism requires the self-hosted sovereign tier. See
+[`DESIGN.md`](DESIGN.md) §2.
+
+## Architecture (one engine, five swappable ports)
+
+```
+digest(text) ─▶ salience gate ─▶ extract gist ─▶ delta in RAM
+                                                   ├─ certain / urgent ─▶ commit  (version++)
+                                                   └─ uncertain ───────▶ staging buffer
+                                                                              │ sleep()
+                                                                       consolidate ─▶ commit (version++)
+
+recall(query) ─▶ retrieve subgraph @version ─▶ content-address ─▶ cache hit? replay
+                                                                  miss? render once → freeze
+```
+
+| Port | Reference adapter | Production (`pip install prismcortex[prism]`) |
+|---|---|---|
+| Gist projection | hashing-trick embeddings | `prismlang` |
+| Graph store (bitemporal) | in-memory | `prismrag-patch` |
+| Weight / salience / sleep | in-process | `prismresonance` |
+| Render cache (durable) | JSON file | `prismlib` (cache-as-failover) |
+| Mesh broadcast | in-process | `prismlib` cluster / Chorus |
+| Extraction + rendering | — | **real Gemini** (`prismcortex[gemini]`) |
+
+## Install & test
+
+```bash
+pip install -e .                      # core
+pip install -e ".[gemini]"            # + real Gemini extraction/rendering
+
+pytest tests/test_graph_engine.py     # deterministic substrate — no API key
+GEMINI_API_KEY=... pytest             # full end-to-end with real Gemini
+```
+
+## Licensing
+
+Open-core (MIT). The core (`digest`/`recall`, bitemporal graph, determinism cache) is
+free. Commercial modules (audit console, consolidation-at-scale, multi-agent mesh, the
+sovereign determinism tier) are gated by an **offline signed license key** — no
+phone-home, works air-gapped. See [`DESIGN.md`](DESIGN.md) §7.

prismcortex-0.2.1/README.md

@@ -0,0 +1,106 @@
+# PrismCortex
+
+**Deterministic, auditable, self-consolidating memory for AI agents.**
+
+Most agent "memory" is an append-only chat log that you stuff back into the context
+window until it overflows. PrismCortex does what a brain does instead: it **digests**
+each turn into a knowledge graph, **consolidates** uncertain facts in the background
+(like sleep), and demotes the LLM from *thinker* to *renderer* — it only paints the
+facts you hand it. Change the memory and only the affected answers change; everything
+is traceable to the exact facts and source events behind it.
+
+It's the orchestration layer over five shipped Insight ITS packages — PrismLang,
+PrismRAG, PrismResonance, PrismLib, and Chorus Fabric — behind one tiny API.
+
+```python
+from prismcortex import reference_memory
+
+mem = reference_memory(cache_path=".prismcortex_cache/demo.json")
+
+mem.digest("My production deploy budget is $40,000.")
+print(mem.recall("What's my deploy budget?").answer)        # → "$40,000"
+
+mem.digest("Correction: my deploy budget is now $55,000.")  # fast-tracked (ALERT)
+print(mem.recall("What's my deploy budget?").answer)        # → "$55,000"
+# …and the $40,000 fact is still on record, time-stamped, for audit/time-travel.
+```
+
+## Why it's different
+
+| | Append-only RAG | PrismCortex |
+|---|---|---|
+| Storage | every chat turn | graph topology (the *gist*) |
+| Updates | append + hope retrieval ranks it | bitemporal: invalidate old, add new, keep history |
+| Determinism | none (logs + LLM both drift) | content-addressed render cache, replay-identical |
+| Cost | re-extract context every call | salience-gated writes, cached reads |
+| Audit | grep the logs | every answer → exact facts + source events |
+
+## What you get that a vector store can't
+
+| Capability | What it does |
+|---|---|
+| **Explainability** (`/explain`) | Every answer returns its **evidence trail** — the exact facts, their source events, and confidence. A vector store returns memories; only a provenance graph returns *evidence*. |
+| **Confidence + freshness** | Each recall reports how reinforced its facts are (0–1) and when they were last confirmed. |
+| **Time-travel / audit** | Corrections invalidate but **retain** the old fact as a queryable bitemporal record (a paid feature in Mem0 OSS). |
+| **Bounded memory** | `sleep()` prunes the coldest facts to a cap — the active set **plateaus** instead of growing forever; pruned facts are kept for audit. |
+| **~12× smaller index** | 128-dim vectors vs the 1536–3072-dim default elsewhere; plus entity-dedup. |
+| **Sovereign** | Self-hosted, your data, offline-keyed — no third-party SaaS. |
+
+These are validated in `benchmarks/` (incl. a fair head-to-head vs Mem0 in `vs_mem0.py`).
+
+## Determinism, honestly
+
+We do **not** claim "temperature 0 → identical output" — that's false for any shared
+API model (batching + floating-point non-associativity flip near-tied tokens). Instead:
+
+- **Content-addressed rendering.** The cache key is a hash of the exact retrieved
+  subgraph + query + template + **pinned model snapshot**. The model is invoked at most
+  once per unique (query, memory-version); its answer is frozen and replayed
+  byte-for-byte. A changed fact changes the key, so a stale answer is *unreachable* —
+  invalidation and determinism are the same mechanism.
+- **Extractive facts.** Numbers, names, ids, and dates are substituted from the graph,
+  not generated, and a verification pass rejects fabricated values — so the *facts* are
+  deterministic even on the first render; only prose phrasing can vary (then it's frozen).
+
+Scope: replay-determinism, pinned model snapshot, snapshot sources (not live feeds).
+First-render *token* determinism requires the self-hosted sovereign tier. See
+[`DESIGN.md`](DESIGN.md) §2.
+
+## Architecture (one engine, five swappable ports)
+
+```
+digest(text) ─▶ salience gate ─▶ extract gist ─▶ delta in RAM
+                                                   ├─ certain / urgent ─▶ commit  (version++)
+                                                   └─ uncertain ───────▶ staging buffer
+                                                                              │ sleep()
+                                                                       consolidate ─▶ commit (version++)
+
+recall(query) ─▶ retrieve subgraph @version ─▶ content-address ─▶ cache hit? replay
+                                                                  miss? render once → freeze
+```
+
+| Port | Reference adapter | Production (`pip install prismcortex[prism]`) |
+|---|---|---|
+| Gist projection | hashing-trick embeddings | `prismlang` |
+| Graph store (bitemporal) | in-memory | `prismrag-patch` |
+| Weight / salience / sleep | in-process | `prismresonance` |
+| Render cache (durable) | JSON file | `prismlib` (cache-as-failover) |
+| Mesh broadcast | in-process | `prismlib` cluster / Chorus |
+| Extraction + rendering | — | **real Gemini** (`prismcortex[gemini]`) |
+
+## Install & test
+
+```bash
+pip install -e .                      # core
+pip install -e ".[gemini]"            # + real Gemini extraction/rendering
+
+pytest tests/test_graph_engine.py     # deterministic substrate — no API key
+GEMINI_API_KEY=... pytest             # full end-to-end with real Gemini
+```
+
+## Licensing
+
+Open-core (MIT). The core (`digest`/`recall`, bitemporal graph, determinism cache) is
+free. Commercial modules (audit console, consolidation-at-scale, multi-agent mesh, the
+sovereign determinism tier) are gated by an **offline signed license key** — no
+phone-home, works air-gapped. See [`DESIGN.md`](DESIGN.md) §7.

prismcortex-0.2.1/prismcortex/__init__.py

@@ -0,0 +1,40 @@
+"""PrismCortex — deterministic, auditable, self-consolidating memory for AI agents.
+
+    from prismcortex import reference_memory
+    mem = reference_memory()                      # reference adapters + real Gemini
+    mem.digest("My deploy budget is $40k.")
+    mem.recall("What's my deploy budget?").answer
+
+Swap the reference adapters for the real Insight ITS packages (prismlang, prismrag,
+prismresonance, prismlib, Chorus) one port at a time — the engine never changes.
+"""
+from .engine import Memory
+from .factory import reference_memory
+from .models import (
+    Band,
+    DigestOutcome,
+    DigestResult,
+    Edge,
+    GraphVersion,
+    Node,
+    RecallResult,
+    StateDelta,
+    Subgraph,
+)
+
+__version__ = "0.2.1"
+
+__all__ = [
+    "Memory",
+    "reference_memory",
+    "Band",
+    "DigestOutcome",
+    "DigestResult",
+    "RecallResult",
+    "Node",
+    "Edge",
+    "Subgraph",
+    "StateDelta",
+    "GraphVersion",
+    "__version__",
+]

prismcortex-0.2.1/prismcortex/adapters/__init__.py

@@ -0,0 +1,20 @@
+"""Adapters that satisfy the PrismCortex ports."""
+from .reference import (
+    DurableCache,
+    HashingProjector,
+    InMemoryGraphStore,
+    InProcessMesh,
+    InProcessResonance,
+    ListStaging,
+    LocalBlobStore,
+)
+
+__all__ = [
+    "DurableCache",
+    "HashingProjector",
+    "InMemoryGraphStore",
+    "InProcessMesh",
+    "InProcessResonance",
+    "ListStaging",
+    "LocalBlobStore",
+]

prismcortex-0.2.1/prismcortex/adapters/ann.py

@@ -0,0 +1,104 @@
+"""IVF-style ANN retrieval for graphs beyond ~10k nodes (numpy-only, no extra deps)."""
+from __future__ import annotations
+
+import os
+from typing import Optional
+
+import numpy as np
+
+from .reference import InMemoryGraphStore
+
+
+class AnnGraphStore(InMemoryGraphStore):
+    """In-memory bitemporal store with inverted-file ANN when node count exceeds threshold."""
+
+    def __init__(self, *, tenant_id: str = "default", ivf_threshold: Optional[int] = None, nlist: int = 256, nprobe: int = 16) -> None:
+        super().__init__()
+        self.tenant_id = tenant_id
+        self._ivf_threshold = ivf_threshold or int(os.environ.get("PRISMCORTEX_ANN_THRESHOLD", "5000"))
+        self._nlist = nlist
+        self._nprobe = nprobe
+        self._centroids: Optional[np.ndarray] = None
+        self._inverted: list[list[str]] = []
+        self._ivf_dirty = True
+
+    def _rebuild_ivf(self) -> None:
+        self._ensure_matrix()
+        if self._emb_unit is None or len(self._emb_ids) < self._ivf_threshold:
+            self._centroids = None
+            self._inverted = []
+            self._ivf_dirty = False
+            return
+        n, d = self._emb_unit.shape
+        k = min(self._nlist, max(8, n // 40))
+        rng = np.random.default_rng(42)
+        idx = rng.choice(n, size=k, replace=False)
+        self._centroids = self._emb_unit[idx].copy()
+        # Lloyd-lite: 3 iterations
+        for _ in range(3):
+            sims = self._emb_unit @ self._centroids.T
+            assign = np.argmax(sims, axis=1)
+            for c in range(k):
+                mask = assign == c
+                if mask.any():
+                    self._centroids[c] = self._emb_unit[mask].mean(axis=0)
+                    cn = np.linalg.norm(self._centroids[c]) or 1.0
+                    self._centroids[c] /= cn
+        self._inverted = [[] for _ in range(k)]
+        sims = self._emb_unit @ self._centroids.T
+        assign = np.argmax(sims, axis=1)
+        for i, c in enumerate(assign):
+            self._inverted[int(c)].append(self._emb_ids[i])
+        self._ivf_dirty = False
+
+    def _ensure_matrix(self) -> None:
+        super()._ensure_matrix()
+        if self._matrix_dirty:
+            self._ivf_dirty = True
+
+    def apply(self, delta):
+        v = super().apply(delta)
+        self._ivf_dirty = True
+        return v
+
+    def retrieve(self, embedding: list[float], k: int = 8):
+        if not self._nodes:
+            return super().retrieve(embedding, k)
+        self._ensure_matrix()
+        if self._emb_unit is None:
+            return super().retrieve(embedding, k)
+        if len(self._emb_ids) < self._ivf_threshold:
+            return super().retrieve(embedding, k)
+        if self._ivf_dirty:
+            self._rebuild_ivf()
+        if self._centroids is None:
+            return super().retrieve(embedding, k)
+
+        q = np.asarray(embedding, dtype=np.float32)
+        qn = float(np.linalg.norm(q)) or 1.0
+        q = q / qn
+        csim = self._centroids @ q
+        n = len(self._emb_ids)
+        # Scale probe depth with graph size (more clusters searched at 50k+ nodes).
+        nprobe = min(len(csim), max(self._nprobe, n // 2000))
+        probe = np.argsort(-csim, kind="stable")[:nprobe]
+        candidates: set[str] = set()
+        id_to_row = {nid: i for i, nid in enumerate(self._emb_ids)}
+        for c in probe:
+            for nid in self._inverted[int(c)]:
+                candidates.add(nid)
+        if not candidates:
+            return super().retrieve(embedding, k)
+
+        rows = [id_to_row[nid] for nid in candidates if nid in id_to_row]
+        sims = self._emb_unit[rows] @ q
+        order = np.argsort(-sims, kind="stable")[: min(k, len(rows))]
+        chosen = {self._emb_ids[rows[int(i)]] for i in order}
+
+        edges = [e for e in self._edges.values() if e.is_current and (e.src in chosen or e.dst in chosen)]
+        for e in edges:
+            chosen.add(e.src)
+            chosen.add(e.dst)
+        nodes = [self._nodes[n] for n in chosen if n in self._nodes]
+        from ..models import Subgraph
+        return Subgraph(nodes=nodes, edges=edges)

prismcortex-0.2.1/prismcortex/adapters/prism.py

@@ -0,0 +1,174 @@
+"""Production adapters — the real Insight ITS packages behind the ports.
+
+Import-guarded so the OSS core stays installable without them (`pip install
+prismcortex[prism]`). Each class wraps exactly one package:
+
+  - PrismLangProjector  → prismlang.PrismProjector   (deterministic, CPU-stable vectors)
+  - PrismResonanceAdapter → prismresonance.PrismResonance (wavepacket weight + sleep)
+  - PrismLibCache       → prismlib SQLiteStore        (durable cache-as-failover)
+
+The bitemporal GraphStore stays PrismCortex-owned (the reference store *is* the design
+— prismrag-patch is a retrieval governor, not a bitemporal database, so it slots in as
+a recall-time filter rather than the store itself). The Chorus/prismlib cluster mesh is
+the remaining seam; InProcessMesh stands in until it's wired.
+"""
+from __future__ import annotations
+
+import os
+import time
+from typing import Optional
+
+import numpy as np
+
+
+class PrismLangProjector:
+    """GistProjector via prismlang.PrismProjector.
+
+    project() returns (category_slug, vector, trace). The vector is all-MiniLM-L6-v2
+    JL-reduced with a seed derived from tenant_id — deterministic given a fixed tenant,
+    which is exactly the CPU-stable projection the read-path determinism contract needs.
+    """
+
+    def __init__(self, taxonomy=None, tenant_id: str = "prismcortex", k: int = 128) -> None:
+        # k = projection dimension. PrismLang defaults to 64, which crowds at scale
+        # (retrieval recall drops to ~0.86 at 3k facts); 128 restores it to ~0.97 with no
+        # latency cost. See benchmarks/scale_bench.py.
+        from prismlang import Category, PrismProjector, TaxonomyConfig
+
+        if taxonomy is None:
+            taxonomy = TaxonomyConfig(categories=[
+                Category("general", "General", ["the", "a", "is", "of", "to"]),
+                Category("preference", "Preference", ["like", "prefer", "favorite", "want", "hate"]),
+                Category("fact", "Fact", ["is", "are", "has", "budget", "name", "id", "number"]),
+                Category("tech", "Tech", ["deploy", "database", "server", "region", "api", "model"]),
+            ])
+        self._p = PrismProjector(taxonomy, tenant_id=tenant_id, k=k)
+        _, probe, _ = self._p.project("dimension probe")
+        self.dim = len(probe)
+
+    def embed(self, text: str) -> list[float]:
+        _, vec, _ = self._p.project(text)
+        return [float(x) for x in vec]
+
+    def classify(self, text: str) -> str:
+        cat, _, _ = self._p.project(text)
+        return cat
+
+
+class PrismResonanceAdapter:
+    """ResonanceEngine via prismresonance.PrismResonance (compiles an ONNX graph on
+    first construction; writes a small state db)."""
+
+    def __init__(self, embedding_dim: int, state_path: str = "resonance_state.db", onnx_path: str = "resonance_engine.onnx") -> None:
+        from prismresonance import PrismResonance
+        from prismresonance.frequency import FrequencyFamily
+
+        self._FF = FrequencyFamily
+        self._r = PrismResonance.create(embedding_dim=embedding_dim, state_path=state_path, onnx_path=onnx_path)
+        self._amps: dict[str, np.ndarray] = {}  # kept so reinforce can re-ingest
+
+    def _freq(self, band: str):
+        return getattr(self._FF, band, self._FF.NEUTRAL)
+
+    def ingest(self, chunk_id: str, amplitude: list[float], band: str) -> None:
+        amp = np.asarray(amplitude, dtype=np.float32)
+        if amp.size == 0:
+            return
+        self._amps[chunk_id] = amp
+        self._r.ingest(chunk_id, amp, self._freq(band))
+
+    def reinforce(self, chunk_id: str) -> None:
+        amp = self._amps.get(chunk_id)
+        if amp is not None:  # re-ingest at higher salience ≈ LTP
+            self._r.ingest(chunk_id, amp, self._FF.ALERT)
+
+    def rank(self, candidate_ids: list[str]) -> list[str]:
+        return list(candidate_ids)  # resonance ordering is not on the determinism path
+
+    def consolidate(self) -> None:
+        self._r.sleep()
+
+    def shutdown(self) -> None:
+        try:
+            self._r.shutdown()
+        except Exception:
+            pass
+
+
+class PrismLibCache:
+    """ResponseCache via prismlib SQLiteStore — exact-key, durable (cache-as-failover).
+
+    packet_id carries our content-address; response carries the frozen answer. Durable
+    by file path so a frozen answer survives restart and cache eviction.
+    """
+
+    _TEN_YEARS = 10 * 365 * 24 * 3600
+
+    def __init__(self, db_path: str = ".prismcortex_cache/prismlib.db") -> None:
+        from prism.cache import CacheEntry, SQLiteStore
+
+        os.makedirs(os.path.dirname(db_path) or ".", exist_ok=True)
+        self._CacheEntry = CacheEntry
+        self._db_path = db_path
+        self._store = SQLiteStore(db_path=db_path)
+
+    def get(self, key: str) -> Optional[str]:
+        entry = self._store.load(key)
+        return entry.response if entry else None
+
+    def has(self, key: str) -> bool:
+        return self._store.load(key) is not None
+
+    def put(self, key: str, value: str) -> None:
+        now = time.time()
+        self._store.save(self._CacheEntry(
+            packet_id=key, query_text="", response=value,
+            created_at=now, expires_at=now + self._TEN_YEARS,
+        ))
+
+    def clear(self) -> None:
+        """Drop all cached answers (recreate the store) — used on erasure."""
+        from prism.cache import SQLiteStore
+
+        try:
+            self._store.close()
+        except Exception:  # noqa: BLE001
+            pass
+        if self._db_path != ":memory:" and os.path.exists(self._db_path):
+            os.remove(self._db_path)
+        self._store = SQLiteStore(db_path=self._db_path)
+
+
+def prism_memory(
+    *,
+    model: Optional[str] = None,
+    cache_db: str = ".prismcortex_cache/prismlib.db",
+    tenant_id: str = "prismcortex",
+    resonance_state: str = ".prismcortex_cache/resonance_state.db",
+    resonance_onnx: str = ".prismcortex_cache/resonance_engine.onnx",
+    k: int = 8,
+):
+    """Production-wired Memory: real PrismLang + PrismResonance + PrismLib + Gemini.
+
+    GraphStore + Mesh remain the reference (PrismCortex-owned bitemporal store; mesh is
+    the open Chorus seam). Needs prismcortex[prism], prismcortex[gemini], and a key.
+    """
+    from ..engine import Memory
+    from ..llm.gemini import GeminiClient
+    from .reference import InMemoryGraphStore, InProcessMesh, ListStaging
+
+    projector = PrismLangProjector(tenant_id=tenant_id)
+    resonance = PrismResonanceAdapter(embedding_dim=projector.dim, state_path=resonance_state, onnx_path=resonance_onnx)
+    cache = PrismLibCache(db_path=cache_db)
+    gemini = GeminiClient(model=model)
+    return Memory(
+        projector=projector,
+        extractor=gemini,
+        renderer=gemini,
+        store=InMemoryGraphStore(),
+        resonance=resonance,
+        cache=cache,
+        mesh=InProcessMesh(),
+        staging=ListStaging(),
+        k=k,
+    )