memorymaster 3.2.2__tar.gz → 3.3.1__tar.gz

{memorymaster-3.2.2/memorymaster.egg-info → memorymaster-3.3.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: memorymaster
-Version: 3.2.2
+Version: 3.3.1
 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

{memorymaster-3.2.2 → memorymaster-3.3.1}/memorymaster/__init__.py

@@ -2,4 +2,4 @@
 
 __all__ = ["__version__"]
 
-__version__ = "3.2.2"
+__version__ = "3.3.1"

{memorymaster-3.2.2 → memorymaster-3.3.1}/memorymaster/_storage_read.py

@@ -590,3 +590,63 @@ class _ReadMixin:
             ).fetchall()
         return [self._row_to_citation(row) for row in rows]
 
+    def traverse_relationships(
+        self,
+        start_claim_id: int,
+        *,
+        link_types: list[str] | None = None,
+        max_depth: int = 3,
+        direction: str = "both",
+    ) -> list[dict]:
+        """Traverse the claim relationship graph from a starting claim.
+
+        Returns a list of dicts: [{"claim": Claim, "depth": int, "path": [int],
+        "link_type": str}]. BFS traversal, stops at max_depth. direction can be
+        "outgoing" (source→target), "incoming" (target→source), or "both".
+
+        Inspired by GBrain's graph traversal queries — "what depends on Qdrant?"
+        becomes traverse_relationships(qdrant_claim_id, link_types=["depends_on"]).
+        """
+        with self.connect() as conn:
+            visited: set[int] = {start_claim_id}
+            queue: list[tuple[int, int, list[int], str]] = []  # (claim_id, depth, path, via_link_type)
+
+            # Seed with depth-0 neighbors
+            def _get_neighbors(claim_id: int) -> list[tuple[int, str]]:
+                neighbors: list[tuple[int, str]] = []
+                if direction in ("outgoing", "both"):
+                    q = "SELECT target_id, link_type FROM claim_links WHERE source_id = ?"
+                    for row in conn.execute(q, (claim_id,)).fetchall():
+                        if link_types is None or row[1] in link_types:
+                            neighbors.append((row[0], row[1]))
+                if direction in ("incoming", "both"):
+                    q = "SELECT source_id, link_type FROM claim_links WHERE target_id = ?"
+                    for row in conn.execute(q, (claim_id,)).fetchall():
+                        if link_types is None or row[1] in link_types:
+                            neighbors.append((row[0], row[1]))
+                return neighbors
+
+            for neighbor_id, link_type in _get_neighbors(start_claim_id):
+                if neighbor_id not in visited:
+                    visited.add(neighbor_id)
+                    queue.append((neighbor_id, 1, [start_claim_id, neighbor_id], link_type))
+
+            results: list[dict] = []
+            while queue:
+                cid, depth, path, via_type = queue.pop(0)
+                claim = self.get_claim(cid, include_citations=False)
+                if claim:
+                    results.append({
+                        "claim": claim,
+                        "depth": depth,
+                        "path": path,
+                        "link_type": via_type,
+                    })
+                if depth < max_depth:
+                    for neighbor_id, link_type in _get_neighbors(cid):
+                        if neighbor_id not in visited:
+                            visited.add(neighbor_id)
+                            queue.append((neighbor_id, depth + 1, path + [neighbor_id], link_type))
+
+        return results
+

{memorymaster-3.2.2 → memorymaster-3.3.1}/memorymaster/_storage_schema.py

@@ -262,21 +262,57 @@ class _SchemaMixin:
 
     @staticmethod
     def _ensure_claim_links_schema(conn: sqlite3.Connection) -> None:
