amfs-adapter-postgres 0.2.43__tar.gz → 0.2.44__tar.gz

{amfs_adapter_postgres-0.2.43 → amfs_adapter_postgres-0.2.44}/PKG-INFO

@@ -1,9 +1,9 @@
 Metadata-Version: 2.5
 Name: amfs-adapter-postgres
-Version: 0.2.43
+Version: 0.2.44
 Summary: AMFS Postgres adapter with back-propagation triggers
 License-Expression: Apache-2.0
 Requires-Python: >=3.11
-Requires-Dist: amfs-core>=0.3.54
+Requires-Dist: amfs-core>=0.3.56
 Requires-Dist: psycopg-pool>=3.1
 Requires-Dist: psycopg[binary]<4,>=3.1

{amfs_adapter_postgres-0.2.43 → amfs_adapter_postgres-0.2.44}/pyproject.toml

@@ -1,13 +1,13 @@
 [project]
 name = "amfs-adapter-postgres"
-version = "0.2.43"
+version = "0.2.44"
 description = "AMFS Postgres adapter with back-propagation triggers"
 requires-python = ">=3.11"
 license = "Apache-2.0"
 dependencies = [
     # 0.3.14 adds the capture fields this adapter now persists and selects back,
     # tool_calls among them.
-    "amfs-core>=0.3.54",
+    "amfs-core>=0.3.56",
     "psycopg[binary]>=3.1,<4",
     "psycopg-pool>=3.1",
 ]

{amfs_adapter_postgres-0.2.43 → amfs_adapter_postgres-0.2.44}/src/amfs_postgres/adapter.py

