memledger 0.5.0a0__py3-none-any.whl

evaluators/__init__.py

@@ -0,0 +1,53 @@
+"""Memledger evaluation suite.
+
+Three tiers, ordered by install footprint:
+
+  Tier 1 — Deterministic Memory Attribution Integrity (MAI)
+      `from evaluators import evaluate_attribution_integrity`
+      Returns an AttributionIntegrityResult.
+      Pure stdlib. No deps beyond memledger core. Always available.
+
+  Tier 2 — RAGAS LLM-as-judge (OSS, provider-agnostic via LiteLLM)
+      `from evaluators import evaluate_mai_ragas`
+      Requires `pip install memledger[eval]`.
+      Set $MEMLEDGER_JUDGE_MODEL (e.g. `openai/gpt-4o-mini`,
+      `bedrock/anthropic.claude-...`, `anthropic/claude-...`,
+      `ollama/llama3.1`).
+
+  Tier 3 — AWS Bedrock AgentCore evaluator
+      `from evaluators import register_agentcore_evaluator`
+      Requires `pip install memledger[aws]`. AWS credentials needed.
+
+The RAGAS and AgentCore entry points are lazy-imported so a clean
+`pip install memledger` (no extras) can still load this module
+and run the deterministic tier.
+"""
+
+from __future__ import annotations
+
+from evaluators.attribution_integrity import (
+    AttributionIntegrityResult,
+    evaluate_attribution_integrity,
+)
+
+
+def evaluate_mai_ragas(*args, **kwargs):
+    """Tier 2 — RAGAS LLM-as-judge. Lazy-imports the [eval] deps."""
+    from evaluators.attribution_integrity_ragas import evaluate_mai_ragas as _impl
+    return _impl(*args, **kwargs)
+
+
+def register_agentcore_evaluator(*args, **kwargs):
+    """Tier 3 — AWS Bedrock AgentCore evaluator. Lazy-imports boto3."""
+    from evaluators.agentcore_evaluator import (
+        register_agentcore_evaluator as _impl,
+    )
+    return _impl(*args, **kwargs)
+
+
+__all__ = [
+    "AttributionIntegrityResult",
+    "evaluate_attribution_integrity",
+    "evaluate_mai_ragas",
+    "register_agentcore_evaluator",
+]

evaluators/agentcore_eval_runner.py