-        conn.execute(
-            """
-            CREATE TABLE IF NOT EXISTS claim_links (
-                id INTEGER PRIMARY KEY AUTOINCREMENT,
-                source_id INTEGER NOT NULL,
-                target_id INTEGER NOT NULL,
-                link_type TEXT NOT NULL,
-                created_at TEXT NOT NULL,
-                FOREIGN KEY (source_id) REFERENCES claims(id) ON DELETE CASCADE,
-                FOREIGN KEY (target_id) REFERENCES claims(id) ON DELETE CASCADE,
-                CHECK (source_id <> target_id),
-                CHECK (link_type IN ('relates_to', 'supersedes', 'derived_from', 'contradicts', 'supports'))
-            )
-            """
-        )
+        from memorymaster.models import CLAIM_LINK_TYPES
+
+        # Build the CHECK constraint from the canonical CLAIM_LINK_TYPES tuple
+        # so new types only need to be added in models.py.
+        types_sql = ", ".join(f"'{t}'" for t in CLAIM_LINK_TYPES)
+        check_clause = f"CHECK (link_type IN ({types_sql}))"
+
+        # Check if table exists and whether it needs migration (old CHECK with only 5 types)
+        existing = conn.execute(
+            "SELECT sql FROM sqlite_master WHERE type='table' AND name='claim_links'"
+        ).fetchone()
+
+        if existing and existing[0]:
+            # Table exists — check if it has the old 5-type CHECK
+            if "'implements'" not in existing[0]:
+                # Migrate: rename old → create new → copy → drop old
+                conn.execute("ALTER TABLE claim_links RENAME TO _claim_links_old")
+                conn.execute(f"""
+                    CREATE TABLE claim_links (
+                        id INTEGER PRIMARY KEY AUTOINCREMENT,
+                        source_id INTEGER NOT NULL,
+                        target_id INTEGER NOT NULL,
+                        link_type TEXT NOT NULL,
+                        created_at TEXT NOT NULL,
+                        FOREIGN KEY (source_id) REFERENCES claims(id) ON DELETE CASCADE,
+                        FOREIGN KEY (target_id) REFERENCES claims(id) ON DELETE CASCADE,
+                        CHECK (source_id <> target_id),
+                        {check_clause}
+                    )
+                """)
+                conn.execute("""
+                    INSERT INTO claim_links (id, source_id, target_id, link_type, created_at)
+                    SELECT id, source_id, target_id, link_type, created_at FROM _claim_links_old
+                """)
+                conn.execute("DROP TABLE _claim_links_old")
+        else:
+            # Fresh creation
+            conn.execute(f"""
+                CREATE TABLE IF NOT EXISTS claim_links (
+                    id INTEGER PRIMARY KEY AUTOINCREMENT,
+                    source_id INTEGER NOT NULL,
+                    target_id INTEGER NOT NULL,
+                    link_type TEXT NOT NULL,
+                    created_at TEXT NOT NULL,
+                    FOREIGN KEY (source_id) REFERENCES claims(id) ON DELETE CASCADE,
+                    FOREIGN KEY (target_id) REFERENCES claims(id) ON DELETE CASCADE,
+                    CHECK (source_id <> target_id),
+                    {check_clause}
+                )
+            """)
+
         conn.execute(
             "CREATE UNIQUE INDEX IF NOT EXISTS idx_claim_links_unique ON claim_links(source_id, target_id, link_type)"
         )

{memorymaster-3.2.2 → memorymaster-3.3.1}/memorymaster/cli.py

@@ -375,6 +375,22 @@ def build_parser() -> argparse.ArgumentParser:
     dream_clean_cmd.add_argument("--project", default=None, help="Project path to compute Claude Code memory dir slug")
     dream_clean_cmd.add_argument("--dry-run", action="store_true", help="Preview what would be removed without deleting files")
 
+    # Entity registry (GBrain-inspired)
+    entity_list = sub.add_parser("entity-list", help="List canonical entities with alias and claim counts")
+    entity_list.add_argument("--scope", default="", help="Filter by scope prefix")
+    entity_list.add_argument("--type", default="", help="Filter by entity type")
+    entity_list.add_argument("--limit", type=int, default=50)
+
+    entity_merge = sub.add_parser("entity-merge", help="Merge two entities (move aliases + claims to target)")
+    entity_merge.add_argument("keep_id", type=int, help="Entity ID to keep")
+    entity_merge.add_argument("merge_id", type=int, help="Entity ID to merge into keep_id")
+
+    entity_aliases_cmd = sub.add_parser("entity-aliases", help="List or add aliases for an entity")
+    entity_aliases_cmd.add_argument("entity_id", type=int, help="Entity ID")
+    entity_aliases_cmd.add_argument("--add", default="", help="Add this alias to the entity")
+
+    entity_backfill = sub.add_parser("entity-backfill", help="Backfill entity_id on claims with subject but no entity")
+
     return parser
 
 