@@ -222,6 +222,14 @@ def priority_score_sql(now: datetime, config: Any | None = None) -> tuple[str, l
     return expr, params
 
 
+#: A row whose TTL has not passed: the predicate every read path that
+#: surfaces current entries carries (``list``, ``search``, ``semantic_search``,
+#: the agent listing). ``NOW()`` rather than a parameter because the fragment
+#: sits in WHERE lists whose parameters are positional and spliced around by
+#: their callers; with nothing to bind it cannot shift any of them.
+_NOT_EXPIRED = "(ttl_at IS NULL OR ttl_at > NOW())"
+
+
 def list_conditions(
     namespace: str,
     entity_path: str | None,
@@ -231,6 +239,7 @@ def list_conditions(
     scope: SqlScope | None,
     agent_id: str | None,
     branch_scope: tuple[str, list[Any]] | None = None,
+    include_expired: bool = False,
 ) -> tuple[list[str], list[Any]]:
     """The WHERE behind ``list()`` and ``count_entries()`` on both adapters.
 
@@ -238,6 +247,13 @@ def list_conditions(
     about which rows exist, and so the shared-namespace guard is applied to
     the unscoped read in one place (``tests/test_shared_path_scoping.py``).
 
+    The rows are the live ones: current and not past their ``ttl_at``, which
+    is the rule ``read`` and ``search`` apply, so a TTL takes effect on every
+    listing at once instead of when the sweep next archives the row. Two
+    callers see expired rows all the same. *include_superseded* is the
+    history, which hides nothing; *include_expired* is for the sweep, whose
+    whole purpose is to find them (``list_expired``).
+
     *branch_scope* replaces the plain ``branch = %s`` predicate with the
     overlay fragment from :func:`branch_scope_sql` (a branch's own live rows
     plus the parent's for every key it has not touched) — the adapters pass
@@ -258,6 +274,8 @@ def list_conditions(
 
     if not include_superseded:
         conditions.append("superseded_at IS NULL")
+        if not include_expired:
+            conditions.append(_NOT_EXPIRED)
     if agent_id is not None:
         conditions.append("agent_id = %s")
         params.append(agent_id)
@@ -2453,13 +2471,15 @@ class PostgresAdapter(AdapterABC):
 
         What a TTL sweep needs: the rows to archive, found through the
         partial index on ``ttl_at`` (``idx_entries_ttl``) rather than by
-        listing the tenant and checking each entry's clock in Python. Same
-        row set as ``list()`` — current versions, this branch, shared paths
-        excluded — narrowed to the expired ones. *limit* bounds one sweep;
-        the next sweep picks up the rest.
+        listing the tenant and checking each entry's clock in Python. The
+        scope is ``list()``'s — current versions, this branch, shared paths
+        excluded — and the rows are the ones ``list()`` leaves out: those past
+        their TTL and not yet archived. *limit* bounds one sweep; the next
+        sweep picks up the rest.
         """
         conditions, params = list_conditions(
             self._namespace, None, include_superseded=False, branch=branch, scope=None, agent_id=None,
+            include_expired=True,
         )
         conditions.append("ttl_at IS NOT NULL AND ttl_at <= %s")
         params.append(now or datetime.now(timezone.utc))
@@ -2684,7 +2704,7 @@ class PostgresAdapter(AdapterABC):
 
         # The branch scope is resolved on the connection below (it may need the
         # branch's parent); a placeholder keeps its position in the WHERE.
-        conditions = ["namespace = %s", _BRANCH_SCOPE, "superseded_at IS NULL"]
+        conditions = ["namespace = %s", _BRANCH_SCOPE, "superseded_at IS NULL", _NOT_EXPIRED]
         params: list[Any] = [self._namespace]
 
         if query.depth < 3:
@@ -2821,7 +2841,7 @@ class PostgresAdapter(AdapterABC):
 
         query_vec = query.embedding if query.embedding is not None else embedder.embed(query.text)
 
-        conditions = ["namespace = %s", "superseded_at IS NULL", "embedding IS NOT NULL"]
+        conditions = ["namespace = %s", "superseded_at IS NULL", "embedding IS NOT NULL", _NOT_EXPIRED]
         params: list[Any] = [self._namespace]
 
         if query.entity_path is not None:
@@ -2928,15 +2948,20 @@ class PostgresAdapter(AdapterABC):
         belonging to another agent turns up in ``keys``. A NULL *agent_id*
         compares as unknown rather than true, so passing nothing counts shared
         entries only — the safe direction.
+
+        The TTL predicate is here for the same reason: ``list()`` leaves out an
+        entry past its ``ttl_at``, so the key of one must not turn up in
+        ``keys`` either.
         """
         with self._pool.connection() as conn:
             row = conn.execute(
-                """SELECT count(*) AS total,
+                f"""SELECT count(*) AS total,
                           count(*) FILTER (WHERE coalesce(recall_count, 0) = 0)
                               AS never_read
                      FROM amfs_memory_entries
                     WHERE namespace = %s AND branch = %s AND entity_path = %s
                       AND superseded_at IS NULL
+                      AND {_NOT_EXPIRED}
                       AND (%s::text IS NULL OR key <> %s)
                       AND (shared OR agent_id = %s::text)""",
                 (self._namespace, branch, entity_path, exclude_key, exclude_key,
@@ -2944,9 +2969,10 @@ class PostgresAdapter(AdapterABC):
             ).fetchone()
             keys = [
                 r["key"] for r in conn.execute(
-                    """SELECT key FROM amfs_memory_entries
+                    f"""SELECT key FROM amfs_memory_entries
                         WHERE namespace = %s AND branch = %s AND entity_path = %s
                           AND superseded_at IS NULL
+                          AND {_NOT_EXPIRED}
                           AND (%s::text IS NULL OR key <> %s)
                           AND (shared OR agent_id = %s::text)
                         ORDER BY key LIMIT %s""",
@@ -5086,6 +5112,7 @@ class PostgresAdapter(AdapterABC):
             "agent_id = %s",
             "superseded_at IS NULL",
             "branch = 'main'",
+            _NOT_EXPIRED,
         ]
         params: list[Any] = [namespace, agent_id]
         for prefix in exclude_prefixes:

{amfs_adapter_postgres-0.2.43 → amfs_adapter_postgres-0.2.44}/src/amfs_postgres/async_adapter.py

@@ -42,6 +42,7 @@ from amfs_postgres.adapter import (
     _EVIDENCE_COLUMNS,
     _EVIDENCE_SELECT,
     _EXCLUDE_SHARED_PATHS,
+    _NOT_EXPIRED,
     _REUSE_EVENT_INSERT_SQL,
     PostgresAdapter,
     _evidence_params,
@@ -353,6 +354,12 @@ class AsyncPostgresAdapter:
         entry = self._row_to_entry(row)
         if entry.confidence < min_confidence:
             return None
+        # As ``PostgresAdapter.read`` does: a TTL takes effect on read, without
+        # waiting for the sweep. Missing here, the HTTP read route — which
+        # tries this adapter first — served an expired entry that the sync
+        # adapter behind the same route would have withheld.
+        if entry.is_expired():
+            return None
         return entry
 
     # ──────────────────────────────────────────────────────────────
@@ -580,7 +587,7 @@ class AsyncPostgresAdapter:
 
         # ``_BRANCH_SCOPE`` is swapped for the real branch condition once a
         # connection is open; its params are spliced in after the namespace.
-        conditions = ["namespace = %s", _BRANCH_SCOPE, "superseded_at IS NULL"]
+        conditions = ["namespace = %s", _BRANCH_SCOPE, "superseded_at IS NULL", _NOT_EXPIRED]
         params: list[Any] = [self._namespace]
 
         if query.depth < 3:
@@ -713,6 +720,7 @@ class AsyncPostgresAdapter:
             _BRANCH_SCOPE,
             "superseded_at IS NULL",
             "embedding IS NOT NULL",
+            _NOT_EXPIRED,
         ]
         params: list[Any] = [self._namespace]
         if query.entity_path is not None:
@@ -1145,15 +1153,19 @@ class AsyncPostgresAdapter:
         ``list()`` applied, and this block's ``keys`` land in a tool result. A
         NULL *agent_id* compares as unknown, so passing nothing counts shared
         entries only.
+
+        The TTL predicate is carried for the same reason: ``list()`` leaves out
+        an entry past its ``ttl_at``, so its key must not turn up here either.
         """
         async with self._pool.connection() as conn:
             cur = await conn.execute(
-                """SELECT count(*) AS total,
+                f"""SELECT count(*) AS total,
                           count(*) FILTER (WHERE coalesce(recall_count, 0) = 0)
                               AS never_read
                      FROM amfs_memory_entries
                     WHERE namespace = %s AND branch = %s AND entity_path = %s
                       AND superseded_at IS NULL
+                      AND {_NOT_EXPIRED}
                       AND (%s::text IS NULL OR key <> %s)
                       AND (shared OR agent_id = %s::text)""",
                 (self._namespace, branch, entity_path, exclude_key, exclude_key,
@@ -1161,9 +1173,10 @@ class AsyncPostgresAdapter:
             )
             row = await cur.fetchone()
             cur = await conn.execute(
-                """SELECT key FROM amfs_memory_entries
+                f"""SELECT key FROM amfs_memory_entries
                     WHERE namespace = %s AND branch = %s AND entity_path = %s
                       AND superseded_at IS NULL
+                      AND {_NOT_EXPIRED}
                       AND (%s::text IS NULL OR key <> %s)
                       AND (shared OR agent_id = %s::text)
                     ORDER BY key LIMIT %s""",