@@ -0,0 +1,238 @@
+"""F6 — AgentCore Evaluation Runner.
+
+Runs built-in AgentCore evaluators against memory operation data exported
+from Phoenix/Aurora. Converts memledger trace data into the format AgentCore
+evaluators expect.
+
+Since AgentCore CLI requires spans in `aws/spans` CloudWatch log group (which
+uses AgentCore SDK's own instrumentation), this script invokes the evaluator
+API programmatically with our trace data.
+
+Usage:
+    python evaluators/agentcore_eval_runner.py
+"""
+
+import asyncio
+import json
+import os
+import sys
+from datetime import datetime, timezone
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).parent.parent / "src"))
+sys.path.insert(0, str(Path(__file__).parent.parent))
+
+
+async def fetch_memories_from_aurora():
+    """Fetch all memories from Aurora for evaluation."""
+    from memledger import Memledger
+    from memledger.models import EmbeddingConfig
+
+    dsn = os.environ.get("MEMLEDGER_PG_DSN", "")
+    if not dsn:
+        print("MEMLEDGER_PG_DSN not set — using Phoenix data only")
+        return []
+
+    ml = await Memledger.create(
+        backend_name="pgvector",
+        connection_string=dsn,
+        embedding_config=EmbeddingConfig(provider="bedrock", model="amazon.titan-embed-text-v2:0", dimensions=1024),
+    )
+
+    active = await ml.get_by_status("active")
+    deprecated = await ml.get_by_status("deprecated")
+    all_mems = active + deprecated
+    await ml.close()
+
+    return [
+        {
+            "id": m.id,
+            "content": m.content[:200],
+            "record_type": m.record_type.value,
+            "created_by": m.created_by,
+            "confidence": m.confidence,
+            "importance": m.importance,
+            "session_id": m.session_id,
+            "derived_from": m.derived_from,
+            "supersedes": m.supersedes,
+            "hedged": m.hedged,
+            "namespace": m.namespace,
+            "status": m.status.value,
+            "success_count": m.success_count,
+            "failure_count": m.failure_count,
+        }
+        for m in all_mems
+    ]
+
+
+def run_option_a_eval(records: list[dict]) -> dict:
+    """Run Option A (deterministic) evaluator."""
+    from evaluators.attribution_integrity import evaluate_attribution_integrity
+
+    # Group by session
+    sessions = {}
+    for r in records:
+        sid = r.get("session_id", "unknown")
+        sessions.setdefault(sid, []).append(r)
+
+    results = {}
+    for sid, mems in sessions.items():
+        result = evaluate_attribution_integrity(sid, mems)
+        results[sid] = {
+            "score": result.score,
+            "passed": result.passed,
+            "explanation": result.explanation,
+        }
+
+    mean_score = sum(r["score"] for r in results.values()) / len(results) if results else 0
+    return {"evaluator": "Option A (deterministic)", "mean_score": round(mean_score, 4), "sessions": results}
+
+
+def run_option_b_eval(records: list[dict]) -> dict:
+    """Run Option B (structural) evaluator."""
+    from evaluators.attribution_integrity_structural import evaluate_from_memory_records
+
+    sessions = {}
+    for r in records:
+        sid = r.get("session_id", "unknown")
+        sessions.setdefault(sid, []).append(r)
+
+    results = {}
+    for sid, mems in sessions.items():
+        result = evaluate_from_memory_records(mems)
+        results[sid] = {
+            "score": result.score,
+            "passed": result.passed,
+            "explanation": result.explanation,
+        }
+
+    mean_score = sum(r["score"] for r in results.values()) / len(results) if results else 0
+    return {"evaluator": "Option B (structural)", "mean_score": round(mean_score, 4), "sessions": results}
+
+
+def run_agentcore_builtin_eval(records: list[dict]) -> dict:
+    """Run AgentCore built-in evaluators via SDK programmatic API.
+
+    Uses the bedrock-agentcore SDK's evaluate API directly, bypassing
+    the CloudWatch log group requirement.
+    """
+    try:
+        from bedrock_agentcore.evaluations import evaluate, BuiltinEvaluator
+
+        # Format records as AgentCore evaluation input
+        eval_input = {
+            "conversation": [
+                {
+                    "role": "user",
+                    "content": "Assess the memory operations performed by the agent fleet",
+                },
+                {
+                    "role": "assistant",
+                    "content": "\n".join(
+                        f"[{r['created_by'] or 'unknown'}] ({r['record_type']}, conf={r['confidence']:.2f}): {r['content']}"
+                        for r in records[:10]
+                    ),
+                },
+            ],
+        }
+
+        evaluator_names = [
+            "Builtin.Correctness",
+            "Builtin.Coherence",
+            "Builtin.Completeness",
+            "Builtin.Helpfulness",
+        ]
+
+        results = {}
+        for eval_name in evaluator_names:
+            try:
+                result = evaluate(
+                    evaluator_id=eval_name,
+                    conversation=eval_input["conversation"],
+                )
+                results[eval_name] = {
+                    "score": result.get("score", 0),
+                    "explanation": result.get("explanation", ""),
+                }
+            except Exception as e:
+                results[eval_name] = {"score": "N/A", "error": str(e)[:100]}
+
+        return {"evaluator": "AgentCore Built-ins", "results": results}
+
+    except ImportError:
+        return {"evaluator": "AgentCore Built-ins", "error": "SDK not available", "results": {}}
+    except Exception as e:
+        return {"evaluator": "AgentCore Built-ins", "error": str(e)[:200], "results": {}}
+
+
+def main():
+    print("F6 — AgentCore Evaluation Runner")
+    print("=" * 60)
+
+    # Fetch data
+    records = asyncio.run(fetch_memories_from_aurora())
+    if not records:
+        print("No records found. Using calibration dataset as fallback.")
+        from evaluators.calibration.score_agreement import load_dataset
+        examples = load_dataset()
+        records = []
+        for ex in examples:
+            records.extend(ex["retrieved_memories"])
+
+    print(f"Loaded {len(records)} memory records")
+
+    # Run all evaluators
+    print("\n--- Option A (deterministic) ---")
+    a_results = run_option_a_eval(records)
+    print(f"Mean score: {a_results['mean_score']}")
+
+    print("\n--- Option B (structural) ---")
+    b_results = run_option_b_eval(records)
+    print(f"Mean score: {b_results['mean_score']}")
+
+    print("\n--- AgentCore Built-ins ---")
+    ac_results = run_agentcore_builtin_eval(records)
+    if "error" in ac_results:
+        print(f"Error: {ac_results['error']}")
+    else:
+        for name, r in ac_results.get("results", {}).items():
+            print(f"  {name}: {r.get('score', 'N/A')}")
+
+    # Load calibration data
+    cal_path = Path(__file__).parent / "calibration" / "results_summary.json"
+    cal_data = {}
+    if cal_path.exists():
+        with open(cal_path) as f:
+            cal_data = json.load(f)
+
+    # Compile final results
+    final = {
+        "timestamp": datetime.now(timezone.utc).isoformat(),
+        "record_count": len(records),
+        "option_a": a_results,
+        "option_b": b_results,
+        "agentcore_builtins": ac_results,
+        "calibration": cal_data,
+        "position_bias": {
+            "rate": "N/A — deterministic evaluators, no LLM judge calls",
+            "note": "F12 position-bias tracker available for LLM-based conflict resolution",
+        },
+    }
+
+    # Save
+    out_path = Path(__file__).parent / "results" / "f6_complete.json"
+    out_path.parent.mkdir(exist_ok=True)
+    with open(out_path, "w") as f:
+        json.dump(final, f, indent=2)
+
+    print(f"\n{'=' * 60}")
+    print(f"Results saved to {out_path}")
+    print(f"Option A mean: {a_results['mean_score']}")
+    print(f"Option B mean: {b_results['mean_score']}")
+    if cal_data:
+        print(f"Calibration κ (A): {cal_data.get('option_a', {}).get('cohens_kappa', 'N/A')}")
+        print(f"Calibration κ (B): {cal_data.get('option_b', {}).get('cohens_kappa', 'N/A')}")
+
+
+if __name__ == "__main__":
+    main()