{memorymaster-3.2.2 → memorymaster-3.3.1}/memorymaster/cli_handlers_curation.py

@@ -673,3 +673,83 @@ COMMAND_HANDLERS["dream-seed"] = _handle_dream_seed
 COMMAND_HANDLERS["dream-ingest"] = _handle_dream_ingest
 COMMAND_HANDLERS["dream-sync"] = _handle_dream_sync
 COMMAND_HANDLERS["dream-clean"] = _handle_dream_clean
+
+
+# ---------------------------------------------------------------------------
+# Entity registry (GBrain-inspired)
+# ---------------------------------------------------------------------------
+
+def _handle_entity_list(args, service, parser, effective_db) -> int:
+    from memorymaster.entity_registry import list_entities
+    t0 = time.perf_counter()
+    with service.store.connect() as conn:
+        entities = list_entities(
+            conn,
+            scope=args.scope or None,
+            entity_type=getattr(args, "type", "") or None,
+            limit=args.limit,
+        )
+    elapsed_ms = (time.perf_counter() - t0) * 1000
+    if args.json_output:
+        print(_json_envelope(entities, total=len(entities), query_ms=elapsed_ms))
+    else:
+        print(f"Entities ({len(entities)}):")
+        for e in entities:
+            print(f"  #{e['id']} [{e['type']}] {e['name']} — {e['alias_count']} aliases, {e['claim_count']} claims (scope={e['scope']})")
+    return 0
+
+
+def _handle_entity_merge(args, service, parser, effective_db) -> int:
+    from memorymaster.entity_registry import merge_entities
+    t0 = time.perf_counter()
+    with service.store.connect() as conn:
+        result = merge_entities(conn, args.keep_id, args.merge_id)
+        conn.commit()
+    elapsed_ms = (time.perf_counter() - t0) * 1000
+    if args.json_output:
+        print(_json_envelope(result, query_ms=elapsed_ms))
+    else:
+        print(f"Merged entity #{args.merge_id} → #{args.keep_id}: {result['merged_aliases']} aliases, {result['updated_claims']} claims moved ({elapsed_ms:.0f}ms)")
+    return 0
+
+
+def _handle_entity_aliases(args, service, parser, effective_db) -> int:
+    from memorymaster.entity_registry import get_aliases, add_alias
+    t0 = time.perf_counter()
+    with service.store.connect() as conn:
+        if args.add:
+            added = add_alias(conn, args.entity_id, args.add)
+            conn.commit()
+            if args.json_output:
+                print(_json_envelope({"added": added, "alias": args.add}, query_ms=(time.perf_counter() - t0) * 1000))
+            else:
+                print(f"{'Added' if added else 'Already exists'}: '{args.add}' → entity #{args.entity_id}")
+        else:
+            aliases = get_aliases(conn, args.entity_id)
+            elapsed_ms = (time.perf_counter() - t0) * 1000
+            if args.json_output:
+                print(_json_envelope(aliases, total=len(aliases), query_ms=elapsed_ms))
+            else:
+                print(f"Aliases for entity #{args.entity_id} ({len(aliases)}):")
+                for a in aliases:
+                    print(f"  - {a}")
+    return 0
+
+
+def _handle_entity_backfill(args, service, parser, effective_db) -> int:
+    from memorymaster.entity_registry import backfill_entities
+    t0 = time.perf_counter()
+    with service.store.connect() as conn:
+        result = backfill_entities(conn)
+    elapsed_ms = (time.perf_counter() - t0) * 1000
+    if args.json_output:
+        print(_json_envelope(result, query_ms=elapsed_ms))
+    else:
+        print(f"Backfill: {result['entities_created']} entities created, {result['claims_resolved']} claims resolved ({result['subjects_processed']} subjects processed, {elapsed_ms:.0f}ms)")
+    return 0
+
+
+COMMAND_HANDLERS["entity-list"] = _handle_entity_list
+COMMAND_HANDLERS["entity-merge"] = _handle_entity_merge
+COMMAND_HANDLERS["entity-aliases"] = _handle_entity_aliases
+COMMAND_HANDLERS["entity-backfill"] = _handle_entity_backfill

