amfs-adapter-postgres 0.2.16__tar.gz → 0.2.17__tar.gz

{amfs_adapter_postgres-0.2.16 → amfs_adapter_postgres-0.2.17}/PKG-INFO

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

{amfs_adapter_postgres-0.2.16 → amfs_adapter_postgres-0.2.17}/pyproject.toml

@@ -1,13 +1,13 @@
 [project]
 name = "amfs-adapter-postgres"
-version = "0.2.16"
+version = "0.2.17"
 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.29",
+    "amfs-core>=0.3.30",
     "psycopg[binary]>=3.1,<4",
     "psycopg-pool>=3.1",
 ]

{amfs_adapter_postgres-0.2.16 → amfs_adapter_postgres-0.2.17}/src/amfs_postgres/adapter.py

@@ -146,6 +146,14 @@ _SCHEMA_SQL = (Path(__file__).parent / "schema.sql").read_text(encoding="utf-8")
 _OUTCOME_EVIDENCE_SQL = (
     Path(__file__).parent / "migrations" / "008_outcome_evidence.sql"
 ).read_text(encoding="utf-8")
+#: Migration 009 — action-level learning (actions_taken / entity_paths /
+#: situation on outcomes, validators on entries, first-strike tolerance in the
+#: step function). Same treatment as 008. The outcomes' ``task_embedding``
+#: column is not in the file: it is a pgvector column whose dimension follows
+#: the entries' embedding, so ``ensure_outcome_embedding_column`` adds it.
+_ACTION_PRIORS_SQL = (
+    Path(__file__).parent / "migrations" / "009_action_priors.sql"
+).read_text(encoding="utf-8")
 
 # Shared by the sync and async adapters so the two cannot drift apart. account_id
 # is omitted on purpose: the hosted product gives the column a default in a tenant
@@ -518,9 +526,14 @@ ENTRY_SELECT = ", ".join(_ENTRY_COLUMNS)
 ENTRY_SELECT_NO_ARTIFACT_COL = ", ".join(c for c in _ENTRY_COLUMNS if c != "is_artifact")
 
 
-def entry_select(has_is_artifact_col: bool) -> str:
-    """The SELECT list for queries whose rows become MemoryEntry objects."""
-    return ENTRY_SELECT if has_is_artifact_col else ENTRY_SELECT_NO_ARTIFACT_COL
+def entry_select(has_is_artifact_col: bool, has_validators_col: bool = False) -> str:
+    """The SELECT list for queries whose rows become MemoryEntry objects.
+
+    ``validators`` (migration 009) is appended only once the column exists; the
+    decoder defaults it to an empty list otherwise.
+    """
+    base = ENTRY_SELECT if has_is_artifact_col else ENTRY_SELECT_NO_ARTIFACT_COL
+    return base + ", validators" if has_validators_col else base
 
 
 def _evidence_params(entry: MemoryEntry) -> list[Any]:
@@ -537,6 +550,18 @@ def _evidence_params(entry: MemoryEntry) -> list[Any]:
     ]
 
 
+def _jsonb(raw: Any, default: Any) -> Any:
+    """A JSONB column as Python, whether the driver decoded it or left a string."""
+    if raw is None:
+        return default
+    if isinstance(raw, str):
+        try:
+            return json.loads(raw)
+        except ValueError:
+            return default
+    return raw
+
+
 def _inherit_from_row(entry: MemoryEntry, row: Any) -> MemoryEntry:
     """Apply ``inherit_evidence`` against the live row fetched inside the write
     transaction, so the hot paths that bypass the engine honour the same rule."""
@@ -556,10 +581,21 @@ def _inherit_from_row(entry: MemoryEntry, row: Any) -> MemoryEntry:
            for f in EVIDENCE_FIELDS},
         "evidence_success": float(row.get("evidence_success") or 0.0),
         "evidence_failure": float(row.get("evidence_failure") or 0.0),
+        "validators": _validators_of(row),
     })
     return inherit_evidence(entry, current)
 
 