evaluators/agentcore_evaluator.py

@@ -0,0 +1,76 @@
+"""AWS Bedrock AgentCore evaluator registration (AWS-only).
+
+Requires the [aws] extra: `pip install memledger[aws]`.
+
+This module is import-safe even without boto3 — the boto3 import is
+deferred to call time so a clean OSS install can still load
+`evaluators.__init__` and use the deterministic and RAGAS tiers.
+"""
+
+from __future__ import annotations
+
+import logging
+import os
+from typing import Optional
+
+logger = logging.getLogger(__name__)
+
+
+def register_agentcore_evaluator(
+    region: Optional[str] = None,
+    model_id: str = "us.anthropic.claude-sonnet-4-5-20250929-v1:0",
+) -> dict:
+    """Register the Memory Attribution Integrity evaluator with AgentCore.
+
+    Region resolution: explicit arg > $AWS_REGION > "us-west-2".
+    Returns the evaluator ARN and registration status.
+    """
+    try:
+        import boto3
+
+        region = region or os.getenv("AWS_REGION", "us-west-2")
+        client = boto3.client("bedrock-agentcore-control", region_name=region)
+
+        evaluator_config = {
+            "evaluatorName": "memory_attribution_integrity",
+            "description": "Scores whether agent decisions rely on well-attributed, confident memory",
+            "level": "TRACE",
+            "evaluatorConfig": {
+                "llmAsAJudge": {
+                    "modelConfig": {
+                        "bedrockEvaluatorModelConfig": {
+                            "modelId": model_id,
+                            "inferenceConfig": {"maxTokens": 500, "temperature": 0.0},
+                        }
+                    },
+                    "ratingScale": {
+                        "numerical": [
+                            {"value": 0.0, "label": "Unattributed", "definition": "Decision relies on memory with no provenance, or on memory with confidence < 0.4 treated as authoritative"},
+                            {"value": 0.5, "label": "Partially attributed", "definition": "Some memories have attribution; low-confidence memories used but decision hedges"},
+                            {"value": 1.0, "label": "Well attributed", "definition": "All retrieved memories have attribution, confidence >= 0.7, OR agent explicitly hedges on lower-confidence data"},
+                        ]
+                    },
+                    "instructions": (
+                        "Given an agent decision and the memories it retrieved, score whether the decision relied on "
+                        "well-attributed, sufficiently confident memory. Score based on: (1) presence of attribution "
+                        "metadata on every retrieved memory, (2) confidence thresholds, (3) consistency of derivation "
+                        "chains, (4) whether contradictory memories were flagged or ignored. "
+                        "Context: {context}. Target to evaluate: {assistant_turn}."
+                    ),
+                }
+            },
+        }
+
+        try:
+            response = client.create_evaluator(**evaluator_config)
+            arn = response.get("evaluatorArn", "")
+        except client.exceptions.ConflictException:
+            response = client.get_evaluator(evaluatorName="memory_attribution_integrity")
+            arn = response.get("evaluatorArn", "")
+
+        return {"arn": arn, "status": "registered"}
+
+    except ImportError:
+        return {"error": "boto3/bedrock-agentcore SDK not installed (install with: pip install memledger[aws])", "status": "skipped"}
+    except Exception as e:
+        return {"error": str(e), "status": "failed"}