memorymaster-3.3.1/memorymaster/entity_registry.py

@@ -0,0 +1,255 @@
+"""Entity Registry — canonical entities with alias resolution.
+
+Inspired by GBrain's entity registry pattern: every subject string resolves
+to a canonical entity so that "MemoryMaster", "memorymaster", "MM" all point
+to the same node. This turns the flat claims DB into a real knowledge graph.
+
+Tables:
+  - entities: canonical entity (id, name, type, scope, created/updated)
+  - entity_aliases: maps normalized alias strings → entity id
+
+Resolution flow (on ingest):
+  1. Normalize subject string (lowercase, strip, collapse separators)
+  2. Look up in entity_aliases
+  3. If found → return canonical entity_id
+  4. If not found → create new entity + register the alias
+  5. Store entity_id on the claim
+
+The claim.subject column stays as free-text for display; entity_id is the
+canonical FK used for grouping and traversal.
+"""
+from __future__ import annotations
+
+import logging
+import re
+import sqlite3
+from datetime import datetime, timezone
+
+logger = logging.getLogger(__name__)
+
+_NORMALIZE_RE = re.compile(r"[\s_\-\.]+")
+
+
+def normalize_alias(raw: str) -> str:
+    """Normalize a subject string for alias lookup.
+
+    Lowercases, collapses whitespace/dashes/underscores/dots into single
+    dashes, strips leading/trailing separators. Truncates to 200 chars.
+    """
+    if not raw:
+        return ""
+    return _NORMALIZE_RE.sub("-", raw.strip().lower()).strip("-")[:200]
+
+
+def ensure_entity_schema(conn: sqlite3.Connection) -> None:
+    """Create entity tables if they don't exist. Idempotent."""
+    conn.executescript("""
+        CREATE TABLE IF NOT EXISTS entities (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            canonical_name TEXT NOT NULL UNIQUE,
+            entity_type TEXT NOT NULL DEFAULT 'unknown',
+            scope TEXT NOT NULL DEFAULT 'global',
+            created_at TEXT NOT NULL,
+            updated_at TEXT NOT NULL
+        );
+
+        CREATE TABLE IF NOT EXISTS entity_aliases (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            entity_id INTEGER NOT NULL,
+            alias TEXT NOT NULL UNIQUE,
+            original_form TEXT NOT NULL,
+            created_at TEXT NOT NULL,
+            FOREIGN KEY (entity_id) REFERENCES entities(id) ON DELETE CASCADE
+        );
+
+        CREATE INDEX IF NOT EXISTS idx_entity_aliases_alias
+            ON entity_aliases(alias);
+        CREATE INDEX IF NOT EXISTS idx_entity_aliases_entity_id
+            ON entity_aliases(entity_id);
+    """)
+
+
+def _utc_now() -> str:
+    return datetime.now(timezone.utc).replace(microsecond=0).isoformat()
+
+
+def resolve_or_create(
+    conn: sqlite3.Connection,
+    subject: str,
+    *,
+    entity_type: str = "unknown",
+    scope: str = "global",
+) -> int:
+    """Resolve a subject string to a canonical entity_id, creating if needed.
+
+    Returns the entity_id (int). Thread-safe via SQLite serialization.
+    """
+    alias = normalize_alias(subject)
+    if not alias:
+        return 0
+
+    # Fast path: alias already registered
+    row = conn.execute(
+        "SELECT entity_id FROM entity_aliases WHERE alias = ?", (alias,)
+    ).fetchone()
+    if row:
+        return row[0]
+
+    # Slow path: create entity + register alias
+    now = _utc_now()
+    display_name = subject.strip()[:200]
+
+    cur = conn.execute(
+        """INSERT OR IGNORE INTO entities (canonical_name, entity_type, scope, created_at, updated_at)
+           VALUES (?, ?, ?, ?, ?)""",
+        (display_name, entity_type, scope, now, now),
+    )
+    if cur.lastrowid and cur.lastrowid > 0:
+        entity_id = cur.lastrowid
+    else:
+        # INSERT OR IGNORE hit a duplicate canonical_name — fetch existing
+        existing = conn.execute(
+            "SELECT id FROM entities WHERE canonical_name = ?", (display_name,)
+        ).fetchone()
+        entity_id = existing[0] if existing else 0
+
+    if entity_id > 0:
+        conn.execute(
+            """INSERT OR IGNORE INTO entity_aliases (entity_id, alias, original_form, created_at)
+               VALUES (?, ?, ?, ?)""",
+            (entity_id, alias, subject.strip(), now),
+        )
+
+    return entity_id
+
+
+def merge_entities(
+    conn: sqlite3.Connection,
+    keep_id: int,
+    merge_id: int,
+) -> dict:
+    """Merge entity merge_id INTO keep_id. All aliases of merge_id move to keep_id.
+
+    Returns {"merged_aliases": int, "updated_claims": int}.
+    """
+    # Move aliases
+    cur = conn.execute(
+        "UPDATE entity_aliases SET entity_id = ? WHERE entity_id = ?",
+        (keep_id, merge_id),
+    )
+    merged_aliases = cur.rowcount
+
+    # Move claims that reference merge_id
+    cur2 = conn.execute(
+        "UPDATE claims SET entity_id = ? WHERE entity_id = ?",
+        (keep_id, merge_id),
+    )
+    updated_claims = cur2.rowcount
+
+    # Delete the merged entity
+    conn.execute("DELETE FROM entities WHERE id = ?", (merge_id,))
+
+    return {"merged_aliases": merged_aliases, "updated_claims": updated_claims}
+
+
+def add_alias(conn: sqlite3.Connection, entity_id: int, alias_text: str) -> bool:
+    """Register an additional alias for an entity. Returns True if added."""
+    alias = normalize_alias(alias_text)
+    if not alias:
+        return False
+    now = _utc_now()
+    try:
+        conn.execute(
+            """INSERT INTO entity_aliases (entity_id, alias, original_form, created_at)
+               VALUES (?, ?, ?, ?)""",
+            (entity_id, alias, alias_text.strip(), now),
+        )
+        return True
+    except sqlite3.IntegrityError:
+        return False  # alias already registered
+
+
+def list_entities(
+    conn: sqlite3.Connection,
+    *,
+    scope: str | None = None,
+    entity_type: str | None = None,
+    limit: int = 100,
+) -> list[dict]:
+    """List entities with their alias counts and claim counts."""
+    query = """
+        SELECT e.id, e.canonical_name, e.entity_type, e.scope, e.created_at,
+               COUNT(DISTINCT a.id) as alias_count,
+               COUNT(DISTINCT c.id) as claim_count
+        FROM entities e
+        LEFT JOIN entity_aliases a ON a.entity_id = e.id
+        LEFT JOIN claims c ON c.entity_id = e.id
+    """
+    params: list = []
+    wheres: list[str] = []
+    if scope:
+        wheres.append("e.scope LIKE ?")
+        params.append(f"{scope}%")
+    if entity_type:
+        wheres.append("e.entity_type = ?")
+        params.append(entity_type)
+    if wheres:
+        query += " WHERE " + " AND ".join(wheres)
+    query += " GROUP BY e.id ORDER BY claim_count DESC LIMIT ?"
+    params.append(limit)
+
+    rows = conn.execute(query, params).fetchall()
+    return [
+        {
+            "id": r[0],
+            "name": r[1],
+            "type": r[2],
+            "scope": r[3],
+            "created_at": r[4],
+            "alias_count": r[5],
+            "claim_count": r[6],
+        }
+        for r in rows
+    ]
+
+
+def get_aliases(conn: sqlite3.Connection, entity_id: int) -> list[str]:
+    """Get all aliases for an entity."""
+    rows = conn.execute(
+        "SELECT original_form FROM entity_aliases WHERE entity_id = ? ORDER BY created_at",
+        (entity_id,),
+    ).fetchall()
+    return [r[0] for r in rows]
+
+
+def backfill_entities(conn: sqlite3.Connection) -> dict:
+    """Backfill entity_id on existing claims that have subject but no entity_id.
+
+    Creates entities and aliases as needed. Returns stats.
+    """
+    ensure_entity_schema(conn)
+
+    # Ensure entity_id column exists on claims
+    try:
+        conn.execute("ALTER TABLE claims ADD COLUMN entity_id INTEGER")
+    except sqlite3.OperationalError:
+        pass  # already exists
+
+    rows = conn.execute(
+        "SELECT DISTINCT subject FROM claims WHERE subject IS NOT NULL AND (entity_id IS NULL OR entity_id = 0)"
+    ).fetchall()
+
+    created = 0
+    resolved = 0
+    for (subject,) in rows:
+        entity_id = resolve_or_create(conn, subject)
+        if entity_id > 0:
+            cur = conn.execute(
+                "UPDATE claims SET entity_id = ? WHERE subject = ? AND (entity_id IS NULL OR entity_id = 0)",
+                (entity_id, subject),
+            )
+            resolved += cur.rowcount
+            created += 1
+
+    conn.commit()
+    return {"entities_created": created, "claims_resolved": resolved, "subjects_processed": len(rows)}

