agent-lifecycle-kit 1.50.1__py3-none-any.whl

agent_lifecycle/goal/records.py

@@ -0,0 +1,244 @@
+"""Goal record validation and compact continuation snapshots."""
+
+from __future__ import annotations
+
+from datetime import UTC, datetime
+from typing import Any
+
+from agent_lifecycle.context.profiles import resolve_window, validate_context_profile
+from agent_lifecycle.context.rendering import estimate_tokens
+from agent_lifecycle.contracts import LifecycleError, canonical_digest
+
+GOAL_STATUSES = {"ACTIVE", "BLOCKED", "READY_FOR_FINALIZATION", "COMPLETE"}
+LINEAGE_KEYS = ("runId", "packageId", "planRevision", "planDigest", "sourceRevision")
+
+
+def validate_goal_record(
+    record: dict[str, Any],
+    *,
+    state: dict[str, Any] | None = None,
+    require_current: bool = False,
+) -> dict[str, Any]:
+    """Validate a goal record and optionally bind it to current workflow state."""
+
+    if not isinstance(record, dict):
+        raise LifecycleError("invalid-goal-record", "goal record must be an object")
+    if record.get("schemaVersion") != "agent-goal-record.v1":
+        raise LifecycleError("invalid-goal-record", "goal record schemaVersion is unsupported")
+    goal_id = _required_string(record.get("goalId"), label="goalId")
+    _required_string(record.get("userIntent"), label="userIntent")
+    _required_string(record.get("ownerOutcome"), label="ownerOutcome")
+    status = record.get("status")
+    if status not in GOAL_STATUSES:
+        raise LifecycleError("invalid-goal-record", "goal status is unsupported")
+    constraints = _string_list(record.get("constraints"), label="constraints")
+    evidence_ids = _string_list(record.get("evidenceIds"), label="evidenceIds", allow_empty=True)
+    lineage = _lineage(record)
+    completion_check = _completion_check(record.get("completionCheck"))
+    if state is not None:
+        _validate_state_binding(lineage, completion_check, state, require_current=require_current)
+    return {
+        "schemaVersion": "agent-goal-record-validation.v1",
+        "status": "PASS",
+        "goalId": goal_id,
+        "goalStatus": status,
+        "lineage": lineage,
+        "stateRevision": lineage.get("stateRevision"),
+        "constraintCount": len(constraints),
+        "evidenceIds": evidence_ids,
+        "completionCheck": completion_check,
+        "goalDigest": canonical_digest(record),
+    }
+
+
+def build_objective_snapshot(
+    record: dict[str, Any],
+    state: dict[str, Any],
+    *,
+    profile: dict[str, Any] | None = None,
+    window: str | None = None,
+) -> dict[str, Any]:
+    """Build a compact continuation summary from a current goal record."""
+
+    from agent_lifecycle.workflow.query import next_action
+
+    validation = validate_goal_record(record, state=state, require_current=True)
+    body: dict[str, Any] = {
+        "schemaVersion": "agent-objective-snapshot.v1",
+        "status": "PASS",
+        "goal": {
+            "goalId": validation["goalId"],
+            "goalStatus": validation["goalStatus"],
+            "goalDigest": validation["goalDigest"],
+            "userIntent": record.get("userIntent"),
+            "userIntentDigest": canonical_digest({"userIntent": record.get("userIntent")}),
+            "ownerOutcome": record.get("ownerOutcome"),
+            "constraints": record.get("constraints", []),
+            "constraintsDigest": canonical_digest({"constraints": record.get("constraints", [])}),
+            "evidenceIds": validation["evidenceIds"],
+        },
+        "lifecycle": {
+            "runId": state.get("runId"),
+            "packageId": state.get("packageId"),
+            "planRevision": state.get("planRevision"),
+            "planDigest": state.get("planDigest"),
+            "sourceRevision": state.get("sourceRevision"),
+            "phase": state.get("phase"),
+            "stateRevision": state.get("stateRevision"),
+            "nextAction": next_action(state),
+        },
+        "completionCheck": validation["completionCheck"],
+    }
+    token_estimate = estimate_tokens(body)
+    target: dict[str, Any] | None = None
+    if profile is not None:
+        validate_context_profile(profile)
+        selected = resolve_window(profile, window)
+        limit = selected["limits"]["maxStateSummaryTokens"]
+        target = {"window": selected["name"], "limit": limit}
+        if token_estimate > limit:
+            raise LifecycleError(
+                "goal-summary-overflow",
+                "objective snapshot exceeds compact context state-summary limit",
+                {"estimatedTokens": token_estimate, "limit": limit, "window": selected["name"]},
+            )
+    body["estimatedTokens"] = token_estimate
+    if target is not None:
+        body["target"] = target
+    return {**body, "snapshotDigest": canonical_digest(body)}
+
+
+def update_goal_record(
+    record: dict[str, Any],
+    state: dict[str, Any],
+    *,
+    status: str | None = None,
+    reason: str,
+    evidence_ids: list[str] | None = None,
+) -> dict[str, Any]:
+    """Return a new goal record bound to the current workflow state."""
+
+    previous = validate_goal_record(record, state=state, require_current=False)
+    new_status = status or str(record.get("status"))
+    if new_status not in GOAL_STATUSES:
+        raise LifecycleError("invalid-goal-record", "goal status is unsupported")
+    added_evidence = _string_list(evidence_ids or [], label="evidenceIds", allow_empty=True)
+    merged_evidence = sorted(set(previous["evidenceIds"]) | set(added_evidence))
+    updated = {
+        **record,
+        "status": new_status,
+        "lineage": _lineage_from_state(state),
+        "completionCheck": _state_completion_check(state),
+        "evidenceIds": merged_evidence,
+        "updatedAt": _now_iso(),
+    }
+    if updated["completionCheck"] is None:
+        updated.pop("completionCheck", None)
+    history = list(record.get("history", [])) if isinstance(record.get("history"), list) else []
+    history.append({
+        "previousGoalDigest": previous["goalDigest"],
+        "previousStateRevision": previous["stateRevision"],
+        "reason": reason,
+        "updatedAt": updated["updatedAt"],
+    })
+    updated["history"] = history
+    validate_goal_record(updated, state=state, require_current=True)
+    return updated
+
+
+def _validate_state_binding(
+    lineage: dict[str, Any],
+    completion_check: dict[str, Any] | None,
+    state: dict[str, Any],
+    *,
+    require_current: bool,
+) -> None:
+    for key in LINEAGE_KEYS:
+        if lineage.get(key) != state.get(key):
+            raise LifecycleError("goal-lineage-mismatch", f"goal record {key} mismatch")
+    state_revision = lineage.get("stateRevision")
+    if not isinstance(state_revision, int) or isinstance(state_revision, bool) or state_revision < 1:
+        raise LifecycleError("invalid-goal-record", "goal lineage.stateRevision must be a positive integer")
+    if require_current and state_revision != state.get("stateRevision"):
+        raise LifecycleError(
+            "goal-state-stale",
+            "goal record is not bound to the current workflow state revision",
+            {"goalStateRevision": state_revision, "stateRevision": state.get("stateRevision")},
+        )
+    expected_check = _state_completion_check(state)
+    if expected_check != completion_check:
+        raise LifecycleError("goal-completion-check-mismatch", "goal record completionCheck does not match workflow state")
+
+
+def _lineage(record: dict[str, Any]) -> dict[str, Any]:
+    lineage = record.get("lineage")
+    if not isinstance(lineage, dict):
+        raise LifecycleError("invalid-goal-record", "goal lineage is required")
+    result = {key: lineage.get(key) for key in LINEAGE_KEYS}
+    for key, value in result.items():
+        if key == "planRevision":
+            if not isinstance(value, int) or isinstance(value, bool) or value < 1:
+                raise LifecycleError("invalid-goal-record", "goal lineage.planRevision must be a positive integer")
+        elif not isinstance(value, str) or not value:
+            raise LifecycleError("invalid-goal-record", f"goal lineage.{key} is required")
+    state_revision = lineage.get("stateRevision")
+    if not isinstance(state_revision, int) or isinstance(state_revision, bool) or state_revision < 1:
+        raise LifecycleError("invalid-goal-record", "goal lineage.stateRevision must be a positive integer")
+    result["stateRevision"] = state_revision
+    return result
+
+
+def _lineage_from_state(state: dict[str, Any]) -> dict[str, Any]:
+    return {
+        "runId": state.get("runId"),
+        "packageId": state.get("packageId"),
+        "planRevision": state.get("planRevision"),
+        "planDigest": state.get("planDigest"),
+        "sourceRevision": state.get("sourceRevision"),
+        "stateRevision": state.get("stateRevision"),
+    }
+
+
+def _state_completion_check(state: dict[str, Any]) -> dict[str, Any] | None:
+    validation = state.get("completionCheckValidation")
+    if not isinstance(validation, dict):
+        return None
+    check_id = validation.get("checkId")
+    check_digest = validation.get("checkDigest")
+    if not isinstance(check_id, str) or not isinstance(check_digest, str):
+        return None
+    return {"checkId": check_id, "checkDigest": check_digest}
+
+
+def _completion_check(value: Any) -> dict[str, Any] | None:
+    if value is None:
+        return None
+    if not isinstance(value, dict):
+        raise LifecycleError("invalid-goal-record", "goal completionCheck must be an object")
+    check_id = _required_string(value.get("checkId"), label="completionCheck.checkId")
+    check_digest = _digest(value.get("checkDigest"), label="completionCheck.checkDigest")
+    return {"checkId": check_id, "checkDigest": check_digest}
+
+
+def _required_string(value: Any, *, label: str) -> str:
+    if not isinstance(value, str) or not value:
+        raise LifecycleError("invalid-goal-record", f"{label} is required")
+    return value
+
+
+def _digest(value: Any, *, label: str) -> str:
+    if not isinstance(value, str) or len(value) != 64:
+        raise LifecycleError("invalid-goal-record", f"{label} must be a 64-character digest")
+    return value
+
+
+def _string_list(value: Any, *, label: str, allow_empty: bool = False) -> list[str]:
+    if not isinstance(value, list) or not all(isinstance(item, str) and item for item in value):
+        raise LifecycleError("invalid-goal-record", f"{label} must be a list of non-empty strings")
+    if not value and not allow_empty:
+        raise LifecycleError("invalid-goal-record", f"{label} must not be empty")
+    return list(value)
+
+
+def _now_iso() -> str:
+    return datetime.now(UTC).replace(microsecond=0).isoformat().replace("+00:00", "Z")