evaluators/agentcore_harness.py

@@ -0,0 +1,134 @@
+"""AgentCore Evaluations harness for memory trust evaluation.
+
+Runs the 4 built-in evaluators + custom Memory Attribution Integrity
+against traces in CloudWatch.
+
+Usage:
+    from evaluators.agentcore_harness import run_agentcore_evaluation
+
+    results = await run_agentcore_evaluation(
+        log_group="/aws/otel/memledger",
+        session_id="demo-session-001",
+    )
+"""
+
+from __future__ import annotations
+import json
+import logging
+import os
+from pathlib import Path
+from typing import Any
+
+logger = logging.getLogger(__name__)
+
+
+async def run_agentcore_evaluation(
+    log_group: str = "/aws/otel/memledger",
+    session_id: str = "demo-session-001",
+    region: str | None = None,
+    builtin_evaluators: list[str] | None = None,
+    custom_evaluator_arn: str | None = None,
+) -> dict[str, Any]:
+    """Run AgentCore Evaluations against CloudWatch traces.
+
+    Args:
+        log_group: CloudWatch log group with OTEL traces
+        session_id: Session to evaluate
+        region: AWS region
+        builtin_evaluators: List of Builtin.* evaluator names
+        custom_evaluator_arn: ARN of the custom evaluator (from register_agentcore_evaluator)
+
+    Returns:
+        {evaluator_name: score, ...}
+    """
+    if builtin_evaluators is None:
+        builtin_evaluators = [
+            "Builtin.GoalSuccessRate",
+            "Builtin.Correctness",
+            "Builtin.ToolSelectionAccuracy",
+            "Builtin.ContextRelevance",
+        ]
+
+    try:
+        import boto3
+        region = region or os.getenv("AWS_REGION", "us-west-2")
+        client = boto3.client("bedrock-agentcore-control", region_name=region)
+
+        # Build evaluator list
+        evaluators = [{"evaluatorId": e} for e in builtin_evaluators]
+        if custom_evaluator_arn:
+            evaluators.append({"evaluatorId": custom_evaluator_arn})
+
+        # Create online evaluation config
+        eval_config = {
+            "evaluationConfigName": f"memledger-eval-{session_id[:20]}",
+            "evaluationDataSource": {
+                "cloudWatchLogGroup": {
+                    "logGroupName": log_group,
+                }
+            },
+            "evaluators": evaluators,
+        }
+
+        try:
+            response = client.create_online_evaluation_config(**eval_config)
+            config_arn = response.get("evaluationConfigArn", "")
+            logger.info("Created AgentCore eval config: %s", config_arn)
+        except Exception as e:
+            logger.warning("Failed to create eval config: %s", e)
+            config_arn = ""
+
+        # Note: AgentCore Evaluations runs asynchronously.
+        # Results appear in CloudWatch after 2-5 minutes.
+        # For the demo, we'll pre-run and screenshot results.
+
+        return {
+            "status": "configured",
+            "config_arn": config_arn,
+            "evaluators": [e["evaluatorId"] for e in evaluators],
+            "log_group": log_group,
+            "session_id": session_id,
+            "note": "Results will appear in CloudWatch after 2-5 minutes. Pre-capture screenshots for demo.",
+        }
+
+    except ImportError:
+        return {"status": "skipped", "reason": "bedrock-agentcore SDK not installed"}
+    except Exception as e:
+        return {"status": "error", "error": str(e)}
+
+
+def get_evaluation_results(
+    session_id: str,
+    log_group: str = "/aws/otel/memledger",
+    region: str | None = None,
+) -> dict[str, Any]:
+    """Query CloudWatch for evaluation results.
+
+    Region resolution: explicit arg > $AWS_REGION > "us-west-2".
+    Call this 5+ minutes after running the evaluation.
+    """
+    try:
+        import boto3
+        region = region or os.getenv("AWS_REGION", "us-west-2")
+        client = boto3.client("logs", region_name=region)
+
+        # Query for evaluation results
+        response = client.filter_log_events(
+            logGroupName=log_group,
+            filterPattern=f'"evaluation" "{session_id}"',
+            limit=50,
+        )
+
+        results = {}
+        for event in response.get("events", []):
+            try:
+                data = json.loads(event["message"])
+                if "evaluator" in data and "score" in data:
+                    results[data["evaluator"]] = data["score"]
+            except (json.JSONDecodeError, KeyError):
+                continue
+
+        return {"session_id": session_id, "results": results, "raw_events": len(response.get("events", []))}
+
+    except Exception as e:
+        return {"error": str(e)}