{memorymaster-3.2.2 → memorymaster-3.3.1}/memorymaster/mcp_server.py

@@ -89,13 +89,26 @@ def _parse_scope_allowlist(raw: str) -> list[str] | None:
 
 
 def _project_scope(workspace: str) -> str:
+    """Derive a project scope from a workspace path.
+
+    Returns the canonical ``project:<slug>`` form by default. The legacy
+    hash-suffix form ``project:<slug>:<sha1[:8]>`` is only used when the env
+    var ``MEMORYMASTER_SCOPE_DISAMBIGUATE=1`` is set — that's the escape hatch
+    for hosts that genuinely have two different workspaces with the same
+    directory name. For the common case (one workspace per slug on a host),
+    dropping the hash prevents scope fragmentation where CLI ingests write
+    ``project:wezbridge`` and MCP ingests write ``project:wezbridge:a6a83c6a``
+    and nobody finds each other.
+    """
     if _ENV_DEFAULT_PROJECT_SCOPE:
         return _ENV_DEFAULT_PROJECT_SCOPE
     workspace_path = Path(_resolve_workspace(workspace)).resolve()
     slug_base = workspace_path.name.strip().lower() or "workspace"
     slug = _SCOPE_SAFE_RE.sub("-", slug_base).strip("-") or "workspace"