+def _validators_of(row: Any) -> list[str]:
+    raw = row.get("validators") if hasattr(row, "get") else None
+    if isinstance(raw, str):
+        try:
+            raw = json.loads(raw)
+        except ValueError:
+            raw = None
+    return [str(v) for v in raw] if isinstance(raw, list) else []
+
+
 class PostgresAdapter(AdapterABC):
     """Store AMFS entries in PostgreSQL.
 
@@ -597,6 +633,9 @@ class PostgresAdapter(AdapterABC):
         self._has_search_tsv = False
         self._has_is_artifact_col = False
         self._has_evidence_cols = False
+        self._has_validators_col = False
+        self._has_action_cols = False
+        self._has_outcome_embedding_col = False
         # When an embedder is provided, embeddings are computed at write time and
         # persisted, so ANN retrieval (semantic_search / pgvector HNSW) works
         # without a separate backfill pass. embedding_dim must match the column
@@ -739,7 +778,7 @@ class PostgresAdapter(AdapterABC):
         if migrations is None:
             return None
         return hashlib.sha256(
-            (_SCHEMA_SQL + migrations + _OUTCOME_EVIDENCE_SQL).encode("utf-8")
+            (_SCHEMA_SQL + migrations + _OUTCOME_EVIDENCE_SQL + _ACTION_PRIORS_SQL).encode("utf-8")
         ).hexdigest()
 
     def _expected_tables(self) -> frozenset[str]:
@@ -1086,6 +1125,30 @@ class PostgresAdapter(AdapterABC):
         # with its helpers. Applied from the migration file rather than a copy
         # here — the copy is what drifted twice before (see 006 and 007).
         cur.execute(_OUTCOME_EVIDENCE_SQL)
+        # Action-level learning (trigger v4): see migration 009.
+        cur.execute(_ACTION_PRIORS_SQL)
+        # task_embedding on outcomes follows the entries' embedding dimension,
+        # so it is derived here rather than declared in the migration.
+        cur.execute(
+            """
+            SELECT format_type(a.atttypid, a.atttypmod) AS t
+            FROM pg_attribute a
+            WHERE a.attrelid = 'amfs_memory_entries'::regclass
+              AND a.attname = 'embedding' AND NOT a.attisdropped
+            """
+        )
+        row = cur.fetchone()
+        m = re.search(r"vector\((\d+)\)", str(row["t"])) if row else None
+        if m:
+            cur.execute(
+                f"ALTER TABLE amfs_outcomes ADD COLUMN IF NOT EXISTS "
+                f"task_embedding vector({int(m.group(1))})"
+            )
+            cur.execute(
+                "CREATE INDEX IF NOT EXISTS idx_outcomes_task_embedding "
+                "ON amfs_outcomes USING hnsw (task_embedding vector_cosine_ops) "
+                "WITH (m = 16, ef_construction = 64)"
+            )
         # Soft-delete for team members (user removal flow)
         cur.execute("""
             ALTER TABLE amfs_team_members
@@ -1474,7 +1537,7 @@ class PostgresAdapter(AdapterABC):
                     """
                     SELECT column_name FROM information_schema.columns
                     WHERE table_name = 'amfs_memory_entries'
-                      AND column_name IN ('embedding', 'search_tsv', 'is_artifact', 'success_count')
+                      AND column_name IN ('embedding', 'search_tsv', 'is_artifact', 'success_count', 'validators')
                     """,
                 )
                 found = {row["column_name"] for row in cur.fetchall()}
@@ -1482,6 +1545,17 @@ class PostgresAdapter(AdapterABC):
                 self._has_search_tsv = "search_tsv" in found
                 self._has_is_artifact_col = "is_artifact" in found
                 self._has_evidence_cols = "success_count" in found
+                self._has_validators_col = "validators" in found
+                cur.execute(
+                    """
+                    SELECT column_name FROM information_schema.columns
+                    WHERE table_name = 'amfs_outcomes'
+                      AND column_name IN ('actions_taken', 'task_embedding')
+                    """,
+                )
+                found = {row["column_name"] for row in cur.fetchall()}
+                self._has_action_cols = "actions_taken" in found
+                self._has_outcome_embedding_col = "task_embedding" in found
 
     # ------------------------------------------------------------------
     # read
@@ -1574,7 +1648,7 @@ class PostgresAdapter(AdapterABC):
                 with conn.cursor() as cur:
                     cur.execute(
                         f"""
-                        SELECT version, value, confidence{_EVIDENCE_SELECT if self._has_evidence_cols else ""}
+                        SELECT version, value, confidence{_EVIDENCE_SELECT if self._has_evidence_cols else ""}{", validators" if self._has_validators_col else ""}
                         FROM amfs_memory_entries
                         WHERE namespace = %s AND branch = %s
                           AND entity_path = %s AND key = %s
@@ -1657,6 +1731,9 @@ class PostgresAdapter(AdapterABC):
                     if self._has_evidence_cols:
                         columns.extend(_EVIDENCE_COLUMNS)
                         params.extend(_evidence_params(entry))
+                    if self._has_validators_col:
+                        columns.append("validators")
+                        params.append(json.dumps(list(entry.validators or [])))
 
                     # Write-time embedding: compute and persist an embedding when
                     # the caller did not supply one and an embedder is configured.
@@ -1968,7 +2045,7 @@ class PostgresAdapter(AdapterABC):
 
         where = " AND ".join(conditions)
         query = (
-            f"SELECT {entry_select(self._has_is_artifact_col)} FROM amfs_memory_entries "
+            f"SELECT {entry_select(self._has_is_artifact_col, self._has_validators_col)} FROM amfs_memory_entries "
             f"WHERE {where} ORDER BY entity_path, key, version"
         )
 
@@ -2073,7 +2150,7 @@ class PostgresAdapter(AdapterABC):
 
         where = " AND ".join(conditions)
         sql = f"""
-            SELECT {entry_select(col_ready)} FROM amfs_memory_entries
+            SELECT {entry_select(col_ready, self._has_validators_col)} FROM amfs_memory_entries
             WHERE {where}
             ORDER BY {order}
             LIMIT %s
@@ -3231,29 +3308,44 @@ class PostgresAdapter(AdapterABC):
                     "SELECT set_config('amfs.outcome_model', %s, true)",
                     (outcome_model(),),
                 )
