memorymaster 3.23.0__tar.gz → 3.24.0__tar.gz

{memorymaster-3.23.0/memorymaster.egg-info → memorymaster-3.24.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: memorymaster
-Version: 3.23.0
+Version: 3.24.0
 Summary: Production-grade memory reliability system for AI coding agents. Lifecycle-managed claims with citations, conflict detection, steward governance, and MCP integration.
 Author: wolverin0
 License: MIT
@@ -52,7 +52,7 @@ Lifecycle-managed claims with citations, conflict detection, steward governance,
 
 [![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](LICENSE)
 [![Python 3.10+](https://img.shields.io/badge/python-3.10+-blue.svg)](https://www.python.org/downloads/)
-[![Tests](https://img.shields.io/badge/tests-2224-green.svg)]()
+[![Tests](https://img.shields.io/badge/tests-2230-green.svg)]()
 [![MCP Tools](https://img.shields.io/badge/MCP%20tools-24-purple.svg)]()
 [![CLI Commands](https://img.shields.io/badge/CLI%20commands-86-orange.svg)]()
 [![PyPI](https://img.shields.io/pypi/v/memorymaster.svg)](https://pypi.org/project/memorymaster/)

{memorymaster-3.23.0 → memorymaster-3.24.0}/README.md

@@ -6,7 +6,7 @@ Lifecycle-managed claims with citations, conflict detection, steward governance,
 
 [![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](LICENSE)
 [![Python 3.10+](https://img.shields.io/badge/python-3.10+-blue.svg)](https://www.python.org/downloads/)
-[![Tests](https://img.shields.io/badge/tests-2224-green.svg)]()
+[![Tests](https://img.shields.io/badge/tests-2230-green.svg)]()
 [![MCP Tools](https://img.shields.io/badge/MCP%20tools-24-purple.svg)]()
 [![CLI Commands](https://img.shields.io/badge/CLI%20commands-86-orange.svg)]()
 [![PyPI](https://img.shields.io/pypi/v/memorymaster.svg)](https://pypi.org/project/memorymaster/)

{memorymaster-3.23.0 → memorymaster-3.24.0}/memorymaster/__init__.py

@@ -2,4 +2,4 @@
 
 __all__ = ["__version__"]
 
-__version__ = "3.23.0"
+__version__ = "3.24.0"

{memorymaster-3.23.0 → memorymaster-3.24.0}/memorymaster/config_templates/hooks/memorymaster-auto-ingest.py

@@ -10,9 +10,8 @@ import json
 import os
 import sys
 import re
-import sqlite3
 import hashlib
-from datetime import datetime, timezone
+from datetime import datetime
 from pathlib import Path
 
 PROJECT_ROOT = "__MEMORYMASTER_PROJECT_ROOT__"
@@ -139,43 +138,40 @@ Only: bug root causes, decisions, gotchas, constraints. Never: credentials, IPs,
             return
 
         scope = "project:" + os.path.basename(cwd).lower().replace(" ", "-") if cwd else "global"
-        now = datetime.now(timezone.utc).isoformat()
 
-        conn = sqlite3.connect(DB_PATH)
+        # Route through MemoryService.ingest instead of raw SQL so claims gain
+        # the canonical ingest path: sensitivity sanitize (defense-in-depth on
+        # top of the _is_sensitive_claim drop above), content-hash + idempotency
+        # dedup, entity resolution, auto-citation, observability, and webhook.
+        # Mirrors _run_rule_extraction, which already uses the service.
+        from memorymaster.service import MemoryService
+        from memorymaster.models import CitationInput
+
+        svc = MemoryService(DB_PATH, workspace_root=Path(cwd or PROJECT_ROOT))
+        ingested = 0
         for c in claims:
             text = c.get("text", "")
             if not text or len(text) < 10:
                 continue
-            # Duplicate check by content hash
             text_hash = hashlib.sha256(text.strip().lower().encode()).hexdigest()[:16]
-            idem = f"llm-stop-{text_hash}"
-            if conn.execute("SELECT id FROM claims WHERE idempotency_key = ?", (idem,)).fetchone():
-                continue
-            cur = conn.execute(
-                """INSERT INTO claims (text, idempotency_key, normalized_text, claim_type,
-                   subject, predicate, scope, status, confidence,
-                   source_agent, created_at, updated_at, tier, version, visibility,
-                   valid_from)
-                   VALUES (?, ?, ?, ?, ?, ?, ?, 'candidate', 0.6,
-                   'llm-stop-hook', ?, ?, 'working', 1, 'public', ?)""",
-                (text, idem, text.lower(), c.get("claim_type", "fact"),
-                 c.get("subject", "codebase"), c.get("predicate", "observation"),
-                 scope, now, now, now),
-            )
-            # Auto-citation: steward's min_citations>=1 gate requires at least one
-            # row per claim. Without this, every llm-stop-hook claim is born
-            # unpromotable. Source is the hook itself; locator = scope for
-            # traceability; excerpt preserves the first 200 chars of the claim.
-            conn.execute(
-                """INSERT INTO citations (claim_id, source, locator, excerpt, created_at)
-                   VALUES (?, 'llm-stop-hook', ?, ?, ?)""",
-                (cur.lastrowid, scope, text[:200], now),
-            )
-        conn.commit()
-        conn.close()
+            try:
+                svc.ingest(
+                    text=text,
+                    citations=[CitationInput(source="llm-stop-hook", locator=scope, excerpt=text[:200])],
+                    idempotency_key=f"llm-stop-{text_hash}",
+                    claim_type=c.get("claim_type", "fact"),
+                    subject=c.get("subject", "codebase"),
+                    predicate=c.get("predicate", "observation"),
+                    scope=scope,
+                    confidence=0.6,
+                    source_agent="llm-stop-hook",
+                )
+                ingested += 1
+            except Exception:
+                continue  # one bad claim must not abort the rest
 
         provider = os.environ.get("MEMORYMASTER_LLM_PROVIDER", "google")
-        sys.stderr.write(f"[MemoryMaster] {provider} extracted {len(claims)} learnings\n")
+        sys.stderr.write(f"[MemoryMaster] {provider} extracted {ingested} learnings\n")
     except Exception:
         pass
 

{memorymaster-3.23.0 → memorymaster-3.24.0}/memorymaster/query_cache.py

@@ -84,11 +84,31 @@ def current_generation(conn: sqlite3.Connection) -> int:
     return int(row[0]) if row else 0
 
 
+def read_generation(db_path: str) -> int:
+    """Return the current corpus generation, or 0 on any error.
+
+    Callers capture this BEFORE reading the corpus they are about to compute a
+    result from, then pass it to ``write()`` — see the TOCTOU note there."""
+    try:
+        conn = _connect(db_path)
+    except sqlite3.Error as exc:
+        logger.warning("query_cache.read_generation connect failed: %s", exc)
+        return 0
+    try:
+        return current_generation(conn)
+    except (sqlite3.Error, ValueError) as exc:
+        logger.warning("query_cache.read_generation failed: %s", exc)
+        return 0
+    finally:
+        conn.close()
+
+
 def read(db_path: str, cache_key: str) -> list[dict] | None:
     """Return cached result stubs if present AND still fresh (generation match)."""
     try:
         conn = _connect(db_path)
-    except sqlite3.Error:
+    except sqlite3.Error as exc:
+        logger.warning("query_cache.read connect failed: %s", exc)
         return None
     try:
         gen = current_generation(conn)
@@ -99,20 +119,31 @@ def read(db_path: str, cache_key: str) -> list[dict] | None:
         if row is None or int(row["generation"]) != gen:
             return None
         return json.loads(row["result_json"])
-    except (sqlite3.Error, json.JSONDecodeError, ValueError):
+    except (sqlite3.Error, json.JSONDecodeError, ValueError) as exc:
+        logger.warning("query_cache.read failed (cache disabled for this query): %s", exc)
         return None
     finally:
         conn.close()
 
 
-def write(db_path: str, cache_key: str, stub_rows: list[dict]) -> None:
-    """Store result stubs tagged with the current generation. Best-effort."""
+def write(db_path: str, cache_key: str, stub_rows: list[dict], generation: int) -> None:
+    """Store result stubs tagged with ``generation``. Best-effort.
+
+    TOCTOU correctness: ``generation`` MUST be the corpus generation captured by
+    the caller BEFORE it read the candidates it computed ``stub_rows`` from. If
+    we re-read the generation here instead, a claim write that raced in between
+    the caller's corpus read and this write would have bumped the counter, and
+    we would tag a stale (generation-G) result as the new generation (G+1) — so
+    a subsequent read at G+1 would serve the stale ranking, defeating the
+    generation gate. Tagging with the compute-time generation guarantees any
+    racing write correctly invalidates this entry. (audit: qc-generation-toctou)
+    """
     try:
         conn = _connect(db_path)
-    except sqlite3.Error:
+    except sqlite3.Error as exc:
+        logger.warning("query_cache.write connect failed: %s", exc)
         return
     try:
-        gen = current_generation(conn)
         conn.execute(
             """INSERT INTO query_cache (cache_key, result_json, generation, created_at)
                VALUES (?, ?, ?, ?)
@@ -120,10 +151,10 @@ def write(db_path: str, cache_key: str, stub_rows: list[dict]) -> None:
                    result_json = excluded.result_json,
                    generation = excluded.generation,
                    created_at = excluded.created_at""",
-            (cache_key, json.dumps(stub_rows), gen, datetime.now(timezone.utc).isoformat()),
+            (cache_key, json.dumps(stub_rows), generation, datetime.now(timezone.utc).isoformat()),
         )
         conn.commit()
-    except (sqlite3.Error, TypeError, ValueError):
-        pass
+    except (sqlite3.Error, TypeError, ValueError) as exc:
+        logger.warning("query_cache.write failed (result not cached): %s", exc)
     finally:
         conn.close()

{memorymaster-3.23.0 → memorymaster-3.24.0}/memorymaster/security.py

@@ -157,6 +157,8 @@ class SanitizedClaimInput:
     is_sensitive: bool
     findings: list[str]
     encrypted_payload: str | None
+    subject: str | None = None
+    predicate: str | None = None
 
 
 def _as_bool(value: object, *, field: str) -> bool:
@@ -320,6 +322,8 @@ def sanitize_claim_input(
     text: str,
     object_value: str | None,
     citations: list[CitationInput],
+    subject: str | None = None,
+    predicate: str | None = None,
 ) -> SanitizedClaimInput:
     redacted_text, findings = _redact(text)
     redacted_object = object_value
@@ -328,6 +332,19 @@ def sanitize_claim_input(
         redacted_object, object_findings = _redact(object_value)
         findings.extend(object_findings)
 
+    # subject/predicate are structured-claim fields that reach the store
+    # alongside text/object_value. They are exposed MCP ingest parameters, so a
+    # secret placed there must be caught by the ingest filter — the last line of
+    # defense — not only at display time. (audit: ingest-subject-skips-filter)
+    redacted_subject = subject
+    if subject:
+        redacted_subject, subject_findings = _redact(subject)
+        findings.extend(subject_findings)
+    redacted_predicate = predicate
+    if predicate:
+        redacted_predicate, predicate_findings = _redact(predicate)
+        findings.extend(predicate_findings)
+
     sanitized_citations: list[CitationInput] = []
     citation_findings: list[str] = []
     for cite in citations:
@@ -344,6 +361,8 @@ def sanitize_claim_input(
         {
             "text": text,
             "object_value": object_value,
+            "subject": subject,
+            "predicate": predicate,
             "citations": [asdict(c) for c in citations],
         }
     ) if is_sensitive else None
@@ -355,6 +374,8 @@ def sanitize_claim_input(
         is_sensitive=is_sensitive,
         findings=dedup_findings,
         encrypted_payload=encrypted_payload,
+        subject=redacted_subject,
+        predicate=redacted_predicate,
     )
 
 

{memorymaster-3.23.0 → memorymaster-3.24.0}/memorymaster/service.py

@@ -251,9 +251,15 @@ class MemoryService:
             text=text.strip(),
             object_value=object_value,
             citations=citations,
+            subject=subject,
+            predicate=predicate,
         )
         if not sanitized.citations:
             raise ValueError("At least one citation is required.")
+        # Use the sanitized subject/predicate everywhere downstream so a secret
+        # placed in those fields is redacted at rest, not just at display time.
+        subject = sanitized.subject
+        predicate = sanitized.predicate
         # Resolve subject → canonical entity (GBrain-inspired entity registry)
         # and mine text for pattern-based entities (#127 Wave 3).
         entity_id = 0
@@ -667,6 +673,11 @@ class MemoryService:
                     rows = self._rehydrate_cached_rows(cached)
                     self._record_accesses(rows, query_text=query_text)
                     return rows
+        # Capture the corpus generation BEFORE reading candidates so the cache
+        # entry is tagged with the generation it was actually computed against,
+        # not whatever it is after ranking/LLM-rerank (which a concurrent claim
+        # write could have bumped). See query_cache.write TOCTOU note.
+        cache_generation = query_cache.read_generation(cache_path) if cache_path else 0
         candidate_limit = max(limit * 6, 60, 50 if use_llm_rerank else 0)
         candidates = self.store.list_claims(
             limit=candidate_limit,
@@ -733,7 +744,7 @@ class MemoryService:
                     "breakdown": r.get("breakdown"),
                 }
                 for r in results if r.get("claim") is not None
-            ])
+            ], cache_generation)
         return results
 
     def _rehydrate_cached_rows(self, stubs: list[dict[str, Any]]) -> list[dict[str, Any]]:

{memorymaster-3.23.0 → memorymaster-3.24.0}/memorymaster/verbatim_store.py

@@ -17,6 +17,7 @@ import os
 import sqlite3
 import urllib.request
 import urllib.error
+from contextlib import closing
 from datetime import datetime, timezone
 from pathlib import Path
 from typing import Any
@@ -48,7 +49,12 @@ def _row_has_sensitive_field(role: str, source_agent: str, content: str) -> bool
     _, findings = _redact_text(joined)
     return bool(findings)
 
-QDRANT_URL = os.environ.get("QDRANT_URL", "http://192.168.100.186:6333")
+# Vector search is opt-in: an unset QDRANT_URL means "vector disabled", exactly
+# like a missing OPENAI_API_KEY. NEVER hardcode a routable private LAN IP here —
+# a home-lab RFC1918 default previously shipped to PyPI, violating the
+# "never hardcode IPs" boundary and silently pointing installs at the author's
+# network. Mirror qdrant_backend.py / service.py which use empty/localhost defaults.
+QDRANT_URL = os.environ.get("QDRANT_URL", "").strip()
 QDRANT_COLLECTION = "memorymaster-verbatim"
 EMBED_DIM = 1536  # text-embedding-3-small
 
@@ -77,36 +83,37 @@ def store_verbatim(
 
     now = timestamp or datetime.now(timezone.utc).isoformat()
 
-    conn = _connect(db_path)
-    # Dedup by exact content within the same session. Uses idx_verbatim_session
-    # so the lookup is O(rows-in-session), not table-scan. The previous FTS5-based
-    # dedup query passed a sha256 hex prefix to MATCH which never resolves —
-    # the FTS5 index stores the content text, not its hash. Result: 9M+ rows
-    # accumulated for orchestrator sessions because every Stop event re-inserted
-    # every message. Fixed 2026-05-03; see mm-0c43.
-    existing = conn.execute(
-        "SELECT id FROM verbatim_memories WHERE session_id = ? AND content = ? LIMIT 1",
-        (session_id, content),
-    ).fetchone()
-    if existing:
-        conn.close()
-        return None
-
-    cur = conn.execute(
-        """INSERT INTO verbatim_memories (session_id, role, content, scope, timestamp, source_agent)
-           VALUES (?, ?, ?, ?, ?, ?)""",
-        (session_id, role, content, scope, now, source_agent),
-    )
-    row_id = cur.lastrowid
+    # closing() guarantees the connection (and its WAL write lock) is released
+    # even if an INSERT/commit raises (e.g. "database is locked" under
+    # concurrent MCP/Stop-hook writers) — this is the hottest write path.
+    with closing(_connect(db_path)) as conn:
+        # Dedup by exact content within the same session. Uses idx_verbatim_session
+        # so the lookup is O(rows-in-session), not table-scan. The previous FTS5-based
+        # dedup query passed a sha256 hex prefix to MATCH which never resolves —
+        # the FTS5 index stores the content text, not its hash. Result: 9M+ rows
+        # accumulated for orchestrator sessions because every Stop event re-inserted
+        # every message. Fixed 2026-05-03; see mm-0c43.
+        existing = conn.execute(
+            "SELECT id FROM verbatim_memories WHERE session_id = ? AND content = ? LIMIT 1",
+            (session_id, content),
+        ).fetchone()
+        if existing:
+            return None
+
+        cur = conn.execute(
+            """INSERT INTO verbatim_memories (session_id, role, content, scope, timestamp, source_agent)
+               VALUES (?, ?, ?, ?, ?, ?)""",
+            (session_id, role, content, scope, now, source_agent),
+        )
+        row_id = cur.lastrowid
 
-    # Update FTS
-    conn.execute(
-        "INSERT INTO verbatim_fts(rowid, content) VALUES (?, ?)",
-        (row_id, content),
-    )
-    conn.commit()
-    conn.close()
-    return row_id
+        # Update FTS
+        conn.execute(
+            "INSERT INTO verbatim_fts(rowid, content) VALUES (?, ?)",
+            (row_id, content),
+        )
+        conn.commit()
+        return row_id
 
 
 def _extract_role_content(entry: dict) -> tuple[str, str]:
@@ -240,40 +247,41 @@ def search_verbatim(
 
 def _search_fts(db_path: str, query: str, scope: str | None, limit: int) -> list[dict]:
     """FTS5 keyword search over verbatim memories."""
-    conn = _connect(db_path)
     # Clean query for FTS5
     clean_query = " ".join(w for w in query.split() if len(w) > 2)
     if not clean_query:
-        conn.close()
         return []
 
-    try:
-        if scope:
-            rows = conn.execute(
-                """SELECT v.id, v.session_id, v.role, v.content, v.scope, v.timestamp,
-                          rank as score
-                   FROM verbatim_fts f
-                   JOIN verbatim_memories v ON v.id = f.rowid
-                   WHERE verbatim_fts MATCH ? AND v.scope LIKE ?
-                   ORDER BY rank
-                   LIMIT ?""",
-                (clean_query, f"{scope}%", limit),
-            ).fetchall()
-        else:
-            rows = conn.execute(
-                """SELECT v.id, v.session_id, v.role, v.content, v.scope, v.timestamp,
-                          rank as score
-                   FROM verbatim_fts f
-                   JOIN verbatim_memories v ON v.id = f.rowid
-                   WHERE verbatim_fts MATCH ?
-                   ORDER BY rank
-                   LIMIT ?""",
-                (clean_query, limit),
-            ).fetchall()
-    except sqlite3.OperationalError:
-        rows = []
-
-    conn.close()
+    # closing() guarantees the connection is released even if the JOIN raises a
+    # non-OperationalError (corrupt/locked DB, programming error) — the bare
+    # except below only catches OperationalError.
+    with closing(_connect(db_path)) as conn:
+        try:
+            if scope:
+                rows = conn.execute(
+                    """SELECT v.id, v.session_id, v.role, v.content, v.scope, v.timestamp,
+                              rank as score
+                       FROM verbatim_fts f
+                       JOIN verbatim_memories v ON v.id = f.rowid
+                       WHERE verbatim_fts MATCH ? AND v.scope LIKE ?
+                       ORDER BY rank
+                       LIMIT ?""",
+                    (clean_query, f"{scope}%", limit),
+                ).fetchall()
+            else:
+                rows = conn.execute(
+                    """SELECT v.id, v.session_id, v.role, v.content, v.scope, v.timestamp,
+                              rank as score
+                       FROM verbatim_fts f
+                       JOIN verbatim_memories v ON v.id = f.rowid
+                       WHERE verbatim_fts MATCH ?
+                       ORDER BY rank
+                       LIMIT ?""",
+                    (clean_query, limit),
+                ).fetchall()
+        except sqlite3.OperationalError:
+            rows = []
+
     return [
         {"id": r["id"], "session_id": r["session_id"], "role": r["role"],
          "content": r["content"], "scope": r["scope"], "timestamp": r["timestamp"],
@@ -284,6 +292,8 @@ def _search_fts(db_path: str, query: str, scope: str | None, limit: int) -> list
 
 def _search_vector(query: str, scope: str | None, limit: int) -> list[dict]:
     """Qdrant semantic search over verbatim memories."""
+    if not QDRANT_URL:
+        return []
     try:
         # Embed query with OpenAI
         api_key = os.environ.get("OPENAI_API_KEY", "")
@@ -337,85 +347,84 @@ def sync_to_qdrant(db_path: str, batch_size: int = 50) -> dict[str, int]:
     api_key = os.environ.get("OPENAI_API_KEY", "")
     if not api_key:
         return {"synced": 0, "error": "no OPENAI_API_KEY"}
+    if not QDRANT_URL:
+        return {"synced": 0, "error": "no QDRANT_URL"}
 
-    conn = _connect(db_path)
-    rows = conn.execute(
-        "SELECT id, content, scope, session_id, role FROM verbatim_memories WHERE embedding_synced = 0 LIMIT ?",
-        (batch_size,),
-    ).fetchall()
+    # closing() guarantees the connection is released on every exit path,
+    # including the initial SELECT raising or the final UPDATE/commit raising.
+    with closing(_connect(db_path)) as conn:
+        rows = conn.execute(
+            "SELECT id, content, scope, session_id, role FROM verbatim_memories WHERE embedding_synced = 0 LIMIT ?",
+            (batch_size,),
+        ).fetchall()
 
-    if not rows:
-        conn.close()
-        return {"synced": 0}
+        if not rows:
+            return {"synced": 0}
 
-    # Ensure collection exists
-    try:
-        req = urllib.request.Request(f"{QDRANT_URL}/collections/{QDRANT_COLLECTION}")
-        urllib.request.urlopen(req, timeout=5)
-    except Exception:
-        payload = {"vectors": {"size": EMBED_DIM, "distance": "Cosine"}}
-        req = urllib.request.Request(
-            f"{QDRANT_URL}/collections/{QDRANT_COLLECTION}",
-            data=json.dumps(payload).encode(),
-            headers={"Content-Type": "application/json"},
-            method="PUT",
-        )
+        # Ensure collection exists
         try:
-            urllib.request.urlopen(req, timeout=60)
+            req = urllib.request.Request(f"{QDRANT_URL}/collections/{QDRANT_COLLECTION}")
+            urllib.request.urlopen(req, timeout=5)
+        except Exception:
+            payload = {"vectors": {"size": EMBED_DIM, "distance": "Cosine"}}
+            req = urllib.request.Request(
+                f"{QDRANT_URL}/collections/{QDRANT_COLLECTION}",
+                data=json.dumps(payload).encode(),
+                headers={"Content-Type": "application/json"},
+                method="PUT",
+            )
+            try:
+                urllib.request.urlopen(req, timeout=60)
+            except Exception as e:
+                return {"synced": 0, "error": str(e)}
+
+        # Embed in batches
+        texts = [r["content"][:2000] for r in rows]
+        try:
+            embed_url = "https://api.openai.com/v1/embeddings"
+            payload = {"model": "text-embedding-3-small", "input": texts}
+            req = urllib.request.Request(
+                embed_url,
+                data=json.dumps(payload).encode(),
+                headers={"Content-Type": "application/json", "Authorization": f"Bearer {api_key}"},
+                method="POST",
+            )
+            with urllib.request.urlopen(req, timeout=30) as resp:
+                result = json.loads(resp.read().decode())
+            embeddings = [d["embedding"] for d in result["data"]]
         except Exception as e:
-            conn.close()
             return {"synced": 0, "error": str(e)}
 
-    # Embed in batches
-    texts = [r["content"][:2000] for r in rows]
-    try:
-        embed_url = "https://api.openai.com/v1/embeddings"
-        payload = {"model": "text-embedding-3-small", "input": texts}
-        req = urllib.request.Request(
-            embed_url,
-            data=json.dumps(payload).encode(),
-            headers={"Content-Type": "application/json", "Authorization": f"Bearer {api_key}"},
-            method="POST",
-        )
-        with urllib.request.urlopen(req, timeout=30) as resp:
-            result = json.loads(resp.read().decode())
-        embeddings = [d["embedding"] for d in result["data"]]
-    except Exception as e:
-        conn.close()
-        return {"synced": 0, "error": str(e)}
-
-    # Upsert to Qdrant
-    points = []
-    for i, (row, emb) in enumerate(zip(rows, embeddings)):
-        points.append({
-            "id": row["id"],
-            "vector": emb,
-            "payload": {
-                "content": row["content"][:2000],
-                "content_hash": hashlib.sha256(row["content"].encode()).hexdigest(),
-                "scope": row["scope"],
-                "session_id": row["session_id"],
-                "role": row["role"],
-            },
-        })
+        # Upsert to Qdrant
+        points = []
+        for i, (row, emb) in enumerate(zip(rows, embeddings)):
+            points.append({
+                "id": row["id"],
+                "vector": emb,
+                "payload": {
+                    "content": row["content"][:2000],
+                    "content_hash": hashlib.sha256(row["content"].encode()).hexdigest(),
+                    "scope": row["scope"],
+                    "session_id": row["session_id"],
+                    "role": row["role"],
+                },
+            })
 
-    try:
-        req = urllib.request.Request(
-            f"{QDRANT_URL}/collections/{QDRANT_COLLECTION}/points",
-            data=json.dumps({"points": points}).encode(),
-            headers={"Content-Type": "application/json"},
-            method="PUT",
-        )
-        urllib.request.urlopen(req, timeout=30)
-    except Exception as e:
-        conn.close()
-        return {"synced": 0, "error": str(e)}
-
-    # Mark as synced
-    ids = [r["id"] for r in rows]
-    placeholders = ",".join("?" for _ in ids)
-    conn.execute(f"UPDATE verbatim_memories SET embedding_synced = 1 WHERE id IN ({placeholders})", ids)
-    conn.commit()
-    conn.close()
-
-    return {"synced": len(rows)}
+        try:
+            req = urllib.request.Request(
+                f"{QDRANT_URL}/collections/{QDRANT_COLLECTION}/points",
+                data=json.dumps({"points": points}).encode(),
+                headers={"Content-Type": "application/json"},
+                method="PUT",
+            )
+            urllib.request.urlopen(req, timeout=30)
+        except Exception as e:
+            return {"synced": 0, "error": str(e)}
+
+        # Mark as synced
+        ids = [r["id"] for r in rows]
+        placeholders = ",".join("?" for _ in ids)
+        conn.execute(f"UPDATE verbatim_memories SET embedding_synced = 1 WHERE id IN ({placeholders})", ids)
+        conn.commit()
+
+        return {"synced": len(rows)}

{memorymaster-3.23.0 → memorymaster-3.24.0/memorymaster.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: memorymaster
-Version: 3.23.0
+Version: 3.24.0
 Summary: Production-grade memory reliability system for AI coding agents. Lifecycle-managed claims with citations, conflict detection, steward governance, and MCP integration.
 Author: wolverin0
 License: MIT
@@ -52,7 +52,7 @@ Lifecycle-managed claims with citations, conflict detection, steward governance,
 
 [![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](LICENSE)
 [![Python 3.10+](https://img.shields.io/badge/python-3.10+-blue.svg)](https://www.python.org/downloads/)
-[![Tests](https://img.shields.io/badge/tests-2224-green.svg)]()
+[![Tests](https://img.shields.io/badge/tests-2230-green.svg)]()
 [![MCP Tools](https://img.shields.io/badge/MCP%20tools-24-purple.svg)]()
 [![CLI Commands](https://img.shields.io/badge/CLI%20commands-86-orange.svg)]()
 [![PyPI](https://img.shields.io/pypi/v/memorymaster.svg)](https://pypi.org/project/memorymaster/)

{memorymaster-3.23.0 → memorymaster-3.24.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "memorymaster"
-version = "3.23.0"
+version = "3.24.0"
 description = "Production-grade memory reliability system for AI coding agents. Lifecycle-managed claims with citations, conflict detection, steward governance, and MCP integration."
 license = {text = "MIT"}
 authors = [{name = "wolverin0"}]