Blame for cases/api_reliability/adapter.py

"""Narrow, auditable adapter for the API reliability recovery slice."""

from __future__ import annotations

import copy
import hashlib
import json
from typing import Any

try:
    from .recovery_policy import (
        FAILURE_SIGNALS,
        OPERATION_CLASSES,
        RECOVERY_PROFILES,
        RECOVERY_RULE_CELLS,
        required_recovery_profile,
    )
except ImportError:  # Direct CLI execution from the case directory.
    from recovery_policy import (  # type: ignore
        FAILURE_SIGNALS,
        OPERATION_CLASSES,
        RECOVERY_PROFILES,
        RECOVERY_RULE_CELLS,
        required_recovery_profile,
    )


ROLE = "api_reliability_operator"
REFERENCE_NOW = "2026-05-20T12:00:00Z"
LIMIT_SCHEMA = {"type": "integer", "minimum": 1, "maximum": 100, "default": 25}
OFFSET_SCHEMA = {"type": "integer", "minimum": 0, "maximum": 1_000_000, "default": 0}

PUBLIC_TOOLS = [
    {
        "name": "list_service_integrations",
        "description": "List provider integrations with bounded business filters.",
        "input_schema": {
            "type": "object",
            "properties": {
                "provider_type": {"type": "string"},
                "status": {"type": "string"},
                "limit": LIMIT_SCHEMA,
                "offset": OFFSET_SCHEMA,
            },
            "required": [],
            "additionalProperties": False,
        },
    },
    {
        "name": "list_api_credentials",
        "description": "List credentials by integration, lifecycle state, and operation scope.",
        "input_schema": {
            "type": "object",
            "properties": {
                "integration_id": {"type": "string"},
                "status": {"type": "string"},
                "scope_contains": {"type": "string"},
                "limit": LIMIT_SCHEMA,
                "offset": OFFSET_SCHEMA,
            },
            "required": [],
            "additionalProperties": False,
        },
    },
    {
        "name": "list_retry_budgets",
        "description": "List retry-budget windows and their current capacity.",
        "input_schema": {
            "type": "object",
            "properties": {
                "integration_id": {"type": "string"},
                "status": {"type": "string"},
                "window_minutes": {"type": "integer", "minimum": 1, "maximum": 1440},
                "limit": LIMIT_SCHEMA,
                "offset": OFFSET_SCHEMA,
            },
            "required": [],
            "additionalProperties": False,
        },
    },
    {
        "name": "inspect_rate_limit_status",
        "description": "Inspect rate capacity for one integration and optional operation.",
        "input_schema": {
            "type": "object",
            "properties": {
                "integration_id": {"type": "string"},
                "operation": {"type": "string"},
                "requested_units": {"type": "integer", "minimum": 1, "maximum": 100, "default": 1},
            },
            "required": ["integration_id"],
            "additionalProperties": False,
        },
    },
    {
        "name": "list_fault_policies",
        "description": "List observed fault conditions for an integration operation.",
        "input_schema": {
            "type": "object",
            "properties": {
                "integration_id": {"type": "string"},
                "enabled": {"type": "boolean"},
                "operation": {"type": "string"},
                "limit": LIMIT_SCHEMA,
                "offset": OFFSET_SCHEMA,
            },
            "required": [],
            "additionalProperties": False,
        },
    },
    {
        "name": "search_recovery_evidence",
        "description": "Search archived successful recovery evidence by observed failure signal and operation class.",
        "input_schema": {
            "type": "object",
            "properties": {
                "failure_signal": {"type": "string", "enum": list(FAILURE_SIGNALS)},
                "operation_class": {"type": "string", "enum": list(OPERATION_CLASSES)},
                "limit": {"type": "integer", "minimum": 1, "maximum": 16, "default": 16},
                "offset": {"type": "integer", "minimum": 0, "maximum": 16, "default": 0},
            },
            "required": [],
            "additionalProperties": False,
        },
    },
    {
        "name": "search_audit_events",
        "description": "Search bounded call and recovery audit history.",
        "input_schema": {
            "type": "object",
            "properties": {
                "integration_id": {"type": "string"},
                "related_call_id": {"type": "string"},
                "limit": LIMIT_SCHEMA,
                "offset": OFFSET_SCHEMA,
            },
            "required": [],
            "additionalProperties": False,
        },
    },
    {
        "name": "execute_api_call",
        "description": "Execute one metered provider request with an explicit idempotency key.",
        "input_schema": {
            "type": "object",
            "properties": {
                "integration_id": {"type": "string"},
                "credential_id": {"type": "string"},
                "operation": {"type": "string"},
                "request_fingerprint": {"type": "string"},
                "idempotency_key": {"type": "string"},
                "retry_budget_id": {"type": "string"},
                "rate_limit_bucket_id": {"type": "string"},
                "fault_policy_id": {"type": "string"},
            },
            "required": ["integration_id", "credential_id", "operation", "request_fingerprint", "idempotency_key"],
            "additionalProperties": False,
        },
    },
    {
        "name": "retry_api_call",
        "description": "Retry one source call using explicit current credential, retry-budget, and rate-bucket bindings.",
        "input_schema": {
            "type": "object",
            "properties": {
                "call_id": {"type": "string"},
                "credential_id": {"type": "string"},
                "retry_budget_id": {"type": "string"},
                "rate_limit_bucket_id": {"type": "string"},
                "recovery_profile_id": {"type": "string", "enum": list(RECOVERY_PROFILES)},
                "incident_id": {"type": "string"},
            },
            "required": [
                "call_id",
                "credential_id",
                "retry_budget_id",
                "rate_limit_bucket_id",
                "recovery_profile_id",
            ],
            "additionalProperties": False,
        },
    },
]

