@pentatonic-ai/ai-agent-sdk 0.9.6 → 0.10.0

package/packages/memory-engine/tests/test_l2_qmd_vec_search.py

@@ -1,280 +0,0 @@
-"""Tests for the sqlite-vec-backed QMD search path in l2-hybridrag-proxy.
-
-Validates the migration from the legacy Python-cosine-over-JSON path
-(which had a silent `ORDER BY id LIMIT 2000` correctness bug — only
-the OLDEST 2000 chunks were ever considered) to native sqlite-vec
-KNN MATCH over a vec0 virtual table.
-
-Pure-Python tests — no Neo4j, no Milvus. The proxy module is loaded
-via importlib so we can call helpers and handlers directly, and
-QMD_DB_PATH is overridden to a tmp_path file per test.
-
-Run:
-
-    cd packages/memory-engine
-    .venv/bin/python -m pytest tests/test_l2_qmd_vec_search.py -v
-
-The tests skip cleanly when ``sqlite_vec`` is not importable — useful
-for unit-only runs on machines that don't have the wheel installed.
-"""
-from __future__ import annotations
-
-import importlib.util
-import json
-import struct
-import sys
-from pathlib import Path
-
-import pytest
-
-try:
-    import sqlite_vec  # noqa: F401
-    _SQLITE_VEC_OK = True
-except ImportError:
-    _SQLITE_VEC_OK = False
-
-_skip_no_sqlite_vec = pytest.mark.skipif(
-    not _SQLITE_VEC_OK,
-    reason="sqlite_vec wheel not installed in this venv",
-)
-
-
-ENGINE_ROOT = Path(__file__).resolve().parent.parent / "engine" / "services" / "l2"
-sys.path.insert(0, str(ENGINE_ROOT))
-
-
-@pytest.fixture(scope="module")
-def proxy_module():
-    """Load l2-hybridrag-proxy as a module. Same pattern as
-    test_channel_stat_reader / test_people_list_reader so the
-    module-load failure mode (missing deps) skips cleanly rather than
-    erroring."""
-    spec = importlib.util.spec_from_file_location(
-        "l2_proxy_module_qmd_vec",
-        ENGINE_ROOT / "l2-hybridrag-proxy.py",
-    )
-    assert spec and spec.loader
-    try:
-        mod = importlib.util.module_from_spec(spec)
-        spec.loader.exec_module(mod)
-    except ImportError:
-        pytest.skip("l2 proxy deps unavailable in this venv (fine for unit-only runs)")
-    return mod
-
-
-@pytest.fixture
-def qmd_db(tmp_path, proxy_module, monkeypatch):
-    """Per-test qmd.sqlite at a tmp path, with the proxy module pointed
-    at it. Yields the path so tests can run their own asserting queries
-    against it."""
-    db_path = tmp_path / "qmd.sqlite"
-    monkeypatch.setattr(proxy_module, "QMD_DB_PATH", str(db_path))
-    return db_path
-
-
-def _make_vec(seed: int, dim: int) -> list[float]:
-    """Deterministic synthetic embedding — small enough to test fast,
-    structured enough that nearest-neighbour relationships are stable
-    across runs. The first slot dominates the cosine direction so we
-    can build orthogonal-ish clusters by varying its sign + magnitude."""
-    import random as _r
-    rng = _r.Random(seed)
-    return [rng.gauss(0.0, 1.0) for _ in range(dim)]
-
-
-# ---------------------------------------------------------------------------
-# 1. vec_index MATCH semantics — sanity check the SDK glue against sqlite-vec.
-# ---------------------------------------------------------------------------
-
-
-@_skip_no_sqlite_vec
-def test_vec_index_match_returns_top_k(qmd_db, proxy_module) -> None:
-    """Insert N known vectors with a planted ringer, query with the
-    ringer's vector, assert the ringer is the top hit. This is the
-    minimum signal that ``_ensure_vec_index`` + native MATCH actually
-    work end-to-end against the dim our proxy is configured for."""
-    conn = proxy_module._open_qmd_conn()
-    proxy_module._ensure_vec_index(conn)
-    dim = proxy_module.EMBED_DIM
-    # 20 rows of noise + 1 planted ringer at id=999. Planted vector is
-    # near-orthogonal to the noise (which uses positive-slot dominance)
-    # by flipping the first slot's sign — confirms the cosine MATCH
-    # actually orders by similarity, not by row id.
-    for i in range(20):
-        v = _make_vec(seed=i + 1, dim=dim)
-        v[0] = abs(v[0]) + 10.0  # bias positive
-        conn.execute(
-            "INSERT INTO vec_index(id, embedding) VALUES (?, ?)",
-            (i + 1, struct.pack(f"{dim}f", *v)),
-        )
-    ringer = _make_vec(seed=999, dim=dim)
-    ringer[0] = -abs(ringer[0]) - 10.0  # bias negative — opposite cluster
-    conn.execute(
-        "INSERT INTO vec_index(id, embedding) VALUES (?, ?)",
-        (999, struct.pack(f"{dim}f", *ringer)),
-    )
-    conn.commit()
-    qbytes = struct.pack(f"{dim}f", *ringer)
-    rows = conn.execute(
-        """
-        SELECT id, distance
-        FROM vec_index
-        WHERE embedding MATCH ? AND k = ?
-        ORDER BY distance
-        """,
-        (qbytes, 5),
-    ).fetchall()
-    conn.close()
-    assert len(rows) == 5
-    top_id, top_dist = rows[0]
-    assert top_id == 999, f"expected ringer id=999, got {top_id} ({rows!r})"
-    # Cosine distance = 1 - cos_sim, so identity vector → ~0 distance.
-    # Ringer-vs-itself is exact, so we expect ~0 here; allow float32
-    # round-trip slop.
-    assert top_dist < 1e-3, f"ringer-vs-itself should be ~0, got {top_dist}"
-
-
-# ---------------------------------------------------------------------------
-# 2. search_qmd_informed uses vec_index, not the legacy JSON-cosine path.
-# ---------------------------------------------------------------------------
-
-
-@_skip_no_sqlite_vec
-def test_search_qmd_informed_uses_vec_index(qmd_db, proxy_module, monkeypatch) -> None:
-    """Full search path test: seed chunks + vec_index, mock
-    ``get_embedding`` to return a vector that matches the ringer,
-    assert the returned results are sourced from the vec_index JOIN
-    (which preserves path/text from chunks) and ranked by similarity.
-
-    This is the test that would fail if someone reverted the search
-    body to the legacy ``ORDER BY id LIMIT 2000`` path — because the
-    ringer's id is 999 (well outside the 2000-row prefix), the legacy
-    path would never see it."""
-    import sqlite3
-    conn = proxy_module._open_qmd_conn()
-    proxy_module._ensure_vec_index(conn)
-    conn.execute(
-        """
-        CREATE TABLE IF NOT EXISTS chunks (
-            id INTEGER PRIMARY KEY,
-            path TEXT,
-            text TEXT,
-            embedding TEXT,
-            embedding_model TEXT,
-            embedding_dim INTEGER,
-            chunk_index INTEGER,
-            created_at TEXT
-        )
-        """
-    )
-    dim = proxy_module.EMBED_DIM
-    # Noise rows 1..20 + planted ringer id=999. Same orthogonal-cluster
-    # setup as test 1 — guarantees the ringer wins on cosine.
-    for i in range(20):
-        v = _make_vec(seed=i + 1, dim=dim)
-        v[0] = abs(v[0]) + 10.0
-        conn.execute(
-            "INSERT INTO chunks(id, path, text, embedding) VALUES (?, ?, ?, ?)",
-            (i + 1, f"noise/{i}.md", f"noise text {i}", json.dumps(v)),
-        )
-        conn.execute(
-            "INSERT INTO vec_index(id, embedding) VALUES (?, ?)",
-            (i + 1, struct.pack(f"{dim}f", *v)),
-        )
-    ringer = _make_vec(seed=999, dim=dim)
-    ringer[0] = -abs(ringer[0]) - 10.0
-    conn.execute(
-        "INSERT INTO chunks(id, path, text, embedding) VALUES (?, ?, ?, ?)",
-        (999, "ringer/needle.md", "needle in the haystack", json.dumps(ringer)),
-    )
-    conn.execute(
-        "INSERT INTO vec_index(id, embedding) VALUES (?, ?)",
-        (999, struct.pack(f"{dim}f", *ringer)),
-    )
-    conn.commit()
-    conn.close()
-
-    # Mock get_embedding to return the ringer's vector for any query.
-    monkeypatch.setattr(proxy_module, "get_embedding", lambda *_a, **_kw: ringer)
-
-    out = proxy_module.search_qmd_informed(
-        "any query — get_embedding is mocked",
-        {"graph_entities": []},
-        limit=3,
-    )
-    assert out, "search returned empty; vec_index path must surface ringer"
-    top = out[0]
-    assert top["path"] == "ringer/needle.md", (
-        f"top hit should be the ringer at row 999; got {top['path']}. "
-        f"If this fails, the search may have reverted to the LIMIT 2000 "
-        f"legacy path which never sees row 999."
-    )
-    assert top["text"] == "needle in the haystack"
-    assert top["base_similarity"] > 0.9
-    assert top["source"] == "vector"
-
-
-# ---------------------------------------------------------------------------
-# 3. Backfill is idempotent — second run on a populated vec_index is no-op.
-# ---------------------------------------------------------------------------
-
-
-@_skip_no_sqlite_vec
-def test_backfill_idempotent(qmd_db, proxy_module) -> None:
-    """Seed chunks with JSON embeddings only (no vec_index rows),
-    call ``_backfill_vec_index`` twice, assert:
-      1. First call copies all rows into vec_index.
-      2. Second call observes vec_n >= chunks_n and is a no-op (no
-         duplicate inserts, no errors).
-
-    Catches the failure mode where a missing idempotency check would
-    INSERT duplicate ids on the second invocation, blow up the UNIQUE
-    constraint, and corrupt the index."""
-    import asyncio
-    conn = proxy_module._open_qmd_conn()
-    proxy_module._ensure_vec_index(conn)
-    conn.execute(
-        """
-        CREATE TABLE IF NOT EXISTS chunks (
-            id INTEGER PRIMARY KEY,
-            path TEXT,
-            text TEXT,
-            embedding TEXT,
-            embedding_model TEXT,
-            embedding_dim INTEGER,
-            chunk_index INTEGER,
-            created_at TEXT
-        )
-        """
-    )
-    dim = proxy_module.EMBED_DIM
-    N = 7
-    for i in range(N):
-        v = _make_vec(seed=i + 100, dim=dim)
-        conn.execute(
-            "INSERT INTO chunks(id, path, text, embedding) VALUES (?, ?, ?, ?)",
-            (i + 1, f"p/{i}.md", f"t{i}", json.dumps(v)),
-        )
-    conn.commit()
-    pre_chunks = conn.execute("SELECT count(*) FROM chunks").fetchone()[0]
-    pre_vec = conn.execute("SELECT count(*) FROM vec_index").fetchone()[0]
-    conn.close()
-    assert pre_chunks == N and pre_vec == 0, (
-        f"setup mismatch: chunks={pre_chunks}, vec={pre_vec}"
-    )
-
-    # First run — should copy all N rows.
-    asyncio.run(proxy_module._backfill_vec_index())
-    conn = proxy_module._open_qmd_conn()
-    mid_vec = conn.execute("SELECT count(*) FROM vec_index").fetchone()[0]
-    conn.close()
-    assert mid_vec == N, f"first backfill should copy all {N} rows, got {mid_vec}"
-
-    # Second run — must no-op cleanly. No exception, no duplicate inserts.
-    asyncio.run(proxy_module._backfill_vec_index())
-    conn = proxy_module._open_qmd_conn()
-    final_vec = conn.execute("SELECT count(*) FROM vec_index").fetchone()[0]
-    conn.close()
-    assert final_vec == N, (
-        f"second backfill should be no-op; got {final_vec} rows instead of {N}"
-    )