-    digest = hashlib.sha1(str(workspace_path).lower().encode("utf-8")).hexdigest()[:8]
-    return f"project:{slug}:{digest}"
+    if os.getenv("MEMORYMASTER_SCOPE_DISAMBIGUATE", "").strip().lower() in ("1", "true", "yes"):
+        digest = hashlib.sha1(str(workspace_path).lower().encode("utf-8")).hexdigest()[:8]
+        return f"project:{slug}:{digest}"
+    return f"project:{slug}"
 
 
 def _effective_ingest_scope(scope: str, workspace: str) -> str:

{memorymaster-3.2.2 → memorymaster-3.3.1}/memorymaster/models.py

@@ -272,11 +272,22 @@ class Event:
 
 
 CLAIM_LINK_TYPES = (
+    # Core lifecycle types (original v2.0)
     "relates_to",
     "supersedes",
     "derived_from",
     "contradicts",
     "supports",
+    # Domain-specific relationship types (GBrain-inspired, v3.3)
+    "implements",       # claim A describes an implementation of claim B
+    "configures",       # claim A configures/parametrizes claim B
+    "depends_on",       # claim A requires claim B to function
+    "deployed_on",      # claim A is deployed on infrastructure described by claim B
+    "owned_by",         # claim A is owned/maintained by entity in claim B
+    "tested_by",        # claim A is validated by test described in claim B
+    "documents",        # claim A documents behavior of claim B
+    "blocks",           # claim A blocks progress on claim B
+    "enables",          # claim A enables/unlocks claim B
 )
 
 