evaluators/attribution_integrity.py

@@ -0,0 +1,191 @@
+"""Memory Attribution Integrity Evaluator.
+
+Scores 0.0-1.0: Did the agent's decision rely on well-attributed,
+sufficiently confident memory?
+
+Can run as:
+1. A DeepEval G-Eval evaluator (LLM-as-judge)
+2. A deterministic rule-based evaluator (no LLM needed)
+3. An AgentCore custom evaluator (when available)
+
+Score 1.0 when:
+- Retrieved memories have attribution (source agent, confidence, session)
+- Memory confidence >= 0.7 OR decision explicitly hedges on low-confidence data
+- No memories in chain with confidence < 0.4 used as basis for decision
+- Derivation chains are present and consistent
+
+Score 0.0 when:
+- Decision uses unattributed or low-confidence memory as ground truth
+- Contradictory memories ignored
+- Memory without session/turn context treated as authoritative
+"""
+
+from __future__ import annotations
+from dataclasses import dataclass, field
+from typing import Any, Optional
+import logging
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class AttributionIntegrityResult:
+    """Result of a memory attribution integrity evaluation."""
+    score: float                    # 0.0-1.0
+    passed: bool                    # score >= threshold
+    threshold: float = 0.7
+    details: dict = field(default_factory=dict)
+    explanation: str = ""
+
+
+def evaluate_attribution_integrity(
+    decision_memory_id: str,
+    retrieved_memories: list[dict],  # Each: {id, content, created_by, importance, derived_from, session_id, ...}
+    chain: Optional[dict] = None,   # Attribution chain from get_attribution_chain()
+    threshold: float = 0.7,
+) -> AttributionIntegrityResult:
+    """Evaluate whether a decision was based on well-attributed memory.
+
+    Deterministic scoring — no LLM needed. Each criterion adds or subtracts
+    from the score.
+
+    Args:
+        decision_memory_id: The memory that represents the agent's decision
+        retrieved_memories: Memories that were retrieved before the decision
+        chain: Attribution chain for the decision memory
+        threshold: Minimum score to pass (default 0.7)
+    """
+    score = 1.0
+    penalties = []
+    bonuses = []
+
+    if not retrieved_memories:
+        return AttributionIntegrityResult(
+            score=0.0,
+            passed=False,
+            threshold=threshold,
+            details={"error": "no_retrieved_memories"},
+            explanation="No retrieved memories to evaluate.",
+        )
+
+    # Helper: read confidence from either 'confidence' or 'importance' field
+    def _conf(m: dict) -> float:
+        return m.get("confidence", m.get("importance", 0.5)) or 0.5
+
+    # Criterion 1: Attribution completeness (do memories have source agent?)
+    attributed_count = sum(1 for m in retrieved_memories if m.get("created_by"))
+    attribution_ratio = attributed_count / len(retrieved_memories)
+    if attribution_ratio < 1.0:
+        penalty = (1.0 - attribution_ratio) * 0.4
+        score -= penalty
+        penalties.append(f"Attribution gap: {attributed_count}/{len(retrieved_memories)} have source agent (-{penalty:.2f})")
+    else:
+        bonuses.append("All retrieved memories have source attribution")
+
+    # Criterion 2: Confidence levels
+    confidences = [_conf(m) for m in retrieved_memories]
+    mean_conf = sum(confidences) / len(confidences)
+
+    # 2a: Low-confidence memories (< 0.4) used without hedging
+    low_conf_unhedged = sum(
+        1 for m in retrieved_memories
+        if _conf(m) < 0.4 and not m.get("hedged", False)
+    )
+    if low_conf_unhedged > 0:
+        penalty = low_conf_unhedged * 0.25
+        score -= penalty
+        penalties.append(f"Low-confidence unhedged: {low_conf_unhedged} below 0.4 (-{penalty:.2f})")
+
+    # 2b: Flagged-confidence (0.4-0.6) without hedging
+    flagged_unhedged = sum(
+        1 for m in retrieved_memories
+        if 0.4 <= _conf(m) < 0.6 and not m.get("hedged", False)
+    )
+    if flagged_unhedged > 0:
+        penalty = flagged_unhedged * 0.1
+        score -= penalty
+        penalties.append(f"Flagged-confidence unhedged: {flagged_unhedged} in 0.4-0.6 (-{penalty:.2f})")
+
+    # 2c: Mean confidence penalty
+    if mean_conf < 0.6:
+        penalty = (0.6 - mean_conf) * 0.5
+        score -= penalty
+        penalties.append(f"Low mean confidence: {mean_conf:.2f} (-{penalty:.2f})")
+
+    # Criterion 3: Session context
+    session_count = sum(1 for m in retrieved_memories if m.get("session_id"))
+    session_ratio = session_count / len(retrieved_memories)
+    if session_ratio < 0.5:
+        penalty = (1.0 - session_ratio) * 0.15
+        score -= penalty
+        penalties.append(f"Weak session context: {session_count}/{len(retrieved_memories)} have session IDs (-{penalty:.2f})")
+
+    # Criterion 4: Chain integrity (if chain provided, check for gaps)
+    if chain:
+        chain_hops = chain.get("chain", [])
+        if chain_hops:
+            min_chain_conf = chain.get("min_confidence", 1.0)
+            if min_chain_conf < 0.4:
+                penalty = 0.2
+                score -= penalty
+                penalties.append(f"Chain contains low-confidence hop (min={min_chain_conf:.2f}) (-{penalty:.2f})")
+
+            if chain.get("truncated"):
+                penalty = 0.05
+                score -= penalty
+                penalties.append(f"Chain truncated (depth > max_hops) (-{penalty:.2f})")
+        else:
+            bonuses.append("No derivation chain (original memory)")
+
+    # Criterion 5: Diversity of sources (multiple agents = more trustworthy)
+    unique_agents = set(m.get("created_by", "") for m in retrieved_memories if m.get("created_by"))
+    if len(unique_agents) >= 2:
+        bonus = 0.05
+        score += bonus
+        bonuses.append(f"Multi-agent corroboration: {len(unique_agents)} agents (+{bonus:.2f})")
+
+    # Clamp score
+    score = max(0.0, min(1.0, score))
+
+    explanation_parts = []
+    if bonuses:
+        explanation_parts.append("Strengths: " + "; ".join(bonuses))
+    if penalties:
+        explanation_parts.append("Issues: " + "; ".join(penalties))
+
+    result = AttributionIntegrityResult(
+        score=round(score, 4),
+        passed=score >= threshold,
+        threshold=threshold,
+        details={
+            "attributed_ratio": attribution_ratio,
+            "low_confidence_unhedged": low_conf_unhedged,
+            "mean_confidence": round(mean_conf, 4),
+            "session_context_ratio": session_ratio,
+            "unique_agents": len(unique_agents),
+            "chain_min_confidence": chain.get("min_confidence") if chain else None,
+            "penalties": penalties,
+            "bonuses": bonuses,
+        },
+        explanation=". ".join(explanation_parts) if explanation_parts else "No issues detected.",
+    )
+
+    # Best-effort: push to Phoenix as an annotation on the current OTEL span.
+    # No-op if [eval] extra not installed or PHOENIX_BASE_URL / OTEL endpoint unset.
+    try:
+        from memledger.telemetry.phoenix import log_evaluation
+        log_evaluation(
+            name="memory_attribution_integrity",
+            score=result.score,
+            label="passed" if result.passed else "failed",
+            explanation=result.explanation[:500],
+            annotator_kind="CODE",
+        )
+    except Exception:
+        pass
+
+    return result
+
+
+# AgentCore evaluator registration moved to evaluators/agentcore_evaluator.py
+# (it's the only AWS-coupled piece; keeping this file pure-OSS / pure-stdlib).