package/packages/memory-engine/tests/test_l3_arena_isolation.py

@@ -1,412 +0,0 @@
-"""Integration tests for L3 arena isolation + typed-entity writes.
-
-Two flavours:
-
-  - Neo4j-backed integration tests (run when ``NEO4J_TEST_URI`` and
-    ``NEO4J_TEST_PASSWORD`` env vars are set). These spin up the actual
-    writer logic and verify cross-arena isolation against a live
-    Neo4j. Skip cleanly when env is absent so the unit-test job stays
-    Neo4j-free.
-
-  - Pure-unit tests using a stub session that records every Cypher
-    call. Fast, hermetic, validate the structural invariants we care
-    about: each typed-entity write carries arena, COMMUNICATED edges
-    carry channel + direction, etc.
-
-Run:
-
-    cd packages/memory-engine
-    .venv/bin/python -m pytest tests/test_l3_arena_isolation.py -v
-
-Run with Neo4j:
-
-    NEO4J_TEST_URI=bolt://localhost:7687 \\
-    NEO4J_TEST_PASSWORD=test \\
-    .venv/bin/python -m pytest tests/test_l3_arena_isolation.py -v
-"""
-from __future__ import annotations
-
-import os
-import sys
-import uuid
-from pathlib import Path
-
-import pytest
-
-
-# Make the engine module importable without packaging it.
-ENGINE_ROOT = Path(__file__).resolve().parent.parent / "engine" / "services" / "l2"
-sys.path.insert(0, str(ENGINE_ROOT))
-
-
-# ---------------------------------------------------------------------------
-# Stub session for unit tests — records calls without hitting Neo4j.
-# ---------------------------------------------------------------------------
-
-
-class _Recorder:
-    """Stand-in for a Neo4j session.run that records every call.
-
-    Just enough surface for the writer block in the engine to think it's
-    talking to Neo4j: ``run(cypher, **params)`` returns an object whose
-    ``single()`` / iteration / ``data()`` calls all return empty.
-    """
-
-    def __init__(self) -> None:
-        self.calls: list[tuple[str, dict]] = []
-
-    def run(self, cypher: str, **params) -> "_Recorder":
-        self.calls.append((cypher, params))
-        return self
-
-    def single(self) -> dict:
-        return {}
-
-    def __iter__(self):
-        return iter([])
-
-
-def _has_arena_in_pattern(cypher: str, label: str, var: str = "") -> bool:
-    """True if every occurrence of (…label…) in the cypher names arena.
-
-    Parses each node pattern as ``(var:Label1:Label2:… {props})``,
-    finds the ones whose label list contains the target ``label``, and
-    asserts each one is arena-scoped (either via ``arena:`` in the
-    property bag or via ``<var>.arena`` somewhere in the same block).
-
-    Parameters
-    ----------
-    cypher : the Cypher block to inspect.
-    label  : target label (e.g. ``"Entity"``, ``"Chunk"``).
-    var    : optional variable filter — when set, only patterns that
-             bind this variable are checked. Useful when a block has
-             multiple patterns of the same label and we want to assert
-             one specific one.
-    """
-    import re
-
-    pattern = re.compile(
-        r"\("
-        r"\s*(?P<v>[A-Za-z_]\w*)?"
-        r"\s*(?P<labels>(?::[A-Za-z_]\w*)+)"  # one or more labels
-        r"\s*(?P<props>\{[^{}]*\})?"
-        r"\s*\)",
-        re.MULTILINE,
-    )
-    target = f":{label}"
-    found_any = False
-    for m in pattern.finditer(cypher):
-        labels = m.group("labels") or ""
-        # Require an exact-label match so :Entity matches `:Entity` and
-        # `:Entity:Concept` but not `:Entitlement` (re.search alone
-        # would treat the latter as a hit).
-        label_tokens = re.findall(r":([A-Za-z_]\w*)", labels)
-        if label not in label_tokens:
-            continue
-        v = m.group("v") or ""
-        if var and v != var:
-            continue
-        found_any = True
-        props = m.group("props") or ""
-        if "arena" in props:
-            continue
-        if v and re.search(rf"\b{re.escape(v)}\.arena\b", cypher):
-            continue
-        return False
-    return found_any
-
-
-# ---------------------------------------------------------------------------
-# Unit tests — exercise the writer block via the stub session by
-# calling its Cypher directly.
-# ---------------------------------------------------------------------------
-
-
-def test_writer_concept_path_carries_arena() -> None:
-    """The Concept-extraction Cypher always names arena on Entity + Chunk."""
-    rec = _Recorder()
-    arena = "acme"
-    rec.run(
-        """
-        MERGE (e:Entity:Concept {arena: $arena, name: $name})
-        ON CREATE SET e.type = 'Concept',
-                      e.created_at = $now,
-                      e.weight = 1.0
-        WITH e
-        MATCH (c:Chunk {arena: $arena, id: $cid})
-        MERGE (e)-[r:MENTIONS]->(c)
-        ON CREATE SET r.weight = 1.0, r.created_at = $now
-        ON MATCH SET r.weight = coalesce(r.weight, 1.0) + 0.1
-        """,
-        arena=arena, name="Pricing", cid="chunk-1", now="t",
-    )
-    cypher, params = rec.calls[-1]
-    assert _has_arena_in_pattern(cypher, "Entity")
-    assert _has_arena_in_pattern(cypher, "Chunk")
-    assert params["arena"] == arena
-
-
-def test_writer_person_email_carries_arena_email_and_communicated_edge() -> None:
-    """Metadata-driven Person email path tags arena + builds COMMUNICATED edge."""
-    rec = _Recorder()
-    arena = "acme"
-    rec.run(
-        """
-        MERGE (p:Entity:Person {arena: $arena, email: $email})
-        ON CREATE SET p.created_at = $now,
-                      p.first_seen = $occurred_at,
-                      p.last_seen = $occurred_at
-        ON MATCH SET p.last_seen = CASE
-              WHEN $occurred_at > coalesce(p.last_seen, '')
-                THEN $occurred_at
-              ELSE p.last_seen END
-        WITH p
-        MATCH (c:Chunk {arena: $arena, id: $cid})
-        MERGE (p)-[r:COMMUNICATED]->(c)
-        ON CREATE SET r.channel = $channel,
-                      r.direction = $direction,
-                      r.occurred_at = $occurred_at,
-                      r.weight = 1.0
-        """,
-        arena=arena, email="alex@acme.com", cid="c-1",
-        channel="email", direction="inbound",
-        occurred_at="2026-05-08T00:00:00Z", now="t",
-    )
-    cypher, params = rec.calls[-1]
-    assert _has_arena_in_pattern(cypher, "Person")
-    assert _has_arena_in_pattern(cypher, "Chunk")
-    assert "COMMUNICATED" in cypher
-    assert params["channel"] == "email"
-    assert params["direction"] == "inbound"
-
-
-def test_co_occurs_edges_are_arena_scoped_on_both_endpoints() -> None:
-    """CO_OCCURS Cypher matches both endpoints in the same arena."""
-    rec = _Recorder()
-    rec.run(
-        """
-        MATCH (a:Entity:Concept {arena: $arena, name: $a})
-        MATCH (b:Entity:Concept {arena: $arena, name: $b})
-        MERGE (a)-[r:CO_OCCURS]->(b)
-        ON CREATE SET r.weight = 0.5, r.created_at = $now
-        ON MATCH SET r.weight = coalesce(r.weight, 0.5) + 0.05
-        """,
-        arena="acme", a="Pricing", b="Negotiation", now="t",
-    )
-    cypher, _ = rec.calls[-1]
-    # Both endpoints carry arena in the property bag.
-    assert cypher.count("arena: $arena") == 2
-
-
-def test_known_as_edge_links_email_and_name_within_arena() -> None:
-    """KNOWN_AS edge connects the (arena, name) and (arena, email) Person nodes."""
-    rec = _Recorder()
-    rec.run(
-        """
-        MATCH (n:Person {arena: $arena, name: $name})
-        MATCH (e:Person {arena: $arena, email: $email})
-        MERGE (n)-[:KNOWN_AS]->(e)
-        """,
-        arena="acme", name="Alex Tong", email="alex@acme.com",
-    )
-    cypher, _ = rec.calls[-1]
-    assert _has_arena_in_pattern(cypher, "Person")
-    assert "KNOWN_AS" in cypher
-
-
-# ---------------------------------------------------------------------------
-# Self-test: the helper above flags the bug the lint missed in v1.
-# ---------------------------------------------------------------------------
-
-
-def test_helper_flags_unscoped_person_pattern() -> None:
-    bad_cypher = """
-        MERGE (p:Entity:Person {email: $email})
-        ON CREATE SET p.created_at = $now
-        MATCH (c:Chunk {arena: $arena, id: $cid})
-        MERGE (p)-[:MENTIONS]->(c)
-    """
-    assert not _has_arena_in_pattern(bad_cypher, "Person"), \
-        "helper must flag the unscoped Person pattern"
-    assert _has_arena_in_pattern(bad_cypher, "Chunk"), \
-        "Chunk pattern with arena in property bag should pass"
-
-
-# ---------------------------------------------------------------------------
-# Neo4j-backed integration tests — only run when env is set.
-# ---------------------------------------------------------------------------
-
-
-_NEO4J_URI = os.environ.get("NEO4J_TEST_URI")
-_NEO4J_USER = os.environ.get("NEO4J_TEST_USER", "neo4j")
-_NEO4J_PASSWORD = os.environ.get("NEO4J_TEST_PASSWORD")
-
-_skip_no_neo4j = pytest.mark.skipif(
-    not (_NEO4J_URI and _NEO4J_PASSWORD),
-    reason="set NEO4J_TEST_URI + NEO4J_TEST_PASSWORD to run integration tests",
-)
-
-
-@pytest.fixture
-def neo4j_driver():
-    """Open a Neo4j driver and clean test data on teardown.
-
-    Uses a randomised arena pair so concurrent test runs don't trample
-    each other; tears down by deleting nodes scoped to those arenas
-    (never a global wipe — this fixture must be safe against a
-    populated dev database).
-    """
-    from neo4j import GraphDatabase  # local import keeps unit-only runs neo4j-free
-
-    driver = GraphDatabase.driver(_NEO4J_URI, auth=(_NEO4J_USER, _NEO4J_PASSWORD))
-    arenas = [f"test_a_{uuid.uuid4().hex[:8]}", f"test_b_{uuid.uuid4().hex[:8]}"]
-    yield driver, arenas
-    with driver.session() as session:
-        for arena in arenas:
-            session.run(
-                "MATCH (n) WHERE n.arena = $arena DETACH DELETE n",
-                arena=arena,
-            )
-    driver.close()
-
-
-@_skip_no_neo4j
-def test_two_arenas_get_distinct_person_nodes_for_same_email(neo4j_driver) -> None:
-    """Same contact_email in two arenas → two :Person nodes, not one."""
-    driver, (arena_a, arena_b) = neo4j_driver
-    email = "shared@example.com"
-    chunk_id = lambda a: f"c_{a}"
-
-    with driver.session() as session:
-        for arena in (arena_a, arena_b):
-            # Materialise the chunk that the Person attaches to.
-            session.run(
-                """
-                MERGE (c:Chunk {id: $cid})
-                SET c.arena = $arena, c.text = 'test', c.path = 'test',
-                    c.created_at = '2026-05-08T00:00:00Z'
-                """,
-                cid=chunk_id(arena), arena=arena,
-            )
-            # Apply the same writer block as the engine would.
-            session.run(
-                """
-                MERGE (p:Entity:Person {arena: $arena, email: $email})
-                ON CREATE SET p.created_at = $now,
-                              p.first_seen = $occurred_at,
-                              p.last_seen = $occurred_at
-                WITH p
-                MATCH (c:Chunk {arena: $arena, id: $cid})
-                MERGE (p)-[r:COMMUNICATED]->(c)
-                ON CREATE SET r.channel = $channel,
-                              r.direction = $direction,
-                              r.occurred_at = $occurred_at,
-                              r.weight = 1.0
-                """,
-                arena=arena, email=email, cid=chunk_id(arena),
-                channel="email", direction="inbound",
-                occurred_at="2026-05-08T00:00:00Z", now="2026-05-08T00:00:00Z",
-            )
-
-        # Assert two distinct nodes, one per arena, both with the same email.
-        result = session.run(
-            "MATCH (p:Person) WHERE p.email = $email RETURN p.arena AS arena",
-            email=email,
-        )
-        seen = sorted(rec["arena"] for rec in result if rec["arena"] in (arena_a, arena_b))
-        assert seen == sorted([arena_a, arena_b]), (
-            f"expected exactly one Person per arena for the same email, got {seen!r}"
-        )
-
-
-@_skip_no_neo4j
-def test_arena_scoped_search_does_not_traverse_other_arena(neo4j_driver) -> None:
-    """A graph search scoped to arena_a can't return arena_b nodes."""
-    driver, (arena_a, arena_b) = neo4j_driver
-    name = "Shared Concept"
-
-    with driver.session() as session:
-        for arena in (arena_a, arena_b):
-            session.run(
-                """
-                MERGE (c:Chunk {id: $cid})
-                SET c.arena = $arena, c.text = 't', c.path = 'p',
-                    c.created_at = '2026-05-08T00:00:00Z'
-                MERGE (e:Entity:Concept {arena: $arena, name: $name})
-                ON CREATE SET e.weight = 1.0, e.created_at = '2026-05-08T00:00:00Z'
-                MERGE (e)-[:MENTIONS]->(c)
-                """,
-                cid=f"c_{arena}", arena=arena, name=name,
-            )
-
-        # Arena-scoped lookup as the engine search now does it.
-        result = session.run(
-            """
-            MATCH (n:Entity {name: $name, arena: $arena})
-            RETURN n.arena AS arena, n.name AS name
-            """,
-            name=name, arena=arena_a,
-        )
-        rows = list(result)
-        assert len(rows) == 1
-        assert rows[0]["arena"] == arena_a, (
-            f"arena-scoped match returned wrong arena: {rows[0]['arena']!r}"
-        )
-
-        # And the unscoped query (intentionally cross-tenant) still
-        # finds two — proves the data is there, isolation is real.
-        result = session.run(
-            "MATCH (n:Entity {name: $name}) RETURN n.arena AS arena", name=name,
-        )
-        all_rows = sorted(
-            r["arena"] for r in result if r["arena"] in (arena_a, arena_b)
-        )
-        assert all_rows == sorted([arena_a, arena_b])
-
-
-@_skip_no_neo4j
-def test_forget_arena_b_leaves_arena_a_intact(neo4j_driver) -> None:
-    """Tenant-scoped delete on arena_b doesn't affect arena_a."""
-    driver, (arena_a, arena_b) = neo4j_driver
-
-    with driver.session() as session:
-        for arena in (arena_a, arena_b):
-            session.run(
-                """
-                MERGE (c:Chunk {id: $cid})
-                SET c.arena = $arena, c.text = 't', c.path = 'p',
-                    c.created_at = '2026-05-08T00:00:00Z'
-                MERGE (e:Entity:Concept {arena: $arena, name: 'thing'})
-                ON CREATE SET e.weight = 1.0, e.created_at = '2026-05-08T00:00:00Z'
-                MERGE (e)-[:MENTIONS]->(c)
-                """,
-                cid=f"c_{arena}", arena=arena,
-            )
-
-        # Tenant-scoped delete: same shape as forget-internal.
-        session.run(
-            "MATCH (c:Chunk {arena: $arena}) DETACH DELETE c", arena=arena_b,
-        )
-        session.run(
-            "MATCH (e:Entity {arena: $arena}) DETACH DELETE e", arena=arena_b,
-        )
-
-        # arena_a still intact.
-        a_chunks = session.run(
-            "MATCH (c:Chunk {arena: $arena}) RETURN count(c) AS n", arena=arena_a,
-        ).single()["n"]
-        a_entities = session.run(
-            "MATCH (e:Entity {arena: $arena}) RETURN count(e) AS n", arena=arena_a,
-        ).single()["n"]
-        assert a_chunks >= 1
-        assert a_entities >= 1
-
-        # arena_b gone.
-        b_chunks = session.run(
-            "MATCH (c:Chunk {arena: $arena}) RETURN count(c) AS n", arena=arena_b,
-        ).single()["n"]
-        b_entities = session.run(
-            "MATCH (e:Entity {arena: $arena}) RETURN count(e) AS n", arena=arena_b,
-        ).single()["n"]
-        assert b_chunks == 0
-        assert b_entities == 0