-                cur.execute(
-                    """
-                    INSERT INTO amfs_outcomes (
-                        namespace, outcome_ref, outcome_type, causal_confidence,
-                        committed_at, causal_entry_keys, agent_id,
-                        attempts, final_action_index, causal_entry_versions
-                    ) VALUES (%s, %s, %s, %s, %s, %s, %s, %s::jsonb, %s, %s::jsonb)
-                    """,
-                    (
-                        self._namespace,
-                        record.outcome_ref,
-                        record.outcome_type.value,
-                        record.causal_confidence,
-                        record.committed_at,
-                        record.causal_entry_keys,
-                        record.agent_id,
-                        json.dumps(
-                            [a.model_dump(mode="json") for a in record.attempts],
-                            default=str,
-                        ),
-                        record.final_action_index,
-                        json.dumps(dict(record.causal_entry_versions or {})),
+                columns = [
+                    "namespace", "outcome_ref", "outcome_type", "causal_confidence",
+                    "committed_at", "causal_entry_keys", "agent_id",
+                    "attempts", "final_action_index", "causal_entry_versions",
+                ]
+                placeholders = ["%s"] * 7 + ["%s::jsonb", "%s", "%s::jsonb"]
+                params: list[Any] = [
+                    self._namespace,
+                    record.outcome_ref,
+                    record.outcome_type.value,
+                    record.causal_confidence,
+                    record.committed_at,
+                    record.causal_entry_keys,
+                    record.agent_id,
+                    json.dumps(
+                        [a.model_dump(mode="json") for a in record.attempts],
+                        default=str,
                     ),
+                    record.final_action_index,
+                    json.dumps(dict(record.causal_entry_versions or {})),
+                ]
+                if self._has_action_cols:
+                    columns += ["actions_taken", "entity_paths", "situation"]
+                    placeholders += ["%s::jsonb", "%s", "%s"]
+                    params += [
+                        json.dumps(list(record.actions_taken or []), default=str),
+                        list(record.entity_paths or []),
+                        record.situation,
+                    ]
+                task_embedding = self._outcome_embedding(record)
+                if task_embedding is not None:
+                    columns.append("task_embedding")
+                    placeholders.append("%s")
+                    params.append(f"[{','.join(str(v) for v in task_embedding)}]")
+                cur.execute(
+                    f"INSERT INTO amfs_outcomes ({', '.join(columns)}) "
+                    f"VALUES ({', '.join(placeholders)})",
+                    params,
                 )
 
         # Every entry any step cited, including the failed attempts' — those
@@ -3320,10 +3412,11 @@ class PostgresAdapter(AdapterABC):
         where, params = self._outcome_conditions(
             entity_path=entity_path, since=since, outcome_ref=outcome_ref
         )
+        extra = ", actions_taken, entity_paths, situation" if self._has_action_cols else ""
         sql = f"""
             SELECT outcome_ref, outcome_type, causal_confidence,
                    committed_at, causal_entry_keys, agent_id,
-                   attempts, final_action_index
+                   attempts, final_action_index, causal_entry_versions{extra}
             FROM amfs_outcomes
             WHERE {where}
             ORDER BY committed_at DESC
@@ -3352,10 +3445,159 @@ class PostgresAdapter(AdapterABC):
                     agent_id=row["agent_id"],
                     attempts=_attempts_from_row(row.get("attempts")),
                     final_action_index=row.get("final_action_index"),
+                    causal_entry_versions=_jsonb(row.get("causal_entry_versions"), {}),
+                    actions_taken=_jsonb(row.get("actions_taken"), []),
+                    entity_paths=list(row.get("entity_paths") or []),
+                    situation=row.get("situation"),
                 )
             )
         return results
 
+    # ------------------------------------------------------------------
+    # action priors (migration 009)
+    # ------------------------------------------------------------------
+
+    def _outcome_embedding(self, record: OutcomeRecord) -> list[float] | None:
+        """The vector stored with an outcome so later tasks can find it by
+        similarity. Built from the situation label and the task input; ``None``
+        when there is nothing to embed, no embedder, or no column."""
+        if self._embedder is None or not self._has_outcome_embedding_col:
+            return None
+        text = " ".join(t for t in (record.situation, record.task_input) if t).strip()
+        if not text:
+            return None
+        try:
+            return self._embedder.embed(text[:2000])
+        except Exception:  # noqa: BLE001
+            logger.warning("outcome embedding failed for %s; storing without vector",
+                           record.outcome_ref, exc_info=True)
+            return None
+
+    def ensure_outcome_embedding_column(self) -> bool:
+        """Add ``amfs_outcomes.task_embedding`` at the entries' embedding dimension.
+
+        Idempotent. Returns ``False`` (and does nothing) when the entries table
+        has no embedding column yet — the dimension is read from it, never
+        assumed, because deployments provision 384 or 1024 (see
+        ``ensure_embedding_column``). The HNSW index is built over a column that
+        is NULL on every existing row, so it is cheap on a populated table.
+        """
+        with self._maintenance_connection() as conn:
+            with conn.cursor() as cur:
+                cur.execute(
+                    """
+                    SELECT format_type(a.atttypid, a.atttypmod) AS t
+                    FROM pg_attribute a
+                    WHERE a.attrelid = 'amfs_memory_entries'::regclass
+                      AND a.attname = 'embedding' AND NOT a.attisdropped
+                    """
+                )
+                row = cur.fetchone()
+                if not row:
+                    return False
+                m = re.search(r"vector\((\d+)\)", str(row["t"]))
+                if not m:
+                    return False
+                dim = int(m.group(1))
+                cur.execute(
+                    f"ALTER TABLE amfs_outcomes ADD COLUMN IF NOT EXISTS task_embedding vector({dim})"
+                )
+                cur.execute(
+                    "CREATE INDEX IF NOT EXISTS idx_outcomes_task_embedding "
+                    "ON amfs_outcomes USING hnsw (task_embedding vector_cosine_ops) "
+                    "WITH (m = 16, ef_construction = 64)"
+                )
+        self._detect_optional_columns()
+        return True
+
+    def similar_outcomes(
+        self,
+        entity_path: str,
+        embedding: list[float],
+        *,
+        k: int = 20,
+        min_similarity: float = 0.75,
+        since: datetime | None = None,
+    ) -> list[dict[str, Any]]:
+        """The ``k`` committed outcomes about ``entity_path`` whose task was most
+        like the one embedded, each with its ``actions_taken`` and ``similarity``.
+
+        Empty when the store has no task embeddings (no embedder, or the column
+        is not provisioned), so callers fall back to :meth:`action_stats`.
+        """
+        if not self._has_outcome_embedding_col or not self._has_action_cols or not embedding:
+            return []
+        vec = f"[{','.join(str(v) for v in embedding)}]"
+        conditions = ["namespace = %s", "task_embedding IS NOT NULL", "%s = ANY(entity_paths)"]
+        params: list[Any] = [self._namespace, entity_path]
+        if since is not None:
+            conditions.append("committed_at >= %s")
+            params.append(since)
+        sql = f"""
+            SELECT outcome_ref, outcome_type, committed_at, agent_id, actions_taken, situation,
+                   1 - (task_embedding <=> %s::vector) AS similarity
+            FROM amfs_outcomes
+            WHERE {" AND ".join(conditions)}
+            ORDER BY task_embedding <=> %s::vector
+            LIMIT %s
+        """
+        with self._pool.connection() as conn:
+            with conn.cursor() as cur:
+                cur.execute(sql, [vec, *params, vec, int(k)])
+                rows = cur.fetchall()
+        out: list[dict[str, Any]] = []
+        for row in rows:
+            sim = float(row["similarity"] or 0.0)
+            if sim < min_similarity:
+                continue
+            out.append({
+                "outcome_ref": row["outcome_ref"],
+                "outcome_type": row["outcome_type"],
+                "committed_at": row["committed_at"],
+                "agent_id": row["agent_id"],
+                "situation": row.get("situation"),
+                "actions_taken": _jsonb(row.get("actions_taken"), []),
+                "similarity": sim,
+            })
+        return out
+
+    def action_stats(
+        self,
+        entity_path: str,
+        *,
+        since: datetime | None = None,
+        limit: int = 500,
+    ) -> list[dict[str, Any]]:
+        """The most recent outcomes about ``entity_path`` with their
+        ``actions_taken`` — the similarity-free fallback for priors."""
+        if not self._has_action_cols:
+            return []
+        conditions = ["namespace = %s", "%s = ANY(entity_paths)", "actions_taken <> '[]'::jsonb"]
+        params: list[Any] = [self._namespace, entity_path]
+        if since is not None:
+            conditions.append("committed_at >= %s")
+            params.append(since)
+        sql = f"""
+            SELECT outcome_ref, outcome_type, committed_at, agent_id, actions_taken, situation
+            FROM amfs_outcomes
+            WHERE {" AND ".join(conditions)}
+            ORDER BY committed_at DESC
+            LIMIT %s
+        """
+        with self._pool.connection() as conn:
+            with conn.cursor() as cur:
+                cur.execute(sql, [*params, int(limit)])
+                rows = cur.fetchall()
+        return [{
+            "outcome_ref": row["outcome_ref"],
+            "outcome_type": row["outcome_type"],
+            "committed_at": row["committed_at"],
+            "agent_id": row["agent_id"],
+            "situation": row.get("situation"),
+            "actions_taken": _jsonb(row.get("actions_taken"), []),
+            "similarity": 1.0,
+        } for row in rows]
+
     # ------------------------------------------------------------------
     # decision traces
     # ------------------------------------------------------------------
@@ -3931,6 +4173,7 @@ class PostgresAdapter(AdapterABC):
             last_outcome=row.get("last_outcome"),
             last_outcome_at=row.get("last_outcome_at"),
             discredited_at=row.get("discredited_at"),
+            validators=_validators_of(row),
             recall_count=row.get("recall_count", 0),
             priority_score=float(row["priority_score"]) if row.get("priority_score") is not None else None,
             tier=row.get("tier", 3),

amfs_adapter_postgres-0.2.17/src/amfs_postgres/migrations/009_action_priors.sql

@@ -0,0 +1,254 @@
+-- Migration 009: action-level learning, first-strike tolerance, validators
+--
+-- Grid v2 of the continual-learning benchmark showed two things the evidence
+-- model of 008 could not do:
+--
+--   * Memory entries record what someone *wrote*; nothing recorded what
+--     happened when an agent *did* something. A support fleet spent 24
+--     attempts per ticket class on the same two failing actions and never
+--     tried the one that worked, because "tried and failed here" was not a
+--     thing memory could say. `actions_taken` on the outcome row is that
+--     record: the action that ended each failed attempt (a loss) and the
+--     terminal action (the outcome). `entity_paths` scopes it to the entities
+--     the outcome was about; `situation` is an optional caller label. The
+--     server adds `task_embedding` (a pgvector column at the same dimension as
+--     the entries' embedding — provisioned by the adapter, not here, because
+--     the dimension is deployment-specific) so a retrieve can ask "on the
+--     tasks most like this one, what worked?".
+--   * A single failure on a rule validated four times discredited it
+--     (0.89 -> 0.49) and pulled it out of retrieval. That is how the surprise
+--     term should treat a fresh claim, not a proven one. The first failure of
+--     an entry with a clean record of at least three successes is now weighed
+--     without surprise: the rule is left contested (~0.62), and a second
+--     failure still discredits it (~0.40), so a regime change is unlearned in
+--     the same two strikes as before.
+--
+-- `validators` on entries lists the distinct agents whose successes credited
+-- the claim; the trigger maintains it. The step function gains the committing
+-- agent as an eighth argument; the seven-argument form is retired.
+--
+-- Arithmetic mirrors amfs_core/evidence.py and must stay identical to
+-- schema.sql, which carries the same function bodies.
+
+ALTER TABLE amfs_outcomes ADD COLUMN IF NOT EXISTS actions_taken JSONB NOT NULL DEFAULT '[]';
+ALTER TABLE amfs_outcomes ADD COLUMN IF NOT EXISTS entity_paths TEXT[] NOT NULL DEFAULT '{}';
+ALTER TABLE amfs_outcomes ADD COLUMN IF NOT EXISTS situation TEXT;
+ALTER TABLE amfs_memory_entries ADD COLUMN IF NOT EXISTS validators JSONB NOT NULL DEFAULT '[]';
+
+-- Priors are scoped by entity overlap, then narrowed by vector similarity.
+CREATE INDEX IF NOT EXISTS idx_outcomes_entity_paths
+    ON amfs_outcomes USING gin (entity_paths);
+CREATE INDEX IF NOT EXISTS idx_outcomes_ns_committed
+    ON amfs_outcomes (namespace, committed_at DESC);
+
+-- The seven-argument step predates validators; the trigger below calls the
+-- eight-argument one, so the old overload is retired here.
+DROP FUNCTION IF EXISTS amfs_apply_outcome_step(TEXT, UUID, TEXT[], TEXT, NUMERIC, TEXT, JSONB);
+
+CREATE OR REPLACE FUNCTION amfs_apply_outcome_step(
+    p_namespace TEXT,
+    p_account UUID,
+    p_keys TEXT[],
+    p_outcome_type TEXT,
+    p_causal_confidence NUMERIC,
+    p_model TEXT,
+    p_versions JSONB,
+    p_agent TEXT
+) RETURNS INTEGER AS $$
+DECLARE
+    keys TEXT[];
+    entry_key TEXT;
+    ep TEXT;
+    k TEXT;
+    cur RECORD;
+    read_version INTEGER;
+    read_value JSONB;
+    n_keys INTEGER;
+    is_ok BOOLEAN;
+    target NUMERIC;
+    w NUMERIC;
+    prior NUMERIC;
+    e_s NUMERIC;
+    e_f NUMERIC;
+    new_conf NUMERIC;
+    disc TIMESTAMPTZ;
+    surprise NUMERIC;
+    vals JSONB;
+    touched INTEGER := 0;
+BEGIN
+    -- Distinct, well-formed specs only; a key cited twice is one citation.
+    SELECT COALESCE(array_agg(DISTINCT x), '{}') INTO keys
+    FROM unnest(COALESCE(p_keys, '{}')) AS x
+    WHERE position('/' in x) > 0;
+    n_keys := cardinality(keys);
+    IF n_keys = 0 THEN
+        RETURN 0;
+    END IF;
+
+    -- An outcome type neither side of the model knows is not evidence of
+    -- anything (the multipliers treated it as x1.0; this treats it as no step).
+    IF NOT amfs_outcome_is_known(p_outcome_type) THEN
+        RETURN 0;
+    END IF;
+    is_ok := amfs_outcome_is_success(p_outcome_type);
+    target := CASE WHEN is_ok THEN 1.0 ELSE 0.0 END;
+
+    FOREACH entry_key IN ARRAY keys
+    LOOP
+        -- Last-slash split, matching Python's rsplit("/", 1).
+        k := substring(entry_key from '([^/]+)$');
+        ep := left(entry_key, length(entry_key) - length(k) - 1);
+
+        SELECT * INTO cur FROM amfs_memory_entries
+        WHERE namespace = p_namespace
+          AND entity_path = ep
+          AND key = k
+          AND superseded_at IS NULL
+          AND account_id IS NOT DISTINCT FROM p_account
+        ORDER BY version DESC LIMIT 1;
+
+        IF NOT FOUND THEN
+            CONTINUE;
+        END IF;
+
+        -- Credit the claim that was read. If the key has been rewritten since
+        -- and now says something else, this outcome is about the old claim.
+        read_version := NULLIF(COALESCE(p_versions, '{}'::jsonb)->>entry_key, '')::INTEGER;
+        IF read_version IS NOT NULL AND read_version <> cur.version THEN
+            SELECT value INTO read_value FROM amfs_memory_entries
+            WHERE namespace = p_namespace
+              AND entity_path = ep
+              AND key = k
+              AND version = read_version
+              AND account_id IS NOT DISTINCT FROM p_account
+            LIMIT 1;
+            IF FOUND AND read_value IS DISTINCT FROM cur.value THEN
+                CONTINUE;
+            END IF;
+        END IF;
+
+        prior := LEAST(1.0, GREATEST(0.0, COALESCE(cur.prior_confidence, cur.confidence)));
+
+        IF p_model = 'multiplicative' THEN
+            new_conf := LEAST(1.0, GREATEST(0.0,
+                cur.confidence * amfs_outcome_multiplier(p_outcome_type) * p_causal_confidence));
+            e_s := COALESCE(cur.evidence_success, 0) + CASE WHEN is_ok THEN 1 ELSE 0 END;
+            e_f := COALESCE(cur.evidence_failure, 0) + CASE WHEN is_ok THEN 0 ELSE 1 END;
+        ELSE
+            -- First strike: the first failure of an entry with a clean record
+            -- of at least three successes is weighed without the surprise
+            -- term (amfs_core.evidence.first_strike). One slip on a validated
+            -- rule leaves it contested; the second still discredits it.
+            surprise := 1.0 + abs(target - LEAST(1.0, GREATEST(0.0, cur.confidence)));
+            IF NOT is_ok AND COALESCE(cur.failure_count, 0) = 0
+               AND COALESCE(cur.success_count, 0) >= 3 THEN
+                surprise := 1.0;
+            END IF;
+            w := amfs_outcome_severity(p_outcome_type)
+                 * GREATEST(0.0, p_causal_confidence)
+                 / n_keys
+                 * surprise;
+            e_s := COALESCE(cur.evidence_success, 0) * 0.8 + CASE WHEN is_ok THEN w ELSE 0 END;
+            e_f := COALESCE(cur.evidence_failure, 0) * 0.8 + CASE WHEN is_ok THEN 0 ELSE w END;
+            new_conf := LEAST(1.0, GREATEST(0.0, (2.0 * prior + e_s) / (2.0 + e_s + e_f)));
+        END IF;
+
+        IF new_conf < 0.5 AND NOT is_ok THEN
+            disc := COALESCE(cur.discredited_at, NOW());
+        ELSIF new_conf >= 0.5 THEN
+            disc := NULL;
+        ELSE
+            disc := cur.discredited_at;
+        END IF;
+
+        -- Validators: distinct agents whose successes credited this claim,
+        -- most recent last, capped at ten (amfs_core.evidence.validators_after).
+        vals := COALESCE(cur.validators, '[]'::jsonb);
+        IF is_ok AND COALESCE(p_agent, '') <> '' THEN
+            vals := vals - p_agent;
+            vals := vals || to_jsonb(ARRAY[p_agent]);
+            IF jsonb_array_length(vals) > 10 THEN
+                SELECT COALESCE(jsonb_agg(v), '[]'::jsonb) INTO vals
+                FROM (
+                    SELECT v FROM jsonb_array_elements(vals) WITH ORDINALITY AS t(v, ord)
+                    ORDER BY ord OFFSET jsonb_array_length(vals) - 10
+                ) s;
+            END IF;
+        END IF;
+
+        UPDATE amfs_memory_entries
+        SET superseded_at = NOW()
+        WHERE id = cur.id;
+
+        -- Copy the row (see 007); override only what this version changes.
+        INSERT INTO amfs_memory_entries
+        SELECT * FROM jsonb_populate_record(
+            NULL::amfs_memory_entries,
+            to_jsonb(cur) || jsonb_build_object(
+                'id', gen_random_uuid(),
+                'version', cur.version + 1,
+                'confidence', new_conf,
+                'outcome_count', cur.outcome_count + 1,
+                'success_count', COALESCE(cur.success_count, 0) + CASE WHEN is_ok THEN 1 ELSE 0 END,
+                'failure_count', COALESCE(cur.failure_count, 0) + CASE WHEN is_ok THEN 0 ELSE 1 END,
+                'evidence_success', e_s,
+                'evidence_failure', e_f,
+                'prior_confidence', prior,
+                'last_outcome', p_outcome_type,
+                'last_outcome_at', NOW(),
+                'discredited_at', disc,
+                'validators', vals,
+                'superseded_at', NULL
+            )
+        );
+        touched := touched + 1;
+    END LOOP;
+    RETURN touched;
+END;
+$$ LANGUAGE plpgsql;
+
+CREATE OR REPLACE FUNCTION amfs_propagate_outcome() RETURNS TRIGGER AS $$
+DECLARE
+    model TEXT;
+    att JSONB;
+    att_keys TEXT[];
+BEGIN
+    model := COALESCE(NULLIF(current_setting('amfs.outcome_model', true), ''), 'evidence');
+
+    -- Failed attempts first, oldest to newest: each hands its own failure to
+    -- the entries that attempt relied on.
+    FOR att IN
+        SELECT value FROM jsonb_array_elements(COALESCE(NEW.attempts, '[]'::jsonb))
+        ORDER BY COALESCE((value->>'attempt')::INTEGER, 0)
+    LOOP
+        SELECT COALESCE(array_agg(x), '{}') INTO att_keys
+        FROM jsonb_array_elements_text(COALESCE(att->'causal_entry_keys', '[]'::jsonb)) AS x;
+        PERFORM amfs_apply_outcome_step(
+            NEW.namespace, NEW.account_id, att_keys,
+            COALESCE(att->>'outcome_type', 'minor_failure'),
+            NEW.causal_confidence, model,
+            COALESCE(att->'causal_entry_versions', '{}'::jsonb),
+            NEW.agent_id
+        );
+    END LOOP;
+
+    -- Then the terminal outcome to the entries the resolution relied on.
+    PERFORM amfs_apply_outcome_step(
+        NEW.namespace, NEW.account_id, NEW.causal_entry_keys,
+        NEW.outcome_type, NEW.causal_confidence, model,
+        COALESCE(NEW.causal_entry_versions, '{}'::jsonb),
+        NEW.agent_id
+    );
+
+    PERFORM pg_notify('amfs_outcome', json_build_object(
+        'namespace', NEW.namespace,
+        'outcome_ref', NEW.outcome_ref,
+        'outcome_type', NEW.outcome_type,
+        'agent_id', NEW.agent_id,
+        'causal_confidence', NEW.causal_confidence,
+        'attempts', jsonb_array_length(COALESCE(NEW.attempts, '[]'::jsonb))
+    )::TEXT);
+
+    RETURN NEW;
+END;
+$$ LANGUAGE plpgsql;

{amfs_adapter_postgres-0.2.16 → amfs_adapter_postgres-0.2.17}/src/amfs_postgres/schema.sql

@@ -22,6 +22,7 @@ CREATE TABLE IF NOT EXISTS amfs_memory_entries (
     last_outcome TEXT,
     last_outcome_at TIMESTAMPTZ,
     discredited_at TIMESTAMPTZ,
+    validators JSONB NOT NULL DEFAULT '[]',
     recall_count INTEGER DEFAULT 0,
     priority_score NUMERIC(10,6),
     tier SMALLINT DEFAULT 3,
@@ -58,7 +59,10 @@ CREATE TABLE IF NOT EXISTS amfs_outcomes (
     account_id UUID,
     attempts JSONB NOT NULL DEFAULT '[]',
     causal_entry_versions JSONB NOT NULL DEFAULT '{}',
-    final_action_index INTEGER
+    final_action_index INTEGER,
+    actions_taken JSONB NOT NULL DEFAULT '[]',
+    entity_paths TEXT[] NOT NULL DEFAULT '{}',
+    situation TEXT
 );
 
 -- Range-partitioned by month on created_at. Traces are append-only and read by
@@ -427,6 +431,10 @@ CREATE INDEX IF NOT EXISTS idx_pr_reviews_pr
 CREATE INDEX IF NOT EXISTS idx_entries_discredited
     ON amfs_memory_entries (namespace, entity_path, discredited_at)
     WHERE discredited_at IS NOT NULL AND superseded_at IS NULL;
+CREATE INDEX IF NOT EXISTS idx_outcomes_entity_paths
+    ON amfs_outcomes USING gin (entity_paths);
+CREATE INDEX IF NOT EXISTS idx_outcomes_ns_committed
+    ON amfs_outcomes (namespace, committed_at DESC);
 
 CREATE OR REPLACE FUNCTION amfs_outcome_is_success(t TEXT) RETURNS BOOLEAN AS $$
     SELECT t IN ('success', 'clean_deploy');
@@ -470,6 +478,7 @@ $$ LANGUAGE sql IMMUTABLE;
 -- credit-split over those keys. The trigger calls this once per failed
 -- attempt and once for the terminal outcome.
 DROP FUNCTION IF EXISTS amfs_apply_outcome_step(TEXT, UUID, TEXT[], TEXT, NUMERIC, TEXT);
+DROP FUNCTION IF EXISTS amfs_apply_outcome_step(TEXT, UUID, TEXT[], TEXT, NUMERIC, TEXT, JSONB);
 
 CREATE OR REPLACE FUNCTION amfs_apply_outcome_step(
     p_namespace TEXT,
@@ -478,7 +487,8 @@ CREATE OR REPLACE FUNCTION amfs_apply_outcome_step(
     p_outcome_type TEXT,
     p_causal_confidence NUMERIC,
     p_model TEXT,
-    p_versions JSONB
+    p_versions JSONB,
+    p_agent TEXT
 ) RETURNS INTEGER AS $$
 DECLARE
     keys TEXT[];
@@ -497,6 +507,8 @@ DECLARE
     e_f NUMERIC;
     new_conf NUMERIC;
     disc TIMESTAMPTZ;
+    surprise NUMERIC;
+    vals JSONB;
     touched INTEGER := 0;
 BEGIN
     -- Distinct, well-formed specs only; a key cited twice is one citation.
@@ -558,10 +570,19 @@ BEGIN
             e_s := COALESCE(cur.evidence_success, 0) + CASE WHEN is_ok THEN 1 ELSE 0 END;
             e_f := COALESCE(cur.evidence_failure, 0) + CASE WHEN is_ok THEN 0 ELSE 1 END;
         ELSE
+            -- First strike: the first failure of an entry with a clean record
+            -- of at least three successes is weighed without the surprise
+            -- term (amfs_core.evidence.first_strike). One slip on a validated
+            -- rule leaves it contested; the second still discredits it.
+            surprise := 1.0 + abs(target - LEAST(1.0, GREATEST(0.0, cur.confidence)));
+            IF NOT is_ok AND COALESCE(cur.failure_count, 0) = 0
+               AND COALESCE(cur.success_count, 0) >= 3 THEN
+                surprise := 1.0;
+            END IF;
             w := amfs_outcome_severity(p_outcome_type)
                  * GREATEST(0.0, p_causal_confidence)
                  / n_keys
-                 * (1.0 + abs(target - LEAST(1.0, GREATEST(0.0, cur.confidence))));
+                 * surprise;
             e_s := COALESCE(cur.evidence_success, 0) * 0.8 + CASE WHEN is_ok THEN w ELSE 0 END;
             e_f := COALESCE(cur.evidence_failure, 0) * 0.8 + CASE WHEN is_ok THEN 0 ELSE w END;
             new_conf := LEAST(1.0, GREATEST(0.0, (2.0 * prior + e_s) / (2.0 + e_s + e_f)));
@@ -575,6 +596,21 @@ BEGIN
             disc := cur.discredited_at;
         END IF;
 
+        -- Validators: distinct agents whose successes credited this claim,
+        -- most recent last, capped at ten (amfs_core.evidence.validators_after).
+        vals := COALESCE(cur.validators, '[]'::jsonb);
+        IF is_ok AND COALESCE(p_agent, '') <> '' THEN
+            vals := vals - p_agent;
+            vals := vals || to_jsonb(ARRAY[p_agent]);
+            IF jsonb_array_length(vals) > 10 THEN
+                SELECT COALESCE(jsonb_agg(v), '[]'::jsonb) INTO vals
+                FROM (
+                    SELECT v FROM jsonb_array_elements(vals) WITH ORDINALITY AS t(v, ord)
+                    ORDER BY ord OFFSET jsonb_array_length(vals) - 10
+                ) s;
+            END IF;
+        END IF;
+
         UPDATE amfs_memory_entries
         SET superseded_at = NOW()
         WHERE id = cur.id;
@@ -596,6 +632,7 @@ BEGIN
                 'last_outcome', p_outcome_type,
                 'last_outcome_at', NOW(),
                 'discredited_at', disc,
+                'validators', vals,
                 'superseded_at', NULL
             )
         );
@@ -625,7 +662,8 @@ BEGIN
             NEW.namespace, NEW.account_id, att_keys,
             COALESCE(att->>'outcome_type', 'minor_failure'),
             NEW.causal_confidence, model,
-            COALESCE(att->'causal_entry_versions', '{}'::jsonb)
+            COALESCE(att->'causal_entry_versions', '{}'::jsonb),
+            NEW.agent_id
         );
     END LOOP;
 
@@ -633,7 +671,8 @@ BEGIN
     PERFORM amfs_apply_outcome_step(
         NEW.namespace, NEW.account_id, NEW.causal_entry_keys,
         NEW.outcome_type, NEW.causal_confidence, model,
-        COALESCE(NEW.causal_entry_versions, '{}'::jsonb)
+        COALESCE(NEW.causal_entry_versions, '{}'::jsonb),
+        NEW.agent_id
     );
 
     PERFORM pg_notify('amfs_outcome', json_build_object(