TOOL_SCHEMAS = {item["name"]: item["input_schema"] for item in PUBLIC_TOOLS}
ALLOWED_TOOLS = frozenset(TOOL_SCHEMAS)
PAGED_READ_TOOLS = {
    "list_service_integrations",
    "list_api_credentials",
    "list_retry_budgets",
    "list_fault_policies",
    "search_audit_events",
}
WRITE_COST = {"execute_api_call": 8, "retry_api_call": 10}
RETRYABLE_STATUSES = {"transient_error", "rate_limited", "timeout", "queued"}


def _canonical(value: Any) -> str:
    return json.dumps(value, sort_keys=True, separators=(",", ":"), ensure_ascii=True)


def _matches_type(value: Any, expected: str) -> bool:
    if expected == "boolean":
        return isinstance(value, bool)
    if expected == "integer":
        return isinstance(value, int) and not isinstance(value, bool)
    if expected == "number":
        return isinstance(value, (int, float)) and not isinstance(value, bool)
    if expected == "string":
        return isinstance(value, str)
    return True


def _validate_arguments(tool: str, arguments: Any) -> str | None:
    if not isinstance(arguments, dict):
        return "arguments must be an object"
    schema = TOOL_SCHEMAS[tool]
    properties = schema["properties"]
    unknown = sorted(set(arguments) - set(properties))
    if unknown:
        return f"unsupported argument(s): {', '.join(unknown)}"
    missing = [name for name in schema.get("required", []) if name not in arguments]
    if missing:
        return f"missing required argument(s): {', '.join(missing)}"
    for name, value in arguments.items():
        field = properties[name]
        if not _matches_type(value, field["type"]):
            return f"{name} must be {field['type']}"
        if field["type"] == "string" and not value.strip():
            return f"{name} must be non-empty"
        if "enum" in field and value not in field["enum"]:
            return f"{name} must be one of: {', '.join(str(item) for item in field['enum'])}"
        if "minimum" in field and value < field["minimum"]:
            return f"{name} must be at least {field['minimum']}"
        if "maximum" in field and value > field["maximum"]:
            return f"{name} must be at most {field['maximum']}"
    return None


