matrx-orm 3.1.63__tar.gz → 3.1.64__tar.gz

{matrx_orm-3.1.63 → matrx_orm-3.1.64}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: matrx-orm
-Version: 3.1.63
+Version: 3.1.64
 Summary: Async-first PostgreSQL ORM with bidirectional migrations, schema introspection, many-to-many relationships, and built-in state caching
 Project-URL: Homepage, https://github.com/AI-Matrix-Engine/aidream-current
 Project-URL: Repository, https://github.com/AI-Matrix-Engine/aidream-current

{matrx_orm-3.1.63 → matrx_orm-3.1.64}/matrx_orm/admin/router.py

@@ -57,43 +57,21 @@ _COMPOSITE_ROW_ID_PREFIX = "cmp1_"
 
 
 def _model_by_table(table_name: str, schema: str | None = None) -> type | None:
-    matches = [
-        model
-        for model in model_registry.all_models().values()
-        if model._meta.table_name == table_name
-    ]
-    if not matches:
-        return None
-    if schema:
-        for model in matches:
-            if _model_schema(model) == schema:
-                return model
-        return None
-    if len(matches) == 1:
-        return matches[0]
-    for model in matches:
-        if _model_schema(model) == "public":
-            return model
-    return matches[0]
+    return model_registry.get_model_by_table(schema or "public", table_name)
 
 
 def _require_model(table_name: str, schema: str | None = None) -> type:
     model = _model_by_table(table_name, schema)
     if model is None:
-        if schema:
-            log.warning(
-                "Table '%s.%s' not found in model registry",
-                schema,
-                table_name,
-            )
-            raise HTTPException(
-                status_code=404,
-                detail=f"Table '{schema}.{table_name}' not found in model registry",
-            )
-        log.warning("Table '%s' not found in model registry", table_name)
+        effective_schema = schema or "public"
+        log.warning(
+            "Table '%s.%s' not found in model registry",
+            effective_schema,
+            table_name,
+        )
         raise HTTPException(
             status_code=404,
-            detail=f"Table '{table_name}' not found in model registry",
+            detail=f"Table '{effective_schema}.{table_name}' not found in model registry",
         )
     return model
 
@@ -176,7 +154,7 @@ def _safe_scalar(value: Any) -> str | int | float | bool | None:
     """Return value only if it is a JSON-safe scalar; drop everything else."""
     if value is None or callable(value):
         return None
-    if isinstance(value, (str, int, float, bool)):
+    if isinstance(value, str | int | float | bool):
         return value
     return None
 

{matrx_orm-3.1.63 → matrx_orm-3.1.64}/matrx_orm/catalog.py

@@ -23,7 +23,7 @@ __all__ = [
     "relation_privileges",
     "role_service_state",
     "softdelete_unique_conflicts",
-    "table_schema_map",
+    "qualified_relation_names",
     "trigger_function_usage",
     "column_privileges",
     "entity_capability_state",
@@ -258,17 +258,17 @@ async def entity_capability_state(database: str) -> list[dict[str, Any]]:
     )
 
 
-async def table_schema_map(database: str) -> dict[str, list[str]]:
-    """Return every table/view name mapped to its distinct schemas."""
+async def qualified_relation_names(database: str) -> set[str]:
+    """Return every table/view as an exact ``schema.table`` identity."""
     rows = await _query(
         database,
         """
-        SELECT table_name, array_agg(DISTINCT table_schema ORDER BY table_schema) AS schemas
+        SELECT DISTINCT table_schema, table_name
         FROM information_schema.tables
-        GROUP BY table_name
+        ORDER BY table_schema, table_name
         """,
     )
