graph-mind-memory 0.5.4__tar.gz → 0.5.5__tar.gz

{graph_mind_memory-0.5.4 → graph_mind_memory-0.5.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: graph-mind-memory
-Version: 0.5.4
+Version: 0.5.5
 Summary: Local-first memory for AI coding assistants: verbatim, on your own PC, no LLM calls at write time.
 Author-email: Yohan Ko <goyohan0611@gmail.com>
 License-Expression: AGPL-3.0-only
@@ -31,8 +31,9 @@ Dynamic: license-file
 
 # Graph-MIND
 
-Local-first memory for AI coding assistants. Verbatim storage, on your own PC:
-**88.8% on LongMemEval with zero model calls at write time.**
+### Your AI forgets everything when the session ends. This one remembers, and it never calls an LLM to do it.
+
+**88.8% on LongMemEval. Zero model tokens spent saving memory. Runs on your own PC.**
 
 [![][license-shield]][license-link]
 [![][python-shield]][python-link]
@@ -41,7 +42,7 @@ Local-first memory for AI coding assistants. Verbatim storage, on your own PC:
 [![][ci-shield]][ci-link]
 [![][pypi-shield]][pypi-link]
 
-*Switch models; keep the memory.*
+*Decide something in Claude Code on Monday. Ask Codex on Wednesday. It knows.*
 
 <img src="demo/demo.gif" alt="A decision made in Claude Code on Monday, recalled from Codex on Wednesday" width="760">
 
@@ -49,6 +50,30 @@ Local-first memory for AI coding assistants. Verbatim storage, on your own PC:
 
 </div>
 
+### The part that sounds wrong
+
+Same 40 questions, same answer model, same prompt, same official judge, pre-registered before
+anyone looked:
+
+| | accuracy | model tokens spent **saving** memory, per question |
+|---|---|---|
+| **Graph-MIND** | **85.0%** | **0** |
+| MemPalace 3.10.0 | 57.5% | 0 |
+| Mem0 2.2.1 (open source) | 52.5% | ~640,000 |
+
+Mem0 runs an LLM over your conversations to decide what to keep. Graph-MIND keeps them word for
+word and finds the right part when you ask. It is cheaper, and in this test it was also more
+accurate.
+
+**Don't believe it? Good.** Every question, answer and judge verdict is in
+[`research/runs/`](research/runs), and [REPORT.md](research/REPORT.md) shows how to rerun it,
+including the runs that went wrong. Or just try it on your own conversations:
+
+```bash
+pip install graph-mind-memory
+graph-mind-install          # connects Claude Code, Codex, Claude Desktop, Cursor, VS Code, ...
+```
+
 > [!NOTE]
 > **Alpha.** Windows: used daily, with full end-to-end checks (fresh install, two PCs, real
 > Claude and Codex). macOS and Linux: tests and a clean install from PyPI pass in CI on every
@@ -89,16 +114,11 @@ official gpt-4o-2024-08-06.
 | **All 500 questions** | **88.8%** (444/500) | **0** | 3.4k tokens |
 | The 380 never used for tuning | **86.8%** (330/380) | 0 | 3.4k tokens |
 
-**Head to head: same 40 questions, same answer model, prompt and judge.** The run was
-pre-registered with code hashes; nobody had tuned on these questions.
-
-| system | accuracy | model tokens at write time, per question |
-|---|---|---|
-| **Graph-MIND** (shipped path, earlier 20-item packet) | **85.0%** | **0** |
-| MemPalace 3.10.0 | 57.5% | 0 |
-| Mem0 2.2.1 (open source, latest on PyPI) | 52.5% | ~640k |
-
-Graph-MIND's lead over both is significant (exact McNemar p = 0.002 and 0.003).
+**Head to head** ([table above](#the-part-that-sounds-wrong)): the run was pre-registered with
+code hashes, and nobody had tuned on those 40 questions. Graph-MIND ran its shipped path with the
+earlier 20-item packet; Mem0 2.2.1 was the latest open-source release on PyPI. Graph-MIND's lead
+over both is significant (exact McNemar p = 0.002 and 0.003); with 40 questions, each score has an
+interval of about ±14 points.
 
 **Reading other published numbers.** They measure different things, so they do not compare
 directly with the tables above:

{graph_mind_memory-0.5.4 → graph_mind_memory-0.5.5}/README.md

@@ -3,8 +3,9 @@
 
 # Graph-MIND
 
-Local-first memory for AI coding assistants. Verbatim storage, on your own PC:
-**88.8% on LongMemEval with zero model calls at write time.**
+### Your AI forgets everything when the session ends. This one remembers, and it never calls an LLM to do it.
+
+**88.8% on LongMemEval. Zero model tokens spent saving memory. Runs on your own PC.**
 
 [![][license-shield]][license-link]
 [![][python-shield]][python-link]
@@ -13,7 +14,7 @@ Local-first memory for AI coding assistants. Verbatim storage, on your own PC:
 [![][ci-shield]][ci-link]
 [![][pypi-shield]][pypi-link]
 
-*Switch models; keep the memory.*
+*Decide something in Claude Code on Monday. Ask Codex on Wednesday. It knows.*
 
 <img src="demo/demo.gif" alt="A decision made in Claude Code on Monday, recalled from Codex on Wednesday" width="760">
 
@@ -21,6 +22,30 @@ Local-first memory for AI coding assistants. Verbatim storage, on your own PC:
 
 </div>
 
+### The part that sounds wrong
+
+Same 40 questions, same answer model, same prompt, same official judge, pre-registered before
+anyone looked:
+
+| | accuracy | model tokens spent **saving** memory, per question |
+|---|---|---|
+| **Graph-MIND** | **85.0%** | **0** |
+| MemPalace 3.10.0 | 57.5% | 0 |
+| Mem0 2.2.1 (open source) | 52.5% | ~640,000 |
+
+Mem0 runs an LLM over your conversations to decide what to keep. Graph-MIND keeps them word for
+word and finds the right part when you ask. It is cheaper, and in this test it was also more
+accurate.
+
+**Don't believe it? Good.** Every question, answer and judge verdict is in
+[`research/runs/`](research/runs), and [REPORT.md](research/REPORT.md) shows how to rerun it,
+including the runs that went wrong. Or just try it on your own conversations:
+
+```bash
+pip install graph-mind-memory
+graph-mind-install          # connects Claude Code, Codex, Claude Desktop, Cursor, VS Code, ...
+```
+
 > [!NOTE]
 > **Alpha.** Windows: used daily, with full end-to-end checks (fresh install, two PCs, real
 > Claude and Codex). macOS and Linux: tests and a clean install from PyPI pass in CI on every
@@ -61,16 +86,11 @@ official gpt-4o-2024-08-06.
 | **All 500 questions** | **88.8%** (444/500) | **0** | 3.4k tokens |
 | The 380 never used for tuning | **86.8%** (330/380) | 0 | 3.4k tokens |
 
-**Head to head: same 40 questions, same answer model, prompt and judge.** The run was
-pre-registered with code hashes; nobody had tuned on these questions.
-
-| system | accuracy | model tokens at write time, per question |
-|---|---|---|
-| **Graph-MIND** (shipped path, earlier 20-item packet) | **85.0%** | **0** |
-| MemPalace 3.10.0 | 57.5% | 0 |
-| Mem0 2.2.1 (open source, latest on PyPI) | 52.5% | ~640k |
-
-Graph-MIND's lead over both is significant (exact McNemar p = 0.002 and 0.003).
+**Head to head** ([table above](#the-part-that-sounds-wrong)): the run was pre-registered with
+code hashes, and nobody had tuned on those 40 questions. Graph-MIND ran its shipped path with the
+earlier 20-item packet; Mem0 2.2.1 was the latest open-source release on PyPI. Graph-MIND's lead
+over both is significant (exact McNemar p = 0.002 and 0.003); with 40 questions, each score has an
+interval of about ±14 points.
 
 **Reading other published numbers.** They measure different things, so they do not compare
 directly with the tables above:

{graph_mind_memory-0.5.4 → graph_mind_memory-0.5.5}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "graph-mind-memory"
-version = "0.5.4"
+version = "0.5.5"
 description = "Local-first memory for AI coding assistants: verbatim, on your own PC, no LLM calls at write time."
 readme = "README.md"
 requires-python = ">=3.10"

{graph_mind_memory-0.5.4 → graph_mind_memory-0.5.5}/src/graph_mind_mcp_server.py

@@ -184,6 +184,107 @@ def embedder_for(database):
     return _EMBEDDER[key]
 
 
+class _Piece:
+    __slots__ = ("revision", "turn_id", "start", "user", "scope", "time", "key", "piece")
+
+    def __init__(self, *values):
+        for name, value in zip(self.__slots__, values):
+            setattr(self, name, value)
+
+
+class PieceIndex:
+    """Every turn's 500-character pieces and their vectors, held in memory for one store and
+    topped up with the turns added since the previous question. Rebuilt per question (hashing
+    every piece, gathering every vector) it cost 6.3 s a question at 100,000 turns and grew with
+    the store. Turns are only ever added or forgotten; a forgotten one triggers a rebuild."""
+
+    def __init__(self):
+        self.lock = threading.Lock()
+        self.reset()
+
+    def reset(self):
+        import numpy as np
+        self.last = 0                     # highest turn revision read
+        self.turns = 0                    # turns read
+        self.pending = []                 # pieces with no vector yet
+        self.seen_vectors = -1
+        self.turn_ids = []
+        self.revisions = np.zeros(0, dtype=np.int64)
+        self.starts = np.zeros(0, dtype=np.int64)
+        self.user = np.zeros(0, dtype=bool)
+        self.scopes = np.zeros(0, dtype=object)
+        self.times = np.zeros(0, dtype="U32")
+        self.matrix = None
+        self.norms = np.zeros(0, dtype=np.float64)
+
+    def sync(self, database, embedder):
+        from embedding_warmup import turn_pieces
+        with ConversationMemoryStore(database) as store:
+            count = store.db.execute("SELECT COUNT(*) FROM conversation_turns").fetchone()[0]
+            new = store.db.execute(
+                "SELECT revision,turn_id,role,scope,happened_at,content_redacted "
+                "FROM conversation_turns WHERE revision>? ORDER BY revision",
+                (self.last,)).fetchall()
+            if count != self.turns + len(new):          # something was forgotten
+                self.reset()
+                new = store.db.execute(
+                    "SELECT revision,turn_id,role,scope,happened_at,content_redacted "
+                    "FROM conversation_turns ORDER BY revision").fetchall()
+        for revision, turn_id, role, scope, happened_at, content in new:
+            for start, piece in turn_pieces(content):
+                self.pending.append(_Piece(revision, turn_id, start, role == "user", scope,
+                                           happened_at, embedder._key(piece.strip()[:2000]),
+                                           piece))
+        if new:
+            self.last = new[-1][0]
+            self.turns += len(new)
+        self.promote(embedder, force=bool(new))
+
+    def promote(self, embedder, force=False):
+        """Move pending pieces whose vectors now exist into the matrix (only when it can have
+        changed: new pieces, or more vectors than last time)."""
+        import numpy as np
+        if not force and len(embedder.cache) == self.seen_vectors:
+            return
+        self.seen_vectors = len(embedder.cache)
+        ready = [entry for entry in self.pending if entry.key in embedder.cache]
+        if not ready:
+            return
+        self.pending = [entry for entry in self.pending if entry.key not in embedder.cache]
+        vectors = np.asarray([embedder.cache.get(entry.key) for entry in ready], dtype=np.float32)
+        self.matrix = vectors if self.matrix is None else np.concatenate([self.matrix, vectors])
+        self.norms = np.concatenate([self.norms, np.linalg.norm(vectors.astype(np.float64), axis=1)])
+        self.turn_ids.extend(entry.turn_id for entry in ready)
+        self.revisions = np.concatenate([self.revisions, [e.revision for e in ready]])
+        self.starts = np.concatenate([self.starts, [e.start for e in ready]])
+        self.user = np.concatenate([self.user, [e.user for e in ready]])
+        self.scopes = np.concatenate([self.scopes, np.array([e.scope for e in ready], dtype=object)])
+        self.times = np.concatenate([self.times, np.array([e.time for e in ready], dtype="U32")])
+
+    def select(self, *, about_assistant, scopes, since, until):
+        import numpy as np
+        mask = np.ones(len(self.turn_ids), dtype=bool) if about_assistant else self.user.copy()
+        if scopes:
+            mask &= np.isin(self.scopes, list(scopes))
+        if since:
+            mask &= self.times >= since
+        if until:
+            mask &= self.times < until
+        return mask
+
+    @staticmethod
+    def wanted(entry, about_assistant, scopes, since, until):
+        return ((about_assistant or entry.user) and (not scopes or entry.scope in scopes)
+                and (not since or entry.time >= since) and (not until or entry.time < until))
+
+
+_PIECES = {}
+
+
+def pieces_for(database):
+    return _PIECES.setdefault(str(database), PieceIndex())
+
+
 def semantic_turns(database, query, *, scopes=None, since=None, until=None, limit=20, embedder,
                    about_assistant=False):
     """Turns ranked by meaning; each carries the 500-character piece that matched.
@@ -191,66 +292,69 @@ def semantic_turns(database, query, *, scopes=None, since=None, until=None, limi
     Only the user's turns by default: indexing the assistant's long prose too buried the user's
     facts (benchmark: answer sessions in the top 8 went 105 -> 115 of 120 when it was left out).
     When the question is about what the assistant itself said, its turns join the index."""
-    with ConversationMemoryStore(database) as store:
-        where, parameters = ["role IN ('user','assistant')" if about_assistant
-                             else "role='user'"], []
-        if scopes:
-            where.append("scope IN (" + ",".join("?" for _ in scopes) + ")")
-            parameters.extend(scopes)
-        if since:
-            where.append("happened_at>=?")
-            parameters.append(since)
-        if until:
-            where.append("happened_at<?")
-            parameters.append(until)
-        turns = [store._turn(row) for row in store.db.execute(
-            "SELECT * FROM conversation_turns WHERE " + " AND ".join(where), parameters)]
-    from embedding_warmup import turn_pieces
-    owners, pieces = [], []
-    for turn in turns:
-        for start, piece in turn_pieces(turn["content"]):
-            owners.append((turn, start))
-            pieces.append(piece)
-    if not pieces:
-        return []
-    if hasattr(embedder.cache, "refresh"):
-        embedder.cache.refresh()        # vectors the capture service embedded since we loaded
-    # Never make a question wait for the store to be embedded: a store that has never been
-    # searched by meaning holds ~1,500 pieces per thousand turns, minutes on a busy laptop. A few
-    # new pieces are embedded inline; a backlog is filled in the background while this question
-    # is answered from what is already embedded (word search covers the rest meanwhile).
-    missing = [p for p in pieces if embedder._key(p.strip()[:2000]) not in embedder.cache]
-    # Nor wait for the model itself: an app's first question used to sit through the torch import
-    # (38.8 s measured). If it is not loaded within WAIT_FOR_MODEL seconds, this question is
-    # answered from word search plus what is embedded already, and loading carries on.
-    asked = embedder._key(query.strip()[:2000]) in embedder.cache
-    wait = getattr(embedder, "WAIT_FOR_MODEL", None)
-    loading = (wait is not None and (missing or not asked) and not embedder.ready(wait))
-    if loading and not asked:
-        return []
-    if len(missing) > INLINE_EMBED_LIMIT or (loading and missing):
-        embed_in_background(embedder, missing)
-        keep = [i for i, p in enumerate(pieces)
-                if embedder._key(p.strip()[:2000]) in embedder.cache]
-        owners, pieces = [owners[i] for i in keep], [pieces[i] for i in keep]
-        if not pieces:
-            return []
     import numpy as np
-    question = np.asarray(embedder.embed([query])[0], dtype=np.float64)
-    # One matrix product instead of a Python loop per piece: 5 s -> 0.05 s at 40,000 pieces, which
-    # a few months of captured chat reaches. Same cosine, in float64 as before.
-    matrix = np.stack([np.asarray(v, dtype=np.float64) for v in embedder.embed(pieces)])
-    norms = np.linalg.norm(matrix, axis=1) * np.linalg.norm(question)
-    scores = np.divide(matrix @ question, norms, out=np.zeros(len(pieces)), where=norms > 0)
-    best = {}
-    # ponytail: a full scan of every piece per query; fine for one person's years of chat, an
-    # approximate-nearest-neighbour index is the upgrade if a store reaches millions of pieces.
-    for (turn, start), piece, score in zip(owners, pieces, scores.tolist()):
-        if score > best.get(turn["turn_id"], (-2.0,))[0]:
-            best[turn["turn_id"]] = (score, turn, start, piece)
-    ranked = sorted(best.values(), key=lambda hit: hit[0], reverse=True)[:limit]
-    return [{**turn, "content": piece, "span": [start, start + len(piece)], "full": turn["content"],
-             "similarity": round(score, 4)} for score, turn, start, piece in ranked]
+    index = pieces_for(database)
+    with index.lock:
+        if hasattr(embedder.cache, "refresh"):
+            embedder.cache.refresh()    # vectors the capture service embedded since we loaded
+        index.sync(database, embedder)
+        mask = index.select(about_assistant=about_assistant, scopes=scopes, since=since,
+                            until=until)
+        waiting = [entry for entry in index.pending
+                   if index.wanted(entry, about_assistant, scopes, since, until)]
+        if not mask.any() and not waiting:
+            return []
+        # Never make a question wait for the store to be embedded: a store that has never been
+        # searched by meaning holds ~1,500 pieces per thousand turns, minutes on a busy laptop. A
+        # few new pieces are embedded inline; a backlog is filled in the background while this
+        # question is answered from what is already embedded (word search covers the rest).
+        missing = [entry.piece for entry in waiting]
+        # Nor wait for the model itself: an app's first question used to sit through the torch
+        # import (38.8 s measured). If it is not loaded within WAIT_FOR_MODEL seconds, this
+        # question is answered from word search plus what is embedded already.
+        asked = embedder._key(query.strip()[:2000]) in embedder.cache
+        wait = getattr(embedder, "WAIT_FOR_MODEL", None)
+        loading = (wait is not None and (missing or not asked) and not embedder.ready(wait))
+        if loading and not asked:
+            return []
+        if len(missing) > INLINE_EMBED_LIMIT or (loading and missing):
+            embed_in_background(embedder, missing)
+        elif missing:
+            embedder.embed(missing)
+            index.promote(embedder, force=True)
+            mask = index.select(about_assistant=about_assistant, scopes=scopes, since=since,
+                                until=until)
+        rows = np.flatnonzero(mask)
+        if not len(rows):
+            return []
+        question = np.asarray(embedder.embed([query])[0], dtype=np.float32)
+        # ponytail: a full scan of every piece per query (one matrix product: ~0.1 s at 100,000
+        # turns); an approximate-nearest-neighbour index is the upgrade at millions of pieces.
+        norms = index.norms[rows] * float(np.linalg.norm(question.astype(np.float64)))
+        dots = (index.matrix[rows] @ question).astype(np.float64)
+        scores = np.divide(dots, norms, out=np.zeros(len(rows)), where=norms > 0)
+        # best piece per turn; ties go to the earlier turn, then the earlier piece, as before
+        order = np.lexsort((index.starts[rows], index.revisions[rows], -scores))
+        best = {}
+        for i in order:
+            turn_id = index.turn_ids[rows[i]]
+            if turn_id not in best:
+                best[turn_id] = (float(scores[i]), int(index.starts[rows[i]]))
+                if len(best) == limit:
+                    break
+    with ConversationMemoryStore(database) as store:
+        found = {row["turn_id"]: store._turn(row) for row in store.db.execute(
+            "SELECT * FROM conversation_turns WHERE turn_id IN (" + ",".join("?" * len(best)) + ")",
+            list(best))}
+    hits = []
+    for turn_id, (score, start) in best.items():
+        turn = found.get(turn_id)
+        if turn is None:                  # forgotten between the scan and this read
+            continue
+        piece = turn["content"][start:start + PIECE]
+        hits.append({**turn, "content": piece, "span": [start, start + len(piece)],
+                     "full": turn["content"], "similarity": round(score, 4)})
+    return hits
 
 
 def fuse(*rankings, limit):

{graph_mind_memory-0.5.4 → graph_mind_memory-0.5.5}/src/graph_mind_memory.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: graph-mind-memory
-Version: 0.5.4
+Version: 0.5.5
 Summary: Local-first memory for AI coding assistants: verbatim, on your own PC, no LLM calls at write time.
 Author-email: Yohan Ko <goyohan0611@gmail.com>
 License-Expression: AGPL-3.0-only
@@ -31,8 +31,9 @@ Dynamic: license-file
 
 # Graph-MIND
 
-Local-first memory for AI coding assistants. Verbatim storage, on your own PC:
-**88.8% on LongMemEval with zero model calls at write time.**
+### Your AI forgets everything when the session ends. This one remembers, and it never calls an LLM to do it.
+
+**88.8% on LongMemEval. Zero model tokens spent saving memory. Runs on your own PC.**
 
 [![][license-shield]][license-link]
 [![][python-shield]][python-link]
@@ -41,7 +42,7 @@ Local-first memory for AI coding assistants. Verbatim storage, on your own PC:
 [![][ci-shield]][ci-link]
 [![][pypi-shield]][pypi-link]
 
-*Switch models; keep the memory.*
+*Decide something in Claude Code on Monday. Ask Codex on Wednesday. It knows.*
 
 <img src="demo/demo.gif" alt="A decision made in Claude Code on Monday, recalled from Codex on Wednesday" width="760">
 
@@ -49,6 +50,30 @@ Local-first memory for AI coding assistants. Verbatim storage, on your own PC:
 
 </div>
 
+### The part that sounds wrong
+
+Same 40 questions, same answer model, same prompt, same official judge, pre-registered before
+anyone looked:
+
+| | accuracy | model tokens spent **saving** memory, per question |
+|---|---|---|
+| **Graph-MIND** | **85.0%** | **0** |
+| MemPalace 3.10.0 | 57.5% | 0 |
+| Mem0 2.2.1 (open source) | 52.5% | ~640,000 |
+
+Mem0 runs an LLM over your conversations to decide what to keep. Graph-MIND keeps them word for
+word and finds the right part when you ask. It is cheaper, and in this test it was also more
+accurate.
+
+**Don't believe it? Good.** Every question, answer and judge verdict is in
+[`research/runs/`](research/runs), and [REPORT.md](research/REPORT.md) shows how to rerun it,
+including the runs that went wrong. Or just try it on your own conversations:
+
+```bash
+pip install graph-mind-memory
+graph-mind-install          # connects Claude Code, Codex, Claude Desktop, Cursor, VS Code, ...
+```
+
 > [!NOTE]
 > **Alpha.** Windows: used daily, with full end-to-end checks (fresh install, two PCs, real
 > Claude and Codex). macOS and Linux: tests and a clean install from PyPI pass in CI on every
@@ -89,16 +114,11 @@ official gpt-4o-2024-08-06.
 | **All 500 questions** | **88.8%** (444/500) | **0** | 3.4k tokens |
 | The 380 never used for tuning | **86.8%** (330/380) | 0 | 3.4k tokens |
 
-**Head to head: same 40 questions, same answer model, prompt and judge.** The run was
-pre-registered with code hashes; nobody had tuned on these questions.
-
-| system | accuracy | model tokens at write time, per question |
-|---|---|---|
-| **Graph-MIND** (shipped path, earlier 20-item packet) | **85.0%** | **0** |
-| MemPalace 3.10.0 | 57.5% | 0 |
-| Mem0 2.2.1 (open source, latest on PyPI) | 52.5% | ~640k |
-
-Graph-MIND's lead over both is significant (exact McNemar p = 0.002 and 0.003).
+**Head to head** ([table above](#the-part-that-sounds-wrong)): the run was pre-registered with
+code hashes, and nobody had tuned on those 40 questions. Graph-MIND ran its shipped path with the
+earlier 20-item packet; Mem0 2.2.1 was the latest open-source release on PyPI. Graph-MIND's lead
+over both is significant (exact McNemar p = 0.002 and 0.003); with 40 questions, each score has an
+interval of about ±14 points.
 
 **Reading other published numbers.** They measure different things, so they do not compare
 directly with the tables above:

{graph_mind_memory-0.5.4 → graph_mind_memory-0.5.5}/src/graph_mind_memory.egg-info/SOURCES.txt

@@ -51,6 +51,7 @@ tests/test_longmemeval_ingestion_calibration.py
 tests/test_longmemeval_ingestion_preflight.py
 tests/test_longmemeval_ingestion_v7.py
 tests/test_memory_algebra.py
+tests/test_piece_index.py
 tests/test_precondition_verifier.py
 tests/test_recent_recall.py
 tests/test_resume_retries.py

graph_mind_memory-0.5.5/tests/test_piece_index.py

@@ -0,0 +1,57 @@
+"""Meaning search keeps its pieces in memory between questions: turns added later are searched,
+and a forgotten turn is never returned again."""
+import _isolate  # noqa: F401  (first: never touch the real ~/.graph-mind)
+from pathlib import Path
+import tempfile
+import unittest
+
+import graph_mind_mcp_server as server
+from conversation_memory import ConversationMemoryStore
+
+TOPICS = ("dog", "cat", "beach", "food")
+
+
+class Words:
+    """A stand-in embedder: one dimension per topic word."""
+    WAIT_FOR_MODEL = None
+
+    def __init__(self):
+        self.cache = {}
+
+    def _key(self, text):
+        return text
+
+    def embed(self, texts):
+        for text in texts:
+            self.cache.setdefault(text, [float(word in text) + 0.01 for word in TOPICS])
+        return [self.cache[text] for text in texts]
+
+
+def turn(i, text):
+    when = f"2026-10-08T10:{i:02d}:00"
+    return {"turn_id": f"t{i}", "client": "codex", "client_session_id": "s", "scope": "global",
+            "role": "user", "content_redacted": text, "raw_sha256": f"t{i}", "source_path": "p",
+            "happened_at": when, "known_at": when, "source_ordinal": i}
+
+
+class PieceIndexTests(unittest.TestCase):
+    def test_new_turns_are_searched_and_forgotten_ones_are_gone(self):
+        with tempfile.TemporaryDirectory() as directory:
+            db, words = Path(directory) / "brain.sqlite", Words()
+            ask = lambda: [h["turn_id"] for h in  # noqa: E731
+                           server.semantic_turns(db, "dog", embedder=words, limit=5)]
+            with ConversationMemoryStore(db) as store:
+                store.record(turn(0, "my dog at the park"))
+                store.record(turn(1, "cat food prices"))
+            self.assertEqual(ask()[0], "t0")
+            with ConversationMemoryStore(db) as store:
+                store.record(turn(2, "dog on the beach"))
+            self.assertIn("t2", ask())
+            with ConversationMemoryStore(db) as store, store.db:
+                store.db.execute("DELETE FROM conversation_turns WHERE turn_id='t0'")
+            self.assertNotIn("t0", ask())
+            self.assertIn("t2", ask())
+
+
+if __name__ == "__main__":
+    unittest.main()