def _bounded_work_value(arguments: Any, name: str, default: int, minimum: int, maximum: int) -> int:
    if not isinstance(arguments, dict):
        return default
    value = arguments.get(name, default)
    if not isinstance(value, int) or isinstance(value, bool) or not minimum <= value <= maximum:
        return default
    return value


def _sanitize_raw_result(tool: str, result: Any) -> dict[str, Any]:
    if not isinstance(result, dict) or not isinstance(result.get("content"), dict):
        return {
            "type": "tool_result",
            "tool": tool,
            "content": {"status": "error", "data": {}, "message": "UPSTREAM_TOOL_ERROR: invalid raw response"},
        }
    content = result["content"]
    if content.get("status") != "error":
        return result
    message = str(content.get("message") or "UPSTREAM_TOOL_ERROR: raw tool failed")
    if message.startswith("TOOL_EXECUTION_ERROR") or "traceback" in message.lower():
        message = "UPSTREAM_TOOL_ERROR: raw tool execution failed"
    return {
        "type": "tool_result",
        "tool": tool,
        "content": {"status": "error", "data": {}, "message": message},
    }


class ApiReliabilityAdapter:
    """Enforces role, schema, quota, idempotency, and retry conservation."""



    def close(self) -> None:
        self.server.cleanup_runtime()

    def public_tool_schemas(self, actor: str = ROLE) -> list[dict[str, Any]]:
        return copy.deepcopy(PUBLIC_TOOLS) if actor == ROLE else []

    def _cost(self, tool: str, arguments: Any) -> int:
        if tool == "search_recovery_evidence":
            return 16 + _bounded_work_value(arguments, "limit", 16, 1, 16)
        if tool in PAGED_READ_TOOLS:
            return 2 + _bounded_work_value(arguments, "limit", 25, 1, 100)
        if tool == "inspect_rate_limit_status":
            return 3
        return WRITE_COST[tool]

    def _search_recovery_evidence(self, arguments: dict[str, Any]) -> dict[str, Any]:
        rows = RECOVERY_RULE_CELLS
        failure_signal = arguments.get("failure_signal")
        operation_class = arguments.get("operation_class")
        if failure_signal:
            rows = [row for row in rows if row["failure_signal"] == failure_signal]
        if operation_class:
            rows = [row for row in rows if row["operation_class"] == operation_class]
        offset = int(arguments.get("offset", 0))
        limit = int(arguments.get("limit", 16))
        page = rows[offset : offset + limit]
        return self._success(
            "search_recovery_evidence",
            {
                "total_count": len(rows),
                "offset": offset,
                "limit": limit,
                "evidence": copy.deepcopy(page),
            },
            "Archived recovery evidence searched",
        )

    def _error(self, tool: str, code: str, message: str, cost: int = 0) -> dict[str, Any]:
        return {
            "type": "tool_result",
            "tool": tool,
            "content": {"status": "error", "data": {}, "message": f"{code}: {message}"},
            "budget": {"charged": cost, "remaining": self.remaining},
        }

    def _success(self, tool: str, data: dict[str, Any], message: str) -> dict[str, Any]:
        return {
            "type": "tool_result",
            "tool": tool,
            "content": {"status": "success", "data": data, "message": message},
        }

    def _record_receipt(
        self,
        tool: str,
        arguments: dict[str, Any],
        status: str,
        cost: int,
        before_hash: str,
    ) -> int:
        receipt = {
            "index": len(self.receipts) + 1,
            "task_id": self.active_task_id,
            "tool": tool,
            "actor": ROLE,
            "arguments": copy.deepcopy(arguments),
            "status": status,
            "cost": cost,
            "before_hash": before_hash,
            "after_business_hash": self.business_hash(),
        }
        self.receipts.append(receipt)
        return receipt["index"]

    def _finish(
        self,
        tool: str,
        arguments: dict[str, Any],
        result: dict[str, Any],
        cost: int,
        before_hash: str,
    ) -> dict[str, Any]:
        index = self._record_receipt(
            tool,
            arguments,
            result.get("content", {}).get("status", "error"),
            cost,
            before_hash,
        )
        result["budget"] = {"charged": cost, "remaining": self.remaining}
        result["receipt_index"] = index
        return result

    def _restore_database(self, database: dict[str, Any], counters: dict[str, Any]) -> None:
        self.manager.db._data = copy.deepcopy(database)
        for entity_type in database:
            self.manager.db._flush(entity_type)
        self.manager._counters = copy.deepcopy(counters)

    def _idempotency_guard(self, arguments: dict[str, Any]) -> dict[str, Any] | None:
        matches = self.manager.query_entities(
            "idempotency_key",
            lambda row: row.get("integration_id") == arguments["integration_id"]
            and row.get("operation") == arguments["operation"]
            and row.get("key") == arguments["idempotency_key"],
        )
        if not matches:
            return None
        key = matches[0]
        if key.get("request_fingerprint") != arguments["request_fingerprint"]:
            return self._error("execute_api_call", "IDEMPOTENCY_CONFLICT", "the key is bound to a different request fingerprint")
        associated = self.manager.get_entity(
            "api_call_attempt", key.get("associated_call_id", ""), id_field="call_id"
        )
        if key.get("status") == "consumed" and associated and associated.get("side_effect_committed"):
            return self._success(
                "execute_api_call",
                {
                    "call_id": associated["call_id"],
                    "status": associated.get("status"),
                    "side_effect_committed": True,
                    "idempotency_id": key.get("idempotency_id"),
                    "idempotent_replay": True,
                },
                "Existing committed result returned without another provider call",
            )
        if key.get("status") == "consumed":
            return self._error(
                "execute_api_call",
                "IDEMPOTENCY_ALREADY_CONSUMED",
                "the original call must be recovered through its retry path",
            )
        if key.get("status") == "conflicted":
            return self._error("execute_api_call", "IDEMPOTENCY_CONFLICT", "the key is already conflicted")
        return None

    def _execute_context_guard(self, arguments: dict[str, Any]) -> dict[str, Any] | None:
        integration = self.manager.get_entity(
            "service_integration", arguments["integration_id"], id_field="integration_id"
        )
        if integration is None:
            return self._error("execute_api_call", "INTEGRATION_NOT_FOUND", "integration does not exist")
        if integration.get("status") == "paused":
            return self._error("execute_api_call", "INTEGRATION_PAUSED", "integration is paused")
        credential = self.manager.get_entity(
            "api_credential", arguments["credential_id"], id_field="credential_id"
        )
        if credential is None:
            return self._error("execute_api_call", "CREDENTIAL_NOT_FOUND", "credential does not exist")
        if credential.get("integration_id") != arguments["integration_id"]:
            return self._error("execute_api_call", "ENTITY_SCOPE_MISMATCH", "credential belongs to another integration")
        if credential.get("status") not in {"active", "rotating"}:
            return self._error("execute_api_call", "CREDENTIAL_NOT_USABLE", "credential is not currently usable")
        if arguments["operation"] not in (credential.get("scope") or []):
            return self._error("execute_api_call", "SCOPE_NOT_ALLOWED", "credential scope excludes the operation")
        return None

    def _retry_guard(self, arguments: dict[str, Any]) -> tuple[dict[str, Any] | None, dict[str, Any] | None]:
        source = self.manager.get_entity("api_call_attempt", arguments["call_id"], id_field="call_id")
        if source is None:
            return None, self._error("retry_api_call", "CALL_NOT_FOUND", "source call does not exist")
        if source.get("status") not in RETRYABLE_STATUSES:
            return None, self._error("retry_api_call", "CALL_NOT_RETRYABLE", "source call status is not retryable")
        if int(source.get("retry_attempt") or 0) >= int(source.get("max_retry_attempts") or 0):
            return None, self._error("retry_api_call", "RETRY_LIMIT_REACHED", "source call has no retry attempts remaining")

        prior = self.manager.query_entities(
            "api_call_attempt",
            lambda row: row.get("duplicate_of_call_id") == source.get("call_id")
            and row.get("side_effect_committed") is True,
        )
        if prior:
            prior.sort(key=lambda row: row.get("call_id") or "")
            return source, self._success(
                "retry_api_call",
                {
                    "source_call_id": source["call_id"],
                    "retry_call_id": prior[0]["call_id"],
                    "status": prior[0].get("status"),
                    "side_effect_committed": True,
                    "idempotent_replay": True,
                },
                "Existing committed recovery returned without another provider call",
            )

        if arguments["recovery_profile_id"] != required_recovery_profile(source):
            return None, self._error(
                "retry_api_call",
                "RECOVERY_PROFILE_MISMATCH",
                "the selected recovery profile is not valid for the observed failure and operation class",
            )

        credential = self.manager.get_entity("api_credential", arguments["credential_id"], id_field="credential_id")
        if credential is None:
            return None, self._error("retry_api_call", "CREDENTIAL_NOT_FOUND", "credential does not exist")
        if credential.get("integration_id") != source.get("integration_id"):
            return None, self._error("retry_api_call", "ENTITY_SCOPE_MISMATCH", "credential belongs to another integration")
        if credential.get("status") not in {"active", "rotating"}:
            return None, self._error("retry_api_call", "CREDENTIAL_NOT_USABLE", "credential is not currently usable")
        if source.get("operation") not in (credential.get("scope") or []):
            return None, self._error("retry_api_call", "SCOPE_NOT_ALLOWED", "credential scope excludes the source operation")

        budget = self.manager.get_entity("retry_budget", arguments["retry_budget_id"], id_field="budget_id")
        if budget is None:
            return None, self._error("retry_api_call", "BUDGET_NOT_FOUND", "retry budget does not exist")
        if budget.get("integration_id") != source.get("integration_id"):
            return None, self._error("retry_api_call", "ENTITY_SCOPE_MISMATCH", "retry budget belongs to another integration")
        available = int(budget.get("max_attempts") or 0) - int(budget.get("used_attempts") or 0) - int(budget.get("reserved_attempts") or 0)
        if budget.get("status") != "open" or available < 1:
            return None, self._error("retry_api_call", "RETRY_BUDGET_EXHAUSTED", "retry budget lacks capacity")

        bucket = self.manager.get_entity("rate_limit_bucket", arguments["rate_limit_bucket_id"], id_field="bucket_id")
        if bucket is None:
            return None, self._error("retry_api_call", "RATE_BUCKET_NOT_FOUND", "rate bucket does not exist")
        if bucket.get("integration_id") != source.get("integration_id") or bucket.get("operation") != source.get("operation"):
            return None, self._error("retry_api_call", "ENTITY_SCOPE_MISMATCH", "rate bucket does not match source integration and operation")
        if bucket.get("status") == "disabled" or int(bucket.get("remaining") or 0) < 1:
            return None, self._error("retry_api_call", "RATE_LIMIT_EXCEEDED", "rate bucket lacks capacity")
        incident_id = arguments.get("incident_id")
        if incident_id:
            incident = self.manager.get_entity("incident_window", incident_id, id_field="incident_id")
            if incident is None:
                return None, self._error("retry_api_call", "INCIDENT_NOT_FOUND", "incident does not exist")
            if incident.get("integration_id") != source.get("integration_id"):
                return None, self._error("retry_api_call", "INCIDENT_SCOPE_MISMATCH", "incident belongs to another integration")
        return source, None

    def _execute_retry(self, source: dict[str, Any], arguments: dict[str, Any]) -> dict[str, Any]:
        credential = self.manager.get_entity("api_credential", arguments["credential_id"], id_field="credential_id")
        budget = self.manager.get_entity("retry_budget", arguments["retry_budget_id"], id_field="budget_id")
        bucket = self.manager.get_entity("rate_limit_bucket", arguments["rate_limit_bucket_id"], id_field="bucket_id")
        assert credential is not None and budget is not None and bucket is not None

        raw_snapshot = self.manager.snapshot()
        try:
            budget["used_attempts"] = int(budget.get("used_attempts") or 0) + 1
            available = int(budget.get("max_attempts") or 0) - budget["used_attempts"] - int(budget.get("reserved_attempts") or 0)
            if available <= 0:
                budget["status"] = "exhausted"
            budget["updated_at"] = REFERENCE_NOW
            self.manager.add_entity("retry_budget", budget, id_field="budget_id")

            bucket["remaining"] = int(bucket.get("remaining") or 0) - 1
            if bucket["remaining"] == 0:
                bucket["status"] = "exhausted"
            bucket["updated_at"] = REFERENCE_NOW
            self.manager.add_entity("rate_limit_bucket", bucket, id_field="bucket_id")

            digest = hashlib.sha256(
                f"{source['call_id']}|{len(self.manager.list_entities('api_call_attempt'))}".encode("utf-8")
            ).hexdigest()[:12]
            retry_call_id = f"adapter-retry-{digest}"
            retry_call = copy.deepcopy(source)
            retry_call.update(
                {
                    "call_id": retry_call_id,
                    "credential_id": credential["credential_id"],
                    "retry_budget_id": budget["budget_id"],
                    "rate_limit_bucket_id": bucket["bucket_id"],
                    "recovery_profile_id": arguments["recovery_profile_id"],
                    "retry_attempt": int(source.get("retry_attempt") or 0) + 1,
                    "status": "success",
                    "http_status": 200,
                    "error_code": None,
                    "created_at": REFERENCE_NOW,
                    "completed_at": REFERENCE_NOW,
                    "updated_at": REFERENCE_NOW,
                    "side_effect_committed": True,
                    "duplicate_of_call_id": source["call_id"],
                    "incident_id": arguments.get("incident_id"),
                }
            )
            self.manager.add_entity("api_call_attempt", retry_call, id_field="call_id")

            audit_digest = hashlib.sha256(f"{retry_call_id}|audit".encode("utf-8")).hexdigest()[:12]
            audit_id = f"adapter-audit-{audit_digest}"
            self.manager.add_entity(
                "audit_event",
                {
                    "audit_id": audit_id,
                    "entity_type": "ApiCallAttempt",
                    "entity_id": retry_call_id,
                    "integration_id": source.get("integration_id"),
                    "actor": ROLE,
                    "action": "api_call_retried",
                    "outcome": "success",
                    "reason": "Bounded adapter retry",
                    "related_call_id": retry_call_id,
                    "incident_id": arguments.get("incident_id"),
                    "created_at": REFERENCE_NOW,
                    "metadata": {
                        "source_call_id": source["call_id"],
                        "operation": source.get("operation"),
                        "request_fingerprint": source.get("request_hash"),
                        "recovery_profile_id": arguments["recovery_profile_id"],
                    },
                },
                id_field="audit_id",
            )
        except Exception:
            self._restore_database(raw_snapshot["database"], raw_snapshot.get("counters", {}))
            return self._error("retry_api_call", "ATOMIC_RETRY_FAILED", "retry transaction was rolled back")

        return self._success(
            "retry_api_call",
            {
                "source_call_id": source["call_id"],
                "retry_call_id": retry_call_id,
                "status": "success",
                "retry_attempt": retry_call["retry_attempt"],
                "side_effect_committed": True,
                "credential_id": credential["credential_id"],
                "retry_budget_id": budget["budget_id"],
                "rate_limit_bucket_id": bucket["bucket_id"],
                "recovery_profile_id": arguments["recovery_profile_id"],
                "rate_limit_remaining": bucket["remaining"],
                "retry_budget_available": available,
                "audit_id": audit_id,
            },
            "Retry call executed",
        )

    def dispatch(self, tool: str, arguments: Any, actor: str = ROLE) -> dict[str, Any]:
        if actor != ROLE:
            return self._error(tool, "ROLE_FORBIDDEN", "actor is not an API reliability operator")
        if tool not in ALLOWED_TOOLS:
            return self._error(tool, "TOOL_FORBIDDEN", "tool is outside the reliability recovery slice")
        cost = self._cost(tool, arguments)
        if self.remaining < cost:
            return self._error(tool, "WORK_QUOTA_EXHAUSTED", "insufficient API-work quota")
        validation_error = _validate_arguments(tool, arguments)
        if validation_error is not None:
            self.remaining -= cost
            return self._error(tool, "INVALID_ARGUMENTS", validation_error, cost)

        before_hash = self.business_hash()
        self.remaining -= cost
        if tool == "execute_api_call":
            guarded = self._execute_context_guard(arguments)
            if guarded is None:
                guarded = self._idempotency_guard(arguments)
            if guarded is not None:
                return self._finish(tool, arguments, guarded, cost, before_hash)
            raw_snapshot = self.manager.snapshot()
            result = _sanitize_raw_result(tool, self.server.call_tool(tool, state_manager=self.manager, **arguments))
            if result["content"]["status"] == "error" and self.business_hash() != before_hash:
                self._restore_database(raw_snapshot["database"], raw_snapshot.get("counters", {}))
                result = self._error(tool, "ATOMIC_CALL_FAILED", "failed provider call mutation was rolled back")
            return self._finish(tool, arguments, result, cost, before_hash)
        if tool == "retry_api_call":
            source, guarded = self._retry_guard(arguments)
            result = guarded if guarded is not None else self._execute_retry(source, arguments)
            return self._finish(tool, arguments, result, cost, before_hash)
        if tool == "search_recovery_evidence":
            return self._finish(
                tool,
                arguments,
                self._search_recovery_evidence(arguments),
                cost,
                before_hash,
            )

        result = _sanitize_raw_result(tool, self.server.call_tool(tool, state_manager=self.manager, **arguments))
        return self._finish(tool, arguments, result, cost, before_hash)

    def snapshot(self) -> dict[str, Any]:
        return {
            "raw": copy.deepcopy(self.manager.snapshot()),
            "remaining": self.remaining,
            "receipts": copy.deepcopy(self.receipts),
            "applied_boundary_events": sorted(self.applied_boundary_events),
            "active_task_id": self.active_task_id,
        }

    def restore(self, snapshot: dict[str, Any]) -> None:
        self._restore_database(snapshot["raw"]["database"], snapshot["raw"].get("counters", {}))
        self.remaining = int(snapshot["remaining"])
        self.receipts = copy.deepcopy(snapshot["receipts"])
        self.applied_boundary_events = set(snapshot.get("applied_boundary_events", []))
        self.active_task_id = snapshot.get("active_task_id")

    def semantic_hash(self) -> str:
        payload = {
            "database": self.manager.snapshot()["database"],
            "remaining": self.remaining,
            "receipts": self.receipts,
            "boundary_events": sorted(self.applied_boundary_events),
            "active_task_id": self.active_task_id,
        }
        return hashlib.sha256(_canonical(payload).encode("utf-8")).hexdigest()

    def business_hash(self) -> str:
        return hashlib.sha256(
            _canonical(self.manager.snapshot()["database"]).encode("utf-8")
        ).hexdigest()

    def activate_task(self, task_id: str, allowance: int = 56) -> dict[str, Any]:
        if not isinstance(task_id, str) or not task_id:
            raise ValueError("task_id must be non-empty")
        self.active_task_id = task_id
        self.initial_budget = int(allowance)
        self.remaining = int(allowance)
        return {"task_id": task_id, "allowance": self.remaining, "world_reset": False}

    def business_events(self, since_receipt: int = 0) -> list[dict[str, Any]]:
        return copy.deepcopy([item for item in self.receipts if item["index"] > since_receipt])

    def apply_credential_rate_drift(
        self,
        event_id: str,
        credential_ids: list[str],
        bucket_ids: list[str],
    ) -> dict[str, Any]:
        if event_id in self.applied_boundary_events:
            return {"status": "success", "event_id": event_id, "idempotent": True, "changed": []}
        changed: list[str] = []
        for credential_id in credential_ids:
            credential = self.manager.get_entity("api_credential", credential_id, id_field="credential_id")
            if credential and credential.get("status") in {"active", "rotating"}:
                credential["status"] = "revoked"
                credential["updated_at"] = REFERENCE_NOW
                self.manager.add_entity("api_credential", credential, id_field="credential_id")
                changed.append(credential_id)
        for bucket_id in bucket_ids:
            bucket = self.manager.get_entity("rate_limit_bucket", bucket_id, id_field="bucket_id")
            if bucket and bucket.get("status") != "disabled":
                bucket["status"] = "disabled"
                bucket["updated_at"] = REFERENCE_NOW
                self.manager.add_entity("rate_limit_bucket", bucket, id_field="bucket_id")
                changed.append(bucket_id)
        self.applied_boundary_events.add(event_id)
        return {"status": "success", "event_id": event_id, "idempotent": False, "changed": changed}

    def grade_targets(self, targets: list[dict[str, str]]) -> dict[str, Any]:
        rows = []
        for target in targets:
            source_id = target["call_id"]
            recoveries = self.manager.query_entities(
                "api_call_attempt",
                lambda row: row.get("duplicate_of_call_id") == source_id
                and row.get("status") == "success"
                and row.get("side_effect_committed") is True,
            )
            source = self.manager.get_entity("api_call_attempt", source_id, id_field="call_id")
            committed = len(recoveries) == 1
            recovery = recoveries[0] if committed else None
            capacity_conserved = False
            recovery_policy_satisfied = False
            audit_complete = False
            if recovery:
                bucket = self.manager.get_entity("rate_limit_bucket", recovery.get("rate_limit_bucket_id", ""), id_field="bucket_id")
                budget = self.manager.get_entity("retry_budget", recovery.get("retry_budget_id", ""), id_field="budget_id")
                capacity_conserved = bool(
                    bucket
                    and budget
                    and bucket.get("integration_id") == target["integration_id"]
                    and bucket.get("operation") == target["operation"]
                    and budget.get("integration_id") == target["integration_id"]
                )
                recovery_policy_satisfied = (
                    recovery.get("recovery_profile_id") == target.get("recovery_profile_id")
                )
                audits = self.manager.query_entities(
                    "audit_event", lambda row: row.get("related_call_id") == recovery.get("call_id")
                )
                audit_complete = bool(audits)
            milestones = {
                "source_bound": bool(source and source.get("integration_id") == target["integration_id"] and source.get("operation") == target["operation"]),
                "capacity_conserved": capacity_conserved,
                "recovery_policy_satisfied": recovery_policy_satisfied,
                "single_recovery_committed": committed,
                "audit_lineage_complete": audit_complete,
            }
            score = (
                2.5 * milestones["source_bound"]
                + 5.0 * milestones["capacity_conserved"]
                + 7.5 * milestones["recovery_policy_satisfied"]
                + 7.5 * milestones["single_recovery_committed"]
                + 2.5 * milestones["audit_lineage_complete"]
            )
            rows.append({"call_id": source_id, "score": score, "milestones": milestones})
        return {"score": sum(row["score"] for row in rows), "complete_artifacts": sum(row["score"] == 25.0 for row in rows), "targets": rows}