-    return {str(row["table_name"]): list(row["schemas"] or []) for row in rows}
+    return {f'{row["table_schema"]}.{row["table_name"]}' for row in rows}
 
 
 async def first_party_function_bodies(

{matrx_orm-3.1.63 → matrx_orm-3.1.64}/matrx_orm/core/FEATURE.md

@@ -45,5 +45,6 @@ Verified against code: 2026-08-13.
 
 ## Change log
 
+- 2026-08-13: Registry, admin, recovery, catalog, and diagnostic identities are now exact `schema.table`; bare names are accepted only as uncached discovery terms and ambiguity fails loudly.
 - 2026-08-13: Added atomic recovery from a pool left at zero connections after an upstream database restart.
 - 2026-08-09: Pinned positional-mapping hydration for parameter-shaped column names.

{matrx_orm-3.1.63 → matrx_orm-3.1.64}/matrx_orm/core/introspection.py

@@ -80,7 +80,7 @@ WHERE table_schema = $1
 
 
 async def introspect_columns(database: str, schema: str, tables: list[str]) -> dict[str, list[str]]:
-    """Live column names per table for ``schema`` — ``{table: [column, ...]}``.
+    """Live columns keyed by exact identity — ``{schema.table: [column, ...]}``.
 
     The catalog question "what columns does this table actually have right
     now?" belongs to the ORM: it is a fact about Postgres, not a row in an
@@ -96,7 +96,7 @@ async def introspect_columns(database: str, schema: str, tables: list[str]) -> d
     rows = await AsyncDatabaseManager.execute_query(database, _COLUMNS_SQL, schema, tables)
     out: dict[str, list[str]] = {}
     for r in rows:
-        out.setdefault(r["table_name"], []).append(r["column_name"])
+        out.setdefault(f'{schema}.{r["table_name"]}', []).append(r["column_name"])
     return out
 
 

{matrx_orm-3.1.63 → matrx_orm-3.1.64}/matrx_orm/operations/staging_load.py

@@ -355,7 +355,7 @@ async def approx_row_counts(
     """``pg_class.reltuples`` approximate row counts for a set of tables in
     one schema — the cheap "how much data is loaded" read (exact ``COUNT(*)``
     is too slow on large bulk-load tables; autovacuum keeps ``reltuples``
-    warm). Returns ``{table_name: approx_rows}``; a table with no matching
+    warm). Returns ``{schema.table: approx_rows}``; a table with no matching
     ``pg_class`` row (not created yet) is simply absent from the result."""
     _ident(schema, what="schema")
     for t in table_names:
@@ -370,7 +370,7 @@ async def approx_row_counts(
     rows = await _fetch(
         config_name, sql, schema, list(set(table_names)), connection=connection, pool=pool
     )
-    return {r["table_name"]: max(0, int(r["approx_rows"])) for r in rows}
+    return {f'{schema}.{r["table_name"]}': max(0, int(r["approx_rows"])) for r in rows}
 
 
 async def copy_records(

{matrx_orm-3.1.63 → matrx_orm-3.1.64}/matrx_orm/session/README.md

@@ -192,7 +192,9 @@ When `Session.flush()` raises, every dropped op is captured to
 `public.system_write_failure` on a fresh asyncpg connection (bypasses
 the failed transaction's pool slot). The recovery tool
 (`scripts/replay_write_failures.py` in aidream) can replay them
-later. Same schema as Phase 1 — no migration change.
+later. `table_target` is always the exact `schema.table`; a model without both
+identity parts is rejected before capture. Replay never guesses a schema from a
+bare name.
 
 If the fallback ALSO fails, a red banner prints every op to stdout and
 the structured logger captures them with full payload.

{matrx_orm-3.1.63 → matrx_orm-3.1.64}/matrx_orm/session/lifecycle.py

@@ -526,7 +526,7 @@ async def sweep_once(
     database: str | None = None,
     limit: int = SWEEP_LIMIT_DEFAULT,
 ) -> dict[str, int]:
-    """One pass over every registered config. Returns ``{table: stuck_count}``."""
+    """One pass over every registered config. Returns ``{schema.table: stuck_count}``."""
     out: dict[str, int] = {}
     now = datetime.now(UTC)
 
@@ -541,11 +541,11 @@ async def sweep_once(
             # logger.error (NOT .exception): the in-package asyncpg traceback is
             # noise — the banner already carries the clean reason + origin.
             logger.error("watchdog_select_failed", extra=structured)
-            out[cfg.table] = 0
+            out[f"{cfg.schema}.{cfg.table}"] = 0
             continue
 
         stuck_count = len(rows)
-        out[cfg.table] = stuck_count
+        out[f"{cfg.schema}.{cfg.table}"] = stuck_count
         if stuck_count == 0:
             continue
 

{matrx_orm-3.1.63 → matrx_orm-3.1.64}/matrx_orm/session/managed.py

@@ -164,30 +164,35 @@ _WRITE_TARGET_RE = re.compile(
 )
 
 
-def _register_strict_table(model_cls: type) -> None:
-    """Record a strict-managed Model's table name(s) for the execute_write guard."""
+def _canonical_table_key(value: str) -> str:
+    """Return an exact ``schema.table`` key for a model or SQL target."""
+    parts = [part.strip().strip('"') for part in value.strip().split(".")]
+    if len(parts) == 2 and all(parts):
+        return f"{parts[0]}.{parts[1]}"
+    raise ValueError(f"invalid table target {value!r}; expected schema.table")
+
+
+def _model_table_key(model_cls: type) -> str | None:
     meta = getattr(model_cls, "_meta", None)
     if meta is None:
-        return
-    qualified = getattr(meta, "qualified_table_name", None)
-    bare = getattr(meta, "table_name", None)
-    for name in (qualified, bare):
-        if name:
-            _STRICT_TABLES.add(str(name).strip('"'))
+        return None
+    table = getattr(meta, "table_name", None)
+    if not table:
+        return None
+    schema = getattr(meta, "db_schema", None) or "public"
+    return _canonical_table_key(f"{schema}.{table}")
+
+
+def _register_strict_table(model_cls: type) -> None:
+    """Record a strict-managed Model under its exact ``schema.table`` key."""
+    if key := _model_table_key(model_cls):
+        _STRICT_TABLES.add(key)
 
 
 def _register_coordinator_table(model_cls: type, required_scope: str) -> None:
-    meta = getattr(model_cls, "_meta", None)
-    if meta is None:
-        return
-    for name in (
-        getattr(meta, "qualified_table_name", None),
-        getattr(meta, "table_name", None),
-    ):
-        if name:
-            normalized = str(name).strip('"')
-            _COORDINATOR_TABLES[normalized] = required_scope
-            _STRICT_TABLES.discard(normalized)
+    if key := _model_table_key(model_cls):
+        _COORDINATOR_TABLES[key] = required_scope
+        _STRICT_TABLES.discard(key)
 
 
 def register_coordinator_owned_model(entry: Any) -> None:
@@ -202,16 +207,8 @@ def coordinator_policy_tables() -> dict[str, str]:
 
 
 def _coordinator_scope_for_model(model_cls: type) -> str | None:
-    meta = getattr(model_cls, "_meta", None)
-    if meta is None:
-        return None
-    for name in (
-        getattr(meta, "qualified_table_name", None),
-        getattr(meta, "table_name", None),
-    ):
-        if name and (scope := _COORDINATOR_TABLES.get(str(name).strip('"'))):
-            return scope
-    return None
+    key = _model_table_key(model_cls)
+    return _COORDINATOR_TABLES.get(key) if key else None
 
 
 def assert_model_write_allowed(
@@ -274,12 +271,21 @@ def assert_managed_write_allowed(query: str) -> None:
     m = _WRITE_TARGET_RE.match(query)
     if not m:
         return
-    token = m.group(1).strip().strip('"')
-    bare_token = token.split(".")[-1].strip('"')
+    raw_target = m.group(1)
+    try:
+        token = _canonical_table_key(raw_target)
+    except ValueError as exc:
+        message = (
+            f"Bare write target {raw_target!r} refused at the managed-write chokepoint; "
+            "write SQL must name schema.table so guards cannot bind the wrong relation"
+        )
+        vcprint(message, color="red")
+        logger.error(message)
+        raise ManagedWriteViolation(raw_target, "write SQL without schema.table") from exc
 
-    required_scope = _COORDINATOR_TABLES.get(token) or _COORDINATOR_TABLES.get(bare_token)
+    required_scope = _COORDINATOR_TABLES.get(token)
     if required_scope is not None:
-        model_cls = _model_for_coordinator_table(token, bare_token)
+        model_cls = _model_for_coordinator_table(token)
         if model_cls is not None:
             assert_model_write_allowed(model_cls, "write")
         else:
@@ -300,7 +306,7 @@ def assert_managed_write_allowed(query: str) -> None:
     except ImportError:
         pass
 
-    if token in _STRICT_TABLES or token.split(".")[-1].strip('"') in _STRICT_TABLES:
+    if token in _STRICT_TABLES:
         banner = _format_chokepoint_banner(token)
         vcprint(banner, color="red")
         logger.error(
@@ -318,24 +324,10 @@ def _active_write_scope() -> str | None:
     return None
 
 
-def _model_for_coordinator_table(token: str, bare_token: str) -> type | None:
+def _model_for_coordinator_table(token: str) -> type | None:
     from matrx_orm.core.registry import ModelRegistry
-
-    for model_cls in ModelRegistry.all_models().values():
-        meta = getattr(model_cls, "_meta", None)
-        if meta is None:
-            continue
-        names = {
-            str(name).strip('"')
-            for name in (
-                getattr(meta, "qualified_table_name", None),
-                getattr(meta, "table_name", None),
-            )
-            if name
-        }
-        if token in names or bare_token in names:
-            return model_cls
-    return None
+    schema, table = token.split(".", 1)
+    return ModelRegistry.get_model_by_table(schema, table)
 
 
 def is_strict_table(model_cls: type) -> bool:
@@ -346,16 +338,8 @@ def is_strict_table(model_cls: type) -> bool:
     """
     if not _STRICT_TABLES:
         return False
-    meta = getattr(model_cls, "_meta", None)
-    if meta is None:
-        return False
-    for name in (
-        getattr(meta, "qualified_table_name", None),
-        getattr(meta, "table_name", None),
-    ):
-        if name and str(name).strip('"') in _STRICT_TABLES:
-            return True
-    return False
+    key = _model_table_key(model_cls)
+    return key in _STRICT_TABLES if key else False
 
 
 @asynccontextmanager

{matrx_orm-3.1.63 → matrx_orm-3.1.64}/matrx_orm/session/op.py

@@ -103,20 +103,23 @@ class SessionOp:
 
     @property
     def table(self) -> str:
-        """Convenience accessor for telemetry / logging. Reads the Model's
-        configured table name, falling back to the class name."""
+        """Exact ``schema.table`` identity for telemetry and durable replay."""
         meta = getattr(self.model_cls, "_meta", None)
         if meta is not None:
-            return getattr(meta, "table_name", None) or self.model_cls.__name__
-        return self.model_cls.__name__
+            table = getattr(meta, "table_name", None)
+            if table:
+                schema = getattr(meta, "db_schema", None) or "public"
+                return f"{schema}.{table}"
+        raise ValueError(
+            f"SessionOp model {self.model_cls.__name__} has no canonical schema.table identity"
+        )
 
     def to_record(self) -> dict[str, Any]:
         """Serialize for the fallback writer.
 
         Returns a dict that the fallback can write into system_write_failure
-        without any further introspection. The ``table_target`` field uses
-        the table name (string) because the fallback is schema-agnostic and
-        recovery tools may not have the Model class available.
+        without any further introspection. ``table_target`` is always the exact
+        ``schema.table`` key so replay cannot bind a same-named table elsewhere.
         """
         return {
             "op_id": self.op_id,

{matrx_orm-3.1.63 → matrx_orm-3.1.64}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "matrx-orm"
-version = "3.1.63"
+version = "3.1.64"
 description = "Async-first PostgreSQL ORM with bidirectional migrations, schema introspection, many-to-many relationships, and built-in state caching"
 readme = "README.md"
 license = { text = "MIT" }

{matrx_orm-3.1.63 → matrx_orm-3.1.64}/tests/level1/test_admin_db_columns.py

@@ -9,6 +9,7 @@ from matrx_orm.admin.router import (
     _admin_column_descriptors,
     _db_row_to_descriptor,
     _decode_row_id,
+    _model_by_table,
     _serialize,
 )
 
@@ -27,6 +28,25 @@ def test_serialize_includes_extra_data() -> None:
     assert out["role"] == "authenticated"
 
 
+def test_admin_model_lookup_defaults_to_exact_public_key() -> None:
+    sentinel = object()
+    with patch(
+        "matrx_orm.admin.router.model_registry.get_model_by_table",
+        return_value=sentinel,
+    ) as lookup:
+        assert _model_by_table("definition") is sentinel
+    lookup.assert_called_once_with("public", "definition")
+
+
+def test_admin_model_lookup_uses_requested_schema() -> None:
+    with patch(
+        "matrx_orm.admin.router.model_registry.get_model_by_table",
+        return_value=None,
+    ) as lookup:
+        assert _model_by_table("definition", "agent") is None
+    lookup.assert_called_once_with("agent", "definition")
+
+
 def test_composite_row_identity_round_trips() -> None:
     meta = SimpleNamespace(
         fields={"site_id": object(), "page_id": object()},

{matrx_orm-3.1.63 → matrx_orm-3.1.64}/tests/level1/test_catalog.py

@@ -106,17 +106,19 @@ async def test_function_access_zips_requested_functions(query_spy):
 
 
 @pytest.mark.asyncio
-async def test_table_schema_map_normalizes_rows(monkeypatch):
+async def test_qualified_relation_names_normalizes_rows(monkeypatch):
     async def execute_query(database, sql, *params):
         return [
-            {"table_name": "notes", "schemas": ["public", "workbench"]},
-            {"table_name": "files", "schemas": ["files"]},
+            {"table_schema": "public", "table_name": "notes"},
+            {"table_schema": "workbench", "table_name": "notes"},
+            {"table_schema": "files", "table_name": "files"},
         ]
 
     monkeypatch.setattr(catalog.AsyncDatabaseManager, "execute_query", execute_query)
-    assert await catalog.table_schema_map("main") == {
-        "notes": ["public", "workbench"],
-        "files": ["files"],
+    assert await catalog.qualified_relation_names("main") == {
+        "public.notes",
+        "workbench.notes",
+        "files.files",
     }
 
 

{matrx_orm-3.1.63 → matrx_orm-3.1.64}/tests/level1/test_insert_ignore_and_admin_primitives.py

@@ -339,7 +339,7 @@ async def test_approx_row_counts_shape() -> None:
     out = await staging_load.approx_row_counts(
         "db", schema="legal", table_names=["courts", "dockets"], connection=conn
     )
-    assert out == {"courts": 1234}
+    assert out == {"legal.courts": 1234}
     _kind, sql, params = conn.calls[0]
     assert "pg_class" in sql and "pg_namespace" in sql
     assert params[0] == "legal"

{matrx_orm-3.1.63 → matrx_orm-3.1.64}/tests/level1/test_introspect_rls_policies.py

@@ -16,7 +16,7 @@ from __future__ import annotations
 from unittest.mock import AsyncMock
 
 import pytest
-from matrx_orm import introspect_rls_policies
+from matrx_orm import introspect_columns, introspect_rls_policies
 
 pytestmark = pytest.mark.asyncio
 
@@ -77,3 +77,19 @@ async def test_empty_input_short_circuits_without_a_query(monkeypatch) -> None:
 async def test_mismatched_array_lengths_raise() -> None:
     with pytest.raises(ValueError, match="same length"):
         await introspect_rls_policies("db", ["public", "workspace"], ["notes"])
+
+
+async def test_introspect_columns_returns_qualified_keys(monkeypatch) -> None:
+    mock_execute = AsyncMock(
+        return_value=[
+            {"table_name": "definition", "column_name": "id"},
+            {"table_name": "definition", "column_name": "name"},
+        ]
+    )
+    monkeypatch.setattr(
+        "matrx_orm.core.introspection.AsyncDatabaseManager.execute_query", mock_execute
+    )
+
+    assert await introspect_columns("db", "workflow", ["definition"]) == {
+        "workflow.definition": ["id", "name"]
+    }

{matrx_orm-3.1.63 → matrx_orm-3.1.64}/tests/level1/test_managed_write_guard.py

@@ -58,27 +58,41 @@ class TestStrictGuard:
         M.assert_managed_write_allowed("UPDATE cx_message SET x=1")  # no raise
 
     def test_ungoverned_write_to_strict_table_raises(self):
-        M._STRICT_TABLES.add("cx_message")
+        M._STRICT_TABLES.add("public.cx_message")
         with pytest.raises(ManagedWriteViolation):
-            M.assert_managed_write_allowed("UPDATE cx_message SET x=1 WHERE id=$1")
+            M.assert_managed_write_allowed("UPDATE public.cx_message SET x=1 WHERE id=$1")
 
-    def test_non_strict_table_passes(self):
-        M._STRICT_TABLES.add("cx_message")
-        M.assert_managed_write_allowed("UPDATE some_other_table SET x=1")  # no raise
+    def test_non_strict_qualified_table_passes(self):
+        M._STRICT_TABLES.add("public.cx_message")
+        M.assert_managed_write_allowed("UPDATE public.some_other_table SET x=1")  # no raise
 
-    def test_qualified_sql_matches_bare_registration(self):
-        M._STRICT_TABLES.add("cx_message")
+    def test_bare_write_target_is_refused_even_when_not_managed(self):
+        M._STRICT_TABLES.add("public.cx_message")
+        with pytest.raises(ManagedWriteViolation, match="schema.table"):
+            M.assert_managed_write_allowed("UPDATE some_other_table SET x=1")
+
+    def test_qualified_sql_matches_qualified_registration(self):
+        M._STRICT_TABLES.add("public.cx_message")
         with pytest.raises(ManagedWriteViolation):
             M.assert_managed_write_allowed("INSERT INTO public.cx_message (id) VALUES ($1)")
 
+    def test_same_bare_name_in_another_schema_does_not_match(self):
+        M._STRICT_TABLES.add("chat.message")
+        M.assert_managed_write_allowed("UPDATE public.message SET x=1")
+
+    def test_quoted_qualified_target_matches_exact_key(self):
+        M._STRICT_TABLES.add("chat.message")
+        with pytest.raises(ManagedWriteViolation):
+            M.assert_managed_write_allowed('UPDATE "chat"."message" SET x=1')
+
     def test_flush_context_is_allowed(self, monkeypatch):
-        M._STRICT_TABLES.add("cx_message")
+        M._STRICT_TABLES.add("public.cx_message")
         monkeypatch.setattr(flush_mod, "is_flushing", lambda: True)
-        M.assert_managed_write_allowed("UPDATE cx_message SET x=1")  # no raise
+        M.assert_managed_write_allowed("UPDATE public.cx_message SET x=1")  # no raise
 
     def test_unparseable_query_is_allowed(self):
         # A query we can't parse falls through (wrappers remain first defense).
-        M._STRICT_TABLES.add("cx_message")
+        M._STRICT_TABLES.add("public.cx_message")
         M.assert_managed_write_allowed("WITH t AS (...) UPDATE cx_message ...")  # no raise
 
 
@@ -91,9 +105,9 @@ class TestDeclareManagedRegistersStrictTable:
         from matrx_orm.session.managed import declare_managed
 
         declare_managed(model, mode="strict")
-        assert "strict_thing" in M._STRICT_TABLES
+        assert "public.strict_thing" in M._STRICT_TABLES
         with pytest.raises(ManagedWriteViolation):
-            M.assert_managed_write_allowed("DELETE FROM strict_thing WHERE id=$1")
+            M.assert_managed_write_allowed("DELETE FROM public.strict_thing WHERE id=$1")
 
     def test_elevate_declaration_does_not_register_strict(self):
         model = _make_model(
@@ -103,8 +117,8 @@ class TestDeclareManagedRegistersStrictTable:
         from matrx_orm.session.managed import declare_managed
 
         declare_managed(model, mode="elevate")
-        assert "elevate_thing" not in M._STRICT_TABLES
-        M.assert_managed_write_allowed("UPDATE elevate_thing SET x=1")  # no raise
+        assert "public.elevate_thing" not in M._STRICT_TABLES
+        M.assert_managed_write_allowed("UPDATE public.elevate_thing SET x=1")  # no raise
 
 
 class TestCoordinatorOwnedGuard:
@@ -266,7 +280,7 @@ class TestCoordinatorOwnedGuard:
             {"id": UUIDField(primary_key=True), "_table_name": "owned_thing"},
         )
         M.declare_managed(model, mode="coordinator")
-        M.assert_managed_write_allowed("UPDATE owned_thing SET x=1")
+        M.assert_managed_write_allowed("UPDATE public.owned_thing SET x=1")
         assert "COORDINATOR OWNERSHIP BYPASS" in caplog.text
 
     def test_internal_flush_is_silent_without_session_stack(self, caplog, monkeypatch):

{matrx_orm-3.1.63 → matrx_orm-3.1.64}/tests/session/test_coalesce.py

@@ -174,7 +174,7 @@ def test_summarize_counts_per_table(FakeMessage, FakeRequest):
         make_insert(FakeMessage, {"id": "m2"}),
         make_insert(FakeRequest, {"id": "r1", "conversation_id": "c1"}),
     ]
-    assert summarize(ops) == {"cx_message": 2, "cx_request": 1}
+    assert summarize(ops) == {"public.cx_message": 2, "public.cx_request": 1}
 
 
 def test_real_world_persist_completed_request_shape(

{matrx_orm-3.1.63 → matrx_orm-3.1.64}/tests/session/test_dag.py

@@ -77,7 +77,7 @@ def test_tier_summary_counts(FakeConversation, FakeMessage):
     ]
     tiers = tier_ops(ops)
     summary = tier_summary(tiers)
-    assert summary == [{"cx_conversation": 1}, {"cx_message": 2}]
+    assert summary == [{"public.cx_conversation": 1}, {"public.cx_message": 2}]
 
 
 class _UnresolvableFK:

{matrx_orm-3.1.63 → matrx_orm-3.1.64}/tests/session/test_disk_spill_fallback.py

@@ -27,6 +27,7 @@ from matrx_orm.session.op import SessionOp
 
 class _FakeMeta:
     table_name = "cx_message"
+    db_schema = "public"
 
 
 class _FakeModel:
@@ -50,7 +51,7 @@ def _row(op_id: str = "op-1", pk: str = "m1") -> dict:
         "request_id": "req-1",
         "user_id": None,
         "conversation_id": None,
-        "table_target": "cx_message",
+        "table_target": "public.cx_message",
         "op_type": "insert",
         "primary_key": json.dumps({"id": pk}),
         "payload": json.dumps({"id": pk, "content": "hi"}),
@@ -122,7 +123,7 @@ def test_spill_writes_one_file_per_op(spill_dir):
     # Content round-trips to the exact row shape.
     loaded = json.loads((spill_dir / "op-a.json").read_text())
     assert loaded["op_id"] == "op-a"
-    assert loaded["table_target"] == "cx_message"
+    assert loaded["table_target"] == "public.cx_message"
     # No temp files left behind.
     assert not list(spill_dir.glob(".*.tmp"))
 
@@ -164,7 +165,7 @@ async def test_record_failures_spills_when_db_capture_fails(spill_dir, monkeypat
     assert len(files) == 1
     row = json.loads(files[0].read_text())
     assert row["op_id"] == "op-outage"
-    assert row["table_target"] == "cx_message"
+    assert row["table_target"] == "public.cx_message"
     assert row["request_id"] == "req-9"