{memorymaster-3.2.2 → memorymaster-3.3.1}/memorymaster/service.py

@@ -120,6 +120,10 @@ class MemoryService:
             raise ValueError("Claim text cannot be empty.")
         if not citations:
             citations = [CitationInput(source="mcp-session", locator=scope or "project")]
+        # Normalize claim_type to lowercase so routing hints like "DECISION"
+        # from the classify hook don't create a separate type from "decision".
+        if claim_type:
+            claim_type = claim_type.strip().lower() or None
         # Dedup by idempotency key
         normalized_idempotency_key = (idempotency_key or "").strip() or None
         if normalized_idempotency_key is not None and hasattr(self.store, "get_claim_by_idempotency_key"):
@@ -146,6 +150,21 @@ class MemoryService:
         )
         if not sanitized.citations:
             raise ValueError("At least one citation is required.")
+        # Resolve subject → canonical entity (GBrain-inspired entity registry)
+        entity_id = 0
+        if subject:
+            try:
+                from memorymaster.entity_registry import resolve_or_create
+                with self.store.connect() as _conn:
+                    entity_id = resolve_or_create(
+                        _conn, subject,
+                        entity_type=claim_type or "unknown",
+                        scope=scope,
+                    )
+                    _conn.commit()
+            except Exception:
+                pass  # entity resolution is best-effort, never block ingest
+
         claim = self.store.create_claim(
             text=sanitized.text,
             citations=sanitized.citations,
@@ -164,6 +183,18 @@ class MemoryService:
             source_agent=source_agent,
             visibility=visibility,
         )
+
+        # Set entity_id on the claim (best-effort, don't fail ingest)
+        if entity_id > 0:
+            try:
+                with self.store.connect() as _conn:
+                    _conn.execute(
+                        "UPDATE claims SET entity_id = ? WHERE id = ?",
+                        (entity_id, claim.id),
+                    )
+                    _conn.commit()
+            except Exception:
+                pass
         if sanitized.is_sensitive:
             self.store.record_event(
                 claim_id=claim.id,

{memorymaster-3.2.2 → memorymaster-3.3.1}/memorymaster/storage.py

@@ -90,4 +90,11 @@ class SQLiteStore(_SchemaMixin, _ReadMixin, _WriteClaimsMixin, _LifecycleMixin):
             self._ensure_agent_columns(conn)
             self._ensure_version_column(conn)
             self._ensure_embeddings_schema(conn)
+            # Entity registry (GBrain-inspired canonical entities + alias resolution)
+            from memorymaster.entity_registry import ensure_entity_schema
+            ensure_entity_schema(conn)
+            try:
+                conn.execute("ALTER TABLE claims ADD COLUMN entity_id INTEGER")
+            except sqlite3.OperationalError:
+                pass  # already exists
             conn.commit()

{memorymaster-3.2.2 → memorymaster-3.3.1/memorymaster.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: memorymaster
-Version: 3.2.2
+Version: 3.3.1
 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

{memorymaster-3.2.2 → memorymaster-3.3.1}/memorymaster.egg-info/SOURCES.txt

@@ -29,6 +29,7 @@ memorymaster/db_merge.py
 memorymaster/dream_bridge.py
 memorymaster/embeddings.py
 memorymaster/entity_graph.py
+memorymaster/entity_registry.py
 memorymaster/feedback.py
 memorymaster/lifecycle.py
 memorymaster/llm_provider.py

{memorymaster-3.2.2 → memorymaster-3.3.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "memorymaster"
-version = "3.2.2"
+version = "3.3.1"
 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"}]