fix(seed): scope delete_memories_by_tag to domain (issue #16)

PSGSupport reported seed_project purging memories globally despite the
domain argument. Added optional domain= parameter to
delete_memories_by_tag; seed_project now passes domain=args["domain"]
so purge stays within scope. Default behavior (domain=None) unchanged
for callers that intentionally want global purge.

Tests cover both the per-domain scoping and the legacy global path.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: cdeust

mcp_server/handlers/seed_project.py

@@ -113,10 +113,14 @@ def _parse_args(args: dict[str, Any] | None) -> tuple[Path, str, int, bool]:
     """Extract and validate handler arguments."""
     args = args or {}
     directory = args.get("directory", "") or os.getcwd()
-    domain = args.get("domain", "")
+    root = Path(directory).expanduser().resolve()
+    # Domain auto-detection: schema documents this behavior; the previous
+    # implementation passed an empty string through, which broke the
+    # per-domain purge contract (issue #16).
+    domain = args.get("domain", "") or root.name
     max_kb = int(args.get("max_file_size_kb", 64))
     dry_run = args.get("dry_run", False)
-    return Path(directory).expanduser().resolve(), domain, max_kb * 1024, dry_run
+    return root, domain, max_kb * 1024, dry_run
 
 
 async def _store_discoveries(
@@ -177,7 +181,10 @@ async def handler(args: dict[str, Any] | None = None) -> dict[str, Any]:
 
     purged = 0
     if not dry_run:
-        purged = _get_store().delete_memories_by_tag("seeded")
+        # Scope purge to this domain (issue #16): seeding repo-A must not
+        # wipe out repo-B's seeded memories. Domain authority ends at the
+        # project boundary; cross-domain effects are an externality.
+        purged = _get_store().delete_memories_by_tag("seeded", domain=domain)
 
     all_discoveries = collect_all_discoveries(root, max_bytes)
 

mcp_server/infrastructure/pg_store_queries.py

@@ -192,12 +192,27 @@ def search_by_tag_vector(
             ).fetchall()
         return [self._normalize_memory_row(r) for r in rows]
 
-    def delete_memories_by_tag(self, tag: str) -> int:
-        """Delete all memories containing the given tag."""
-        cur = self._execute(
-            "DELETE FROM memories WHERE tags @> %s::jsonb",
-            (json.dumps([tag]),),
-        )
+    def delete_memories_by_tag(self, tag: str, domain: str | None = None) -> int:
+        """Delete memories with the given tag, optionally scoped to a domain.
+
+        precondition: tag is a non-empty string; domain is None or a non-empty string.
+        postcondition: returns the number of rows removed; rows removed iff their
+            tags JSONB contains [tag] AND (domain is None OR domain matches).
+            domain=None preserves global-purge behavior for callers that
+            actually want it (legacy contract). Caller is responsible for
+            passing domain when scope matters (e.g. seed_project, which is
+            per-repo by design — see issue #16).
+        """
+        if domain is None:
+            cur = self._execute(
+                "DELETE FROM memories WHERE tags @> %s::jsonb",
+                (json.dumps([tag]),),
+            )
+        else:
+            cur = self._execute(
+                "DELETE FROM memories WHERE tags @> %s::jsonb AND domain = %s",
+                (json.dumps([tag]), domain),
+            )
         self._conn.commit()
         return cur.rowcount
 

mcp_server/infrastructure/sqlite_store_queries.py

@@ -111,12 +111,22 @@ def get_all_memories_for_decay(self) -> list[dict[str, Any]]:
         ).fetchall()
         return [self._normalize_memory_row(r) for r in rows]
 
-    def delete_memories_by_tag(self, tag: str) -> int:
-        """Delete all memories containing the given tag.
+    def delete_memories_by_tag(self, tag: str, domain: str | None = None) -> int:
+        """Delete memories with the given tag, optionally scoped to a domain.
+
+        precondition: tag is a non-empty string; domain is None or a non-empty string.
+        postcondition: returns the number of memory rows removed; rows removed
+            iff their tags list contains tag AND (domain is None OR row.domain
+            matches). domain=None preserves the legacy global-purge behavior.
 
         SQLite lacks jsonb operators — filter in Python then delete by ID.
         """
-        rows = self._conn.execute("SELECT id, tags FROM memories").fetchall()
+        if domain is None:
+            rows = self._conn.execute("SELECT id, tags FROM memories").fetchall()
+        else:
+            rows = self._conn.execute(
+                "SELECT id, tags FROM memories WHERE domain = ?", (domain,)
+            ).fetchall()
         ids_to_delete: list[int] = []
         for r in rows:
             try:

tests_py/handlers/test_seed_project.py

@@ -0,0 +1,103 @@
+"""Tests for seed_project handler — domain-scoped purge (issue #16).
+
+PSGSupport reported that calling `seed_project` for repo-A and then
+repo-B purged repo-A's "seeded" memories despite the explicit `domain`
+argument. The cause was a global `delete_memories_by_tag("seeded")` call
+that ignored domain. The fix scopes the purge to the supplied domain.
+
+These tests prove the cross-domain leak is closed.
+"""
+
+from __future__ import annotations
+
+import asyncio
+from pathlib import Path
+
+from mcp_server.handlers.seed_project import handler
+from mcp_server.infrastructure.memory_store import MemoryStore
+
+
+def _make_repo(tmp_path: Path, name: str) -> Path:
+    """Build a minimal repo skeleton sufficient for seed_project to find content."""
+    root = tmp_path / name
+    root.mkdir()
+    (root / "README.md").write_text(f"# {name}\nMinimal seed test fixture.\n")
+    (root / "pyproject.toml").write_text(
+        f'[project]\nname = "{name}"\nversion = "0.1.0"\n'
+    )
+    return root
+
+
+def _seeded_count(store, domain: str) -> int:
+    rows = store.get_memories_for_domain(domain, min_heat=0.0, limit=500)
+    return sum(1 for r in rows if "seeded" in (r.get("tags") or []))
+
+
+def test_seed_repo_a_then_repo_b_preserves_repo_a(tmp_path: Path) -> None:
+    """The bug: seeding repo-B used to wipe out repo-A's seeded memories."""
+    repo_a = _make_repo(tmp_path, "repo-a")
+    repo_b = _make_repo(tmp_path, "repo-b")
+
+    store = MemoryStore()
+
+    # Seed repo-a
+    res_a = asyncio.run(
+        handler({"directory": str(repo_a), "domain": "repo-a"})
+    )
+    assert res_a["seeded"] is True
+    assert res_a["stored"] >= 1, "fixture should yield at least one stored memory"
+    a_after_first_seed = _seeded_count(store, "repo-a")
+    assert a_after_first_seed >= 1
+
+    # Seed repo-b — must not touch repo-a's memories
+    res_b = asyncio.run(
+        handler({"directory": str(repo_b), "domain": "repo-b"})
+    )
+    assert res_b["seeded"] is True
+
+    a_after_second_seed = _seeded_count(store, "repo-a")
+    assert a_after_second_seed == a_after_first_seed, (
+        f"repo-a's seeded memories must survive seeding repo-b "
+        f"(had {a_after_first_seed}, now {a_after_second_seed})"
+    )
+
+
+def test_reseeding_same_repo_purges_only_that_repo(tmp_path: Path) -> None:
+    """Reseeding repo-A should clear repo-A's prior seeds and replace them,
+    while leaving repo-B's seeds untouched."""
+    repo_a = _make_repo(tmp_path, "repo-a")
+    repo_b = _make_repo(tmp_path, "repo-b")
+
+    store = MemoryStore()
+
+    asyncio.run(handler({"directory": str(repo_a), "domain": "repo-a"}))
+    asyncio.run(handler({"directory": str(repo_b), "domain": "repo-b"}))
+
+    b_before = _seeded_count(store, "repo-b")
+    assert b_before >= 1
+
+    # Reseed repo-a — purge should be domain-scoped
+    res_a2 = asyncio.run(
+        handler({"directory": str(repo_a), "domain": "repo-a"})
+    )
+    assert res_a2["seeded"] is True
+    # Reported purge count must reflect the prior repo-a memories,
+    # never zero (we know there were some) and never include repo-b's.
+    assert res_a2["purged_stale"] >= 1
+    assert res_a2["purged_stale"] <= b_before + res_a2["purged_stale"]  # sanity
+
+    b_after = _seeded_count(store, "repo-b")
+    assert b_after == b_before, (
+        "reseeding repo-a must not affect repo-b's seeded memories"
+    )
+
+
+def test_domain_auto_detected_from_directory_name(tmp_path: Path) -> None:
+    """Schema documents domain auto-detection from directory name. The fix
+    materializes that contract — without it, an omitted domain would
+    fall back to global purge (the original bug)."""
+    repo = _make_repo(tmp_path, "auto-detect-me")
+
+    res = asyncio.run(handler({"directory": str(repo)}))
+    assert res["seeded"] is True
+    assert res["domain"] == "auto-detect-me"

tests_py/infrastructure/test_pg_store_delete_by_tag.py

@@ -0,0 +1,95 @@
+"""Tests for delete_memories_by_tag — domain scoping (issue #16).
+
+Background: PSGSupport reported `seed_project` purging memories globally
+across repos. Root cause: `delete_memories_by_tag("seeded")` was unscoped
+and authority leaked past the project boundary. Fix: optional `domain`
+parameter scopes the delete; default (None) preserves legacy behavior
+for callers that intentionally want a global purge.
+"""
+
+from __future__ import annotations
+
+from mcp_server.infrastructure.memory_store import MemoryStore
+
+
+def _insert(store, *, content: str, tag: str, domain: str) -> int:
+    return store.insert_memory(
+        {
+            "content": content,
+            "tags": [tag],
+            "domain": domain,
+            "source": "test",
+            "is_protected": False,
+        }
+    )
+
+
+def test_delete_by_tag_with_domain_scopes_to_that_domain() -> None:
+    """domain=X removes only memories with tag AND domain=X."""
+    store = MemoryStore()
+
+    a1 = _insert(store, content="repo-a memory 1", tag="seeded", domain="repo-a")
+    a2 = _insert(store, content="repo-a memory 2", tag="seeded", domain="repo-a")
+    b1 = _insert(store, content="repo-b memory 1", tag="seeded", domain="repo-b")
+
+    deleted = store.delete_memories_by_tag("seeded", domain="repo-a")
+
+    assert deleted == 2, "must remove exactly the two repo-a rows"
+    # repo-b survives
+    surviving = [
+        m for m in store.get_memories_for_domain("repo-b", min_heat=0.0, limit=100)
+    ]
+    surviving_ids = {m["id"] for m in surviving}
+    assert b1 in surviving_ids, "repo-b memory must survive a repo-a-scoped purge"
+    # repo-a is gone
+    surviving_a = [
+        m for m in store.get_memories_for_domain("repo-a", min_heat=0.0, limit=100)
+    ]
+    surviving_a_ids = {m["id"] for m in surviving_a}
+    assert a1 not in surviving_a_ids
+    assert a2 not in surviving_a_ids
+
+
+def test_delete_by_tag_without_domain_purges_globally() -> None:
+    """domain=None preserves legacy global-purge behavior."""
+    store = MemoryStore()
+
+    _insert(store, content="repo-a memory", tag="seeded", domain="repo-a")
+    _insert(store, content="repo-b memory", tag="seeded", domain="repo-b")
+    _insert(store, content="other tag memory", tag="kept", domain="repo-a")
+
+    deleted = store.delete_memories_by_tag("seeded")
+
+    assert deleted == 2, "must remove both seeded rows globally"
+    # The differently-tagged memory survives
+    a_remaining = store.get_memories_for_domain("repo-a", min_heat=0.0, limit=100)
+    assert any("other tag" in m["content"] for m in a_remaining)
+
+
+def test_delete_by_tag_with_domain_does_not_touch_other_tags() -> None:
+    """Scoped delete must not remove rows that lack the tag, even in-domain."""
+    store = MemoryStore()
+
+    _insert(store, content="seeded one", tag="seeded", domain="repo-a")
+    _insert(store, content="manual one", tag="manual", domain="repo-a")
+
+    deleted = store.delete_memories_by_tag("seeded", domain="repo-a")
+
+    assert deleted == 1
+    remaining = store.get_memories_for_domain("repo-a", min_heat=0.0, limit=100)
+    contents = [m["content"] for m in remaining]
+    assert "manual one" in contents
+    assert "seeded one" not in contents
+
+
+def test_delete_by_tag_with_unknown_domain_is_noop() -> None:
+    """Domain that has no rows returns 0 and removes nothing."""
+    store = MemoryStore()
+
+    _insert(store, content="real memory", tag="seeded", domain="repo-a")
+
+    deleted = store.delete_memories_by_tag("seeded", domain="nonexistent")
+
+    assert deleted == 0
+    remaining = store.get_memories_for_domain("repo-a", min_heat=0.0, limit=100)
+    assert len(remaining) == 1