agent_lifecycle/goal/view.py

@@ -0,0 +1,109 @@
+"""Read-only goal and lifecycle progress view."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any
+
+from agent_lifecycle.contracts import LifecycleError, canonical_digest, read_json_object
+from agent_lifecycle.goal.records import validate_goal_record
+from agent_lifecycle.reporting.progress_view import build_lifecycle_progress_view
+from agent_lifecycle.workflow.query import next_action
+from agent_lifecycle.workflow.state import load_state
+
+GOAL_PROGRESS_VIEW_SCHEMA = "agent-goal-progress-view.v1"
+
+
+def build_goal_progress_view(
+    *,
+    record_path: Path,
+    state_path: Path,
+    usage_receipt_paths: list[Path] | None = None,
+    change_summary_path: Path | None = None,
+    require_current: bool = True,
+) -> dict[str, Any]:
+    """Build a compact read-only view from goal and progress artifacts."""
+
+    record = read_json_object(record_path, label="goal record")
+    state = load_state(state_path)
+    validation = validate_goal_record(record, state=state, require_current=require_current)
+    progress = build_lifecycle_progress_view(
+        state_path=state_path,
+        usage_receipt_paths=usage_receipt_paths or [],
+        change_summary_path=change_summary_path,
+    )
+    task_summary = _task_summary(state)
+    blockers = _blockers(state, task_summary)
+    body = {
+        "schemaVersion": GOAL_PROGRESS_VIEW_SCHEMA,
+        "status": "PASS",
+        "sourceOfTruth": False,
+        "readOnly": True,
+        "modelCallsStarted": False,
+        "hostCallsStarted": False,
+        "stateMutated": False,
+        "goalRecordMutated": False,
+        "stateWritten": False,
+        "goalRecordWritten": False,
+        "tokenSpendForView": False,
+        "goal": {
+            "goalId": validation["goalId"],
+            "goalStatus": validation["goalStatus"],
+            "goalDigest": validation["goalDigest"],
+            "userIntentDigest": canonical_digest({"userIntent": record.get("userIntent")}),
+            "ownerOutcomeDigest": canonical_digest({"ownerOutcome": record.get("ownerOutcome")}),
+            "constraintCount": validation["constraintCount"],
+            "evidenceIds": validation["evidenceIds"],
+            "stateRevision": validation["stateRevision"],
+        },
+        "lifecycle": {
+            "runId": state.get("runId"),
+            "packageId": state.get("packageId"),
+            "planRevision": state.get("planRevision"),
+            "planDigest": state.get("planDigest"),
+            "sourceRevision": state.get("sourceRevision"),
+            "phase": state.get("phase"),
+            "stateRevision": state.get("stateRevision"),
+            "nextAction": next_action(state),
+            "taskSummary": task_summary,
+        },
+        "progress": {
+            "progressDigest": progress["progressDigest"],
+            "rowCount": progress["rowCount"],
+            "lines": progress["lines"],
+            "terminalSummary": progress["terminalSummary"],
+        },
+        "metrics": {
+            "duration": progress["terminalSummary"]["duration"],
+            "tokens": progress["terminalSummary"]["tokens"],
+            "changeSummary": progress["terminalSummary"]["changeSummary"],
+        },
+        "blockers": blockers,
+        "productionPromotionClaimed": False,
+    }
+    return {**body, "viewDigest": canonical_digest(body)}
+
+
+def _task_summary(state: dict[str, Any]) -> dict[str, int]:
+    counts: dict[str, int] = {}
+    tasks = state.get("tasks")
+    for task in tasks if isinstance(tasks, list) else []:
+        if not isinstance(task, dict):
+            continue
+        status = str(task.get("status") or "UNKNOWN")
+        counts[status] = counts.get(status, 0) + 1
+    return counts
+
+
+def _blockers(state: dict[str, Any], task_summary: dict[str, int]) -> list[dict[str, Any]]:
+    blockers: list[dict[str, Any]] = []
+    blocker = state.get("blocker")
+    if isinstance(blocker, dict):
+        blockers.append({
+            "code": str(blocker.get("code") or "workflow-blocked"),
+            "message": str(blocker.get("message") or blocker.get("reason") or "workflow is blocked"),
+        })
+    blocked_count = task_summary.get("BLOCKED", 0)
+    if blocked_count:
+        blockers.append({"code": "blocked-tasks-present", "count": blocked_count})
+    return blockers

agent_lifecycle/host_protocol/__init__.py

@@ -0,0 +1,65 @@
+"""Provider-neutral host operation protocol."""
+
+from agent_lifecycle.host_protocol.acp_capability import (
+    build_acp_capability,
+    build_acp_probe_receipt,
+    require_host_capabilities_pass,
+    validate_host_capabilities,
+    validate_no_acp_evidence_for_hosts,
+)
+from agent_lifecycle.host_protocol.capabilities import (
+    build_capability_manifest,
+    validate_capability_manifest,
+)
+from agent_lifecycle.host_protocol.contracts import HostAdapterEvent, HostOperationReceipt, HostOperationRequest
+from agent_lifecycle.host_protocol.event_capture import (
+    adapter_declares_event_capture,
+    build_adapter_event_stream,
+    build_event_stream_receipt,
+    event_capture_declaration,
+    require_event_capture_pass,
+    validate_event_capture_conformance,
+    validate_event_capture_receipt,
+)
+from agent_lifecycle.host_protocol.events import (
+    require_adapter_event_stream_pass,
+    validate_adapter_event_stream,
+)
+from agent_lifecycle.host_protocol.inspection import (
+    inspect_adapter_descriptor,
+    require_adapter_inspection_pass,
+)
+from agent_lifecycle.host_protocol.receipts import normalize_host_operation_receipt
+from agent_lifecycle.host_protocol.scaffold import scaffold_adapter
+from agent_lifecycle.host_protocol.validation import (
+    require_adapter_validation_pass,
+    validate_adapter_descriptor,
+)
+
+__all__ = [
+    "HostAdapterEvent",
+    "HostOperationReceipt",
+    "HostOperationRequest",
+    "adapter_declares_event_capture",
+    "build_acp_capability",
+    "build_acp_probe_receipt",
+    "build_capability_manifest",
+    "build_adapter_event_stream",
+    "build_event_stream_receipt",
+    "event_capture_declaration",
+    "normalize_host_operation_receipt",
+    "require_event_capture_pass",
+    "require_adapter_event_stream_pass",
+    "require_adapter_inspection_pass",
+    "require_adapter_validation_pass",
+    "require_host_capabilities_pass",
+    "inspect_adapter_descriptor",
+    "scaffold_adapter",
+    "validate_capability_manifest",
+    "validate_event_capture_conformance",
+    "validate_event_capture_receipt",
+    "validate_adapter_event_stream",
+    "validate_adapter_descriptor",
+    "validate_host_capabilities",
+    "validate_no_acp_evidence_for_hosts",
+]

agent_lifecycle/host_protocol/acp_capability.py

@@ -0,0 +1,195 @@
+"""Neutral ACP host capability declarations and fail-closed probe receipts."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from agent_lifecycle.contracts.errors import LifecycleError
+
+ACP_CAPABILITY_ID = "acp"
+HOST_CAPABILITY_SCHEMA_VERSION = "agent-host-capability.v1"
+HOST_CAPABILITY_VALIDATION_SCHEMA_VERSION = "agent-host-capability-validation.v1"
+ACP_PROBE_RECEIPT_SCHEMA_VERSION = "agent-acp-probe-receipt.v1"
+_SUPPORTED_VALUES = {"supported", "unsupported", "unknown"}
+
+
+def build_acp_capability(
+    *,
+    adapter_id: str,
+    host: str,
+    support: str,
+    probe_command: list[str] | None = None,
+) -> dict[str, Any]:
+    """Build a schema-backed ACP capability declaration without provider identity."""
+
+    capability: dict[str, Any] = {
+        "schemaVersion": HOST_CAPABILITY_SCHEMA_VERSION,
+        "capabilityId": ACP_CAPABILITY_ID,
+        "adapterId": adapter_id,
+        "host": host,
+        "support": support,
+        "transport": "acp" if support == "supported" else "unknown",
+        "evidencePolicy": "probe-required" if support == "supported" else "not-claimed",
+        "providerIdentityUsed": False,
+        "probe": None,
+        "invocationContract": None,
+    }
+    if support == "supported":
+        capability["probe"] = {
+            "required": True,
+            "command": list(probe_command or [host, "--help"]),
+            "liveCallsStarted": False,
+        }
+        capability["invocationContract"] = {
+            "requestSchema": "agent-host-operation-request.v1",
+            "receiptSchema": "agent-host-operation-receipt.v1",
+            "unsupportedOperationPolicy": "fail-closed",
+        }
+    return capability
+
+
+def validate_host_capabilities(
+    capabilities: Any,
+    *,
+    adapter_id: str | None = None,
+    host: str | None = None,
+) -> dict[str, Any]:
+    """Validate optional host capability declarations attached to a descriptor."""
+
+    blockers: list[dict[str, Any]] = []
+    if not isinstance(capabilities, list):
+        blockers.append({"code": "invalid-host-capabilities", "message": "hostCapabilities must be an array"})
+        return _validation_result(0, blockers)
+    for index, capability in enumerate(capabilities):
+        if not isinstance(capability, dict):
+            blockers.append({"code": "invalid-host-capability", "index": index, "message": "host capability must be an object"})
+            continue
+        _validate_capability_shape(capability, blockers, index=index, adapter_id=adapter_id, host=host)
+    return _validation_result(len(capabilities), blockers)
+
+
+def validate_no_acp_evidence_for_hosts(capabilities: list[dict[str, Any]], *, excluded_hosts: set[str]) -> dict[str, Any]:
+    """Validate that excluded hosts have no positive ACP evidence declarations."""
+
+    blockers: list[dict[str, Any]] = []
+    for capability in capabilities:
+        if capability.get("capabilityId") != ACP_CAPABILITY_ID:
+            continue
+        host = capability.get("host")
+        if isinstance(host, str) and host in excluded_hosts and capability.get("support") == "supported":
+            blockers.append({"code": "excluded-host-acp-evidence", "host": host})
+    return _validation_result(len(capabilities), blockers)
+
+
+def build_acp_probe_receipt(
+    capability: dict[str, Any],
+    *,
+    executable_found: bool,
+    probe_passed: bool,
+    invocation_contract_valid: bool,
+) -> dict[str, Any]:
+    """Return a fail-closed ACP probe receipt without starting live model calls."""
+
+    validation = validate_host_capabilities(
+        [capability],
+        adapter_id=capability.get("adapterId") if isinstance(capability.get("adapterId"), str) else None,
+        host=capability.get("host") if isinstance(capability.get("host"), str) else None,
+    )
+    blockers = list(validation["blockers"])
+    support = capability.get("support")
+    checks = [
+        {"name": "capability-declaration", "status": validation["status"]},
+        {"name": "executable-present", "status": "PASS" if executable_found else "FAIL"},
+        {"name": "acp-probe", "status": "PASS" if probe_passed else "FAIL"},
+        {"name": "invocation-contract", "status": "PASS" if invocation_contract_valid else "FAIL"},
+    ]
+    if support != "supported":
+        return {
+            "schemaVersion": ACP_PROBE_RECEIPT_SCHEMA_VERSION,
+            "status": "SKIPPED",
+            "adapterId": capability.get("adapterId"),
+            "host": capability.get("host"),
+            "capabilityId": ACP_CAPABILITY_ID,
+            "liveCallsStarted": False,
+            "checks": checks[:1],
+            "blockers": blockers,
+        }
+    if not executable_found:
+        blockers.append({"code": "acp-executable-missing"})
+    if not probe_passed:
+        blockers.append({"code": "acp-probe-failed"})
+    if not invocation_contract_valid:
+        blockers.append({"code": "acp-invocation-contract-invalid"})
+    return {
+        "schemaVersion": ACP_PROBE_RECEIPT_SCHEMA_VERSION,
+        "status": "PASS" if not blockers else "FAIL",
+        "adapterId": capability.get("adapterId"),
+        "host": capability.get("host"),
+        "capabilityId": ACP_CAPABILITY_ID,
+        "liveCallsStarted": False,
+        "checks": checks,
+        "blockers": blockers,
+    }
+
+
+def require_host_capabilities_pass(payload: dict[str, Any]) -> dict[str, Any]:
+    if payload.get("status") == "FAIL":
+        raise LifecycleError("host-capability-validation-failed", "host capability validation failed", {"validation": payload})
+    return payload
+
+
+def _validate_capability_shape(
+    capability: dict[str, Any],
+    blockers: list[dict[str, Any]],
+    *,
+    index: int,
+    adapter_id: str | None,
+    host: str | None,
+) -> None:
+    if capability.get("schemaVersion") != HOST_CAPABILITY_SCHEMA_VERSION:
+        blockers.append({"code": "invalid-host-capability-schema", "index": index})
+    if capability.get("capabilityId") != ACP_CAPABILITY_ID:
+        blockers.append({"code": "unsupported-host-capability", "index": index, "capabilityId": capability.get("capabilityId")})
+    if capability.get("support") not in _SUPPORTED_VALUES:
+        blockers.append({"code": "invalid-host-capability-support", "index": index})
+    if capability.get("providerIdentityUsed") is not False:
+        blockers.append({"code": "host-capability-provider-identity", "index": index})
+    if adapter_id is not None and capability.get("adapterId") != adapter_id:
+        blockers.append({"code": "host-capability-adapter-mismatch", "index": index})
+    if host is not None and capability.get("host") != host:
+        blockers.append({"code": "host-capability-host-mismatch", "index": index})
+    if capability.get("support") == "supported":
+        _validate_supported_acp(capability, blockers, index=index)
+
+
+def _validate_supported_acp(capability: dict[str, Any], blockers: list[dict[str, Any]], *, index: int) -> None:
+    if capability.get("transport") != "acp":
+        blockers.append({"code": "supported-acp-transport-mismatch", "index": index})
+    if capability.get("evidencePolicy") != "probe-required":
+        blockers.append({"code": "supported-acp-probe-policy-missing", "index": index})
+    probe = capability.get("probe")
+    if not isinstance(probe, dict) or probe.get("required") is not True:
+        blockers.append({"code": "supported-acp-probe-required", "index": index})
+    elif not isinstance(probe.get("command"), list) or not all(isinstance(item, str) and item for item in probe["command"]):
+        blockers.append({"code": "supported-acp-probe-command-invalid", "index": index})
+    elif probe.get("liveCallsStarted") is not False:
+        blockers.append({"code": "supported-acp-probe-live-call-overclaim", "index": index})
+    contract = capability.get("invocationContract")
+    if not isinstance(contract, dict):
+        blockers.append({"code": "supported-acp-invocation-contract-missing", "index": index})
+        return
+    if contract.get("requestSchema") != "agent-host-operation-request.v1":
+        blockers.append({"code": "supported-acp-request-schema", "index": index})
+    if contract.get("receiptSchema") != "agent-host-operation-receipt.v1":
+        blockers.append({"code": "supported-acp-receipt-schema", "index": index})
+    if contract.get("unsupportedOperationPolicy") != "fail-closed":
+        blockers.append({"code": "supported-acp-unsupported-policy", "index": index})
+
+
+def _validation_result(capability_count: int, blockers: list[dict[str, Any]]) -> dict[str, Any]:
+    return {
+        "schemaVersion": HOST_CAPABILITY_VALIDATION_SCHEMA_VERSION,
+        "status": "PASS" if not blockers else "FAIL",
+        "capabilityCount": capability_count,
+        "blockers": blockers,
+    }