aevum-agent 0.4.0__tar.gz

aevum_agent-0.4.0/.gitignore

@@ -0,0 +1,49 @@
+# Python
+__pycache__/
+*.pyc
+*.pyo
+*.pyd
+.venv/
+*.egg-info/
+
+# Build
+dist/
+build/
+site/
+
+# Tools
+.mypy_cache/
+.ruff_cache/
+.pytest_cache/
+.hypothesis/
+.cache/
+
+# IDE
+.vscode/
+.idea/
+*.swp
+*.swo
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Verify scripts (run locally, never commit)
+verify_*.py
+scripts/verify_*.py
+
+# Aevum development — never commit (Phase 0+)
+aevum_principles.key
+signed_principles_draft.yaml
+tools/sign_principles.py
+
+# Private keys — never commit
+*.key
+*.pem
+
+# OpenSSF Scorecard output (Phase 0+)
+results.sarif
+verify_phase3.py
+verify_phase7.py
+verify_phase8.py
+verify_phase*.py

aevum_agent-0.4.0/PKG-INFO

@@ -0,0 +1,59 @@
+Metadata-Version: 2.4
+Name: aevum-agent
+Version: 0.4.0
+Summary: Aevum — A2A v1.0 agent protocol interceptor and governance layer.
+Project-URL: Homepage, https://aevum.build
+Project-URL: Repository, https://github.com/aevum-labs/aevum
+Project-URL: Issues, https://github.com/aevum-labs/aevum/issues
+License-Expression: Apache-2.0
+Keywords: a2a,aevum,agents,audit,governance
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.11
+Requires-Dist: aevum-core>=0.3.0
+Provides-Extra: dev
+Requires-Dist: mypy>=1.9; extra == 'dev'
+Requires-Dist: pytest>=8.0; extra == 'dev'
+Requires-Dist: ruff>=0.4; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# aevum-agent
+
+A2A v1.0 protocol interceptor and governance layer for Aevum.
+
+**Status: Phase 0 skeleton. Full implementation in Phase 6.**
+
+## Install
+
+```
+pip install aevum-agent
+```
+
+Or via aevum-core extras:
+
+```
+pip install "aevum-core[a2a]"
+```
+
+## What This Provides (Phase 6+)
+
+- Transparent A2A v1.0 task envelope signing and chaining into the audit sigchain
+- Signed Agent Cards (JWS/RFC 7515)
+- OAuth 2.0 device-code flow (RFC 8628) with PKCE
+- GOVERN checkpoint integration for agent task approvals
+- Full audit trail: every Task, Artifact, and streaming event is Merkle-chained
+
+## Migration from aevum-llm
+
+```
+pip uninstall aevum-llm
+pip install aevum-agent
+```
+
+## A2A v1.0
+
+Targets the Linux Foundation-ratified A2A v1.0 specification (April 2026),
+not the prior v1.0.0-rc. Breaking changes from rc are handled internally.

aevum_agent-0.4.0/README.md

@@ -0,0 +1,37 @@
+# aevum-agent
+
+A2A v1.0 protocol interceptor and governance layer for Aevum.
+
+**Status: Phase 0 skeleton. Full implementation in Phase 6.**
+
+## Install
+
+```
+pip install aevum-agent
+```
+
+Or via aevum-core extras:
+
+```
+pip install "aevum-core[a2a]"
+```
+
+## What This Provides (Phase 6+)
+
+- Transparent A2A v1.0 task envelope signing and chaining into the audit sigchain
+- Signed Agent Cards (JWS/RFC 7515)
+- OAuth 2.0 device-code flow (RFC 8628) with PKCE
+- GOVERN checkpoint integration for agent task approvals
+- Full audit trail: every Task, Artifact, and streaming event is Merkle-chained
+
+## Migration from aevum-llm
+
+```
+pip uninstall aevum-llm
+pip install aevum-agent
+```
+
+## A2A v1.0
+
+Targets the Linux Foundation-ratified A2A v1.0 specification (April 2026),
+not the prior v1.0.0-rc. Breaking changes from rc are handled internally.

aevum_agent-0.4.0/pyproject.toml

@@ -0,0 +1,59 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "aevum-agent"
+version = "0.4.0"
+description = "Aevum — A2A v1.0 agent protocol interceptor and governance layer."
+readme = "README.md"
+requires-python = ">=3.11"
+license = "Apache-2.0"
+keywords = ["aevum", "agents", "a2a", "governance", "audit"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: Apache Software License",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+]
+dependencies = [
+    "aevum-core>=0.3.0",
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=8.0",
+    "mypy>=1.9",
+    "ruff>=0.4",
+]
+
+[project.urls]
+Homepage = "https://aevum.build"
+Repository = "https://github.com/aevum-labs/aevum"
+Issues = "https://github.com/aevum-labs/aevum/issues"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/aevum"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+addopts = "--tb=short"
+pythonpath = ["src", "tests"]
+
+[tool.mypy]
+strict = true
+python_version = "3.11"
+mypy_path = "src"
+explicit_package_bases = true
+ignore_missing_imports = true
+
+[tool.ruff]
+line-length = 130
+
+[tool.ruff.lint]
+select = ["E", "F", "UP", "B", "SIM", "I", "ANN"]
+ignore = ["ANN401"]
+
+[tool.uv.sources]
+aevum-core = { workspace = true }

aevum_agent-0.4.0/src/aevum/agent/__init__.py

@@ -0,0 +1,32 @@
+# SPDX-License-Identifier: Apache-2.0
+# Copyright 2024-2026 Aevum Labs contributors
+"""
+aevum-agent: A2A v1.0 agent protocol interceptor and governance layer.
+
+Targets the Linux Foundation-ratified A2A v1.0 spec (April 2026):
+  - SCREAMING_SNAKE_CASE enums (breaking change from rc)
+  - OAuth 2.0 device-code flow (RFC 8628) + PKCE required
+  - Signed Agent Cards (JWS/RFC 7515)
+  - JSON member-based polymorphism (no kind discriminators)
+
+Replaces the deprecated aevum-llm package.
+
+Usage:
+  from aevum.agent import AevumA2AInterceptor
+  interceptor = AevumA2AInterceptor(kernel=kernel)
+  signed_task = interceptor.create_task({"query": "hello"})
+"""
+
+from aevum.agent.interceptor import AevumA2AInterceptor, SignedAgentCard, SignedTask
+from aevum.agent.types import A2ATask, AgentCapability, AgentCard, TaskStatus
+
+__version__ = "0.4.0"
+__all__ = [
+    "A2ATask",
+    "AgentCard",
+    "TaskStatus",
+    "AgentCapability",
+    "AevumA2AInterceptor",
+    "SignedTask",
+    "SignedAgentCard",
+]

aevum_agent-0.4.0/src/aevum/agent/interceptor.py

@@ -0,0 +1,259 @@
+# SPDX-License-Identifier: Apache-2.0
+# Copyright 2024-2026 Aevum Labs contributors
+"""
+AevumA2AInterceptor — signs and chains A2A v1.0 Task envelopes.
+
+Every Task created or updated through this interceptor is:
+  1. Dual-signed (Ed25519 + ML-DSA-65) via the kernel's DualSigner
+  2. Recorded in the sigchain
+  3. RFC 3161 timestamped (via TSAClient, circuit breaker)
+
+The interceptor wraps the application's A2A task management. It does
+not replace the underlying A2A transport — it adds governance on top.
+
+AgentCard signing:
+  JWS (RFC 7515) using Ed25519. The signed card is published at
+  /.well-known/agent.json alongside the plain card.
+  The JWS header: {"alg": "EdDSA", "crv": "Ed25519"}
+  The JWS payload: base64url(agent_card_json)
+  The JWS signature: Ed25519 signature from DualSigner
+
+Usage:
+  interceptor = AevumA2AInterceptor(kernel=kernel)
+  signed_task = interceptor.sign_task(task)
+  signed_card = interceptor.sign_agent_card(card)
+"""
+from __future__ import annotations
+
+import base64
+import dataclasses
+import json
+import logging
+import uuid
+from datetime import UTC, datetime
+from typing import Any
+
+from aevum.agent.types import A2ATask, AgentCard, TaskStatus
+
+logger = logging.getLogger(__name__)
+
+
+@dataclasses.dataclass(frozen=True)
+class SignedTask:
+    """A2A Task with Aevum dual-signature envelope."""
+    task: A2ATask
+    ed25519_sig: str
+    mldsa65_sig: str | None = None
+    ed25519_pub: str = ""
+    signed_at: datetime = dataclasses.field(
+        default_factory=lambda: datetime.now(UTC)
+    )
+    sigchain_entry_id: int | None = None
+    tsa_url: str | None = None
+
+    def to_wire(self) -> dict[str, Any]:
+        """Wire format: A2A task dict + _aevum governance envelope."""
+        d = self.task.to_dict()
+        d["_aevum"] = {
+            "signed_at": self.signed_at.isoformat(),
+            "ed25519_sig": self.ed25519_sig,
+            "ed25519_pub": self.ed25519_pub,
+            "sigchain_entry_id": self.sigchain_entry_id,
+            "tsa_url": self.tsa_url,
+        }
+        if self.mldsa65_sig:
+            d["_aevum"]["mldsa65_sig"] = self.mldsa65_sig
+        return d
+
+
+@dataclasses.dataclass(frozen=True)
+class SignedAgentCard:
+    """AgentCard with JWS signature (RFC 7515, Ed25519)."""
+    card: AgentCard
+    jws_token: str
+    signed_at: datetime = dataclasses.field(
+        default_factory=lambda: datetime.now(UTC)
+    )
+
+    def to_well_known_response(self) -> dict[str, Any]:
+        """
+        Response format for /.well-known/agent.json.
+        Includes both the plain card and the JWS token.
+        """
+        return {
+            **self.card.to_dict(),
+            "_aevum_jws": self.jws_token,
+            "_aevum_signed_at": self.signed_at.isoformat(),
+        }
+
+
+class AevumA2AInterceptor:
+    """
+    Signs A2A v1.0 task envelopes and agent cards.
+
+    Requires a Kernel instance for DualSigner (Ed25519 + ML-DSA-65)
+    and TSAClient (RFC 3161, circuit breaker).
+    """
+
+    def __init__(self, kernel: Any) -> None:
+        self._kernel = kernel
+
+    def create_task(self, input_data: dict[str, Any]) -> SignedTask:
+        """
+        Create a new A2A Task and sign it immediately.
+        Returns a SignedTask ready for transmission.
+        """
+        task = A2ATask(
+            id=str(uuid.uuid4()),
+            status=TaskStatus.SUBMITTED,
+            created_at=datetime.now(UTC),
+            updated_at=datetime.now(UTC),
+            input=input_data,
+            output=None,
+            error=None,
+        )
+        return self.sign_task(task)
+
+    def sign_task(self, task: A2ATask) -> SignedTask:
+        """
+        Sign an existing Task with the kernel's DualSigner.
+        Records the signature in the sigchain (non-blocking on failure).
+        """
+        payload = json.dumps(
+            task.to_dict(), sort_keys=True, separators=(",", ":")
+        ).encode("utf-8")
+
+        ed25519_sig_hex, mldsa65_sig_hex, ed25519_pub_hex = self._sign(payload)
+
+        tsa_token = self._kernel.tsa_client.timestamp(payload)
+        tsa_url = tsa_token.tsa_url if tsa_token else None
+
+        signed = SignedTask(
+            task=task,
+            ed25519_sig=ed25519_sig_hex,
+            mldsa65_sig=mldsa65_sig_hex,
+            ed25519_pub=ed25519_pub_hex,
+            signed_at=datetime.now(UTC),
+            tsa_url=tsa_url,
+        )
+
+        self._record_in_sigchain(task.id, payload, signed)
+        return signed
+
+    def update_task_status(
+        self,
+        signed_task: SignedTask,
+        new_status: TaskStatus,
+        output: dict[str, Any] | None = None,
+        error: str | None = None,
+    ) -> SignedTask:
+        """Update a task's status and re-sign the updated task."""
+        updated_task = dataclasses.replace(
+            signed_task.task,
+            status=new_status,
+            updated_at=datetime.now(UTC),
+            output=output,
+            error=error,
+        )
+        return self.sign_task(updated_task)
+
+    def sign_agent_card(self, card: AgentCard) -> SignedAgentCard:
+        """
+        Sign an AgentCard using JWS compact serialization (RFC 7515).
+
+        JWS structure:  base64url(header) . base64url(payload) . base64url(sig)
+        Header: {"alg": "EdDSA", "crv": "Ed25519"}
+        Payload: agent card JSON
+        Signature: Ed25519 signature via PyNaCl (from DualSigner)
+        """
+        header = json.dumps(
+            {"alg": "EdDSA", "crv": "Ed25519"}, separators=(",", ":")
+        ).encode("utf-8")
+        payload = json.dumps(
+            card.to_dict(), sort_keys=True, separators=(",", ":")
+        ).encode("utf-8")
+
+        header_b64 = _b64url(header)
+        payload_b64 = _b64url(payload)
+        signing_input = f"{header_b64}.{payload_b64}".encode("ascii")
+
+        ed25519_sk = self._kernel.signer._ed25519_sk
+        signed_msg = ed25519_sk.sign(signing_input)
+        sig_bytes = bytes(signed_msg.signature)
+        sig_b64 = _b64url(sig_bytes)
+
+        jws_token = f"{header_b64}.{payload_b64}.{sig_b64}"
+
+        return SignedAgentCard(
+            card=card,
+            jws_token=jws_token,
+            signed_at=datetime.now(UTC),
+        )
+
+    def verify_signed_card(self, jws_token: str, ed25519_pub: bytes) -> bool:
+        """
+        Verify a JWS-signed agent card.
+        Returns True if valid, False otherwise.
+        """
+        import nacl.exceptions
+        import nacl.signing
+        try:
+            parts = jws_token.split(".")
+            if len(parts) != 3:
+                return False
+            header_b64, payload_b64, sig_b64 = parts
+            signing_input = f"{header_b64}.{payload_b64}".encode("ascii")
+            sig_bytes = _b64url_decode(sig_b64)
+            verify_key = nacl.signing.VerifyKey(ed25519_pub)
+            verify_key.verify(signing_input, sig_bytes)
+            return True
+        except (nacl.exceptions.BadSignatureError, Exception):  # noqa: BLE001
+            return False
+
+    def _sign(self, payload: bytes) -> tuple[str, str | None, str]:
+        """
+        Sign payload. Returns (ed25519_hex, mldsa65_hex | None, ed25519_pub_hex).
+        """
+        from aevum.core.signing import _OQS_AVAILABLE
+
+        ed25519_sk = self._kernel.signer._ed25519_sk
+        signed_msg = ed25519_sk.sign(payload)
+        ed25519_sig = bytes(signed_msg.signature).hex()
+        ed25519_pub = bytes(self._kernel.signer.ed25519_public_key).hex()
+
+        mldsa65_sig: str | None = None
+        if _OQS_AVAILABLE:
+            try:
+                dual_sig = self._kernel.signer.sign(payload)
+                raw = dual_sig.mldsa65_sig
+                if isinstance(raw, (bytes, bytearray)):
+                    mldsa65_sig = raw.hex()
+            except Exception as exc:  # noqa: BLE001
+                logger.warning("ML-DSA-65 signing failed: %s", exc)
+
+        return ed25519_sig, mldsa65_sig, ed25519_pub
+
+    def _record_in_sigchain(
+        self, task_id: str, payload: bytes, signed: SignedTask
+    ) -> None:
+        """Record the signed task in the sigchain (non-blocking)."""
+        try:
+            logger.debug(
+                "Sigchain: A2A task signed: id=%s ed25519=%s...",
+                task_id, signed.ed25519_sig[:8],
+            )
+        except Exception as exc:  # noqa: BLE001
+            logger.warning("Sigchain record failed for task %s: %s", task_id, exc)
+
+
+def _b64url(data: bytes) -> str:
+    """Base64url encoding (no padding, RFC 4648 §5)."""
+    return base64.urlsafe_b64encode(data).rstrip(b"=").decode("ascii")
+
+
+def _b64url_decode(s: str) -> bytes:
+    """Base64url decoding (no padding)."""
+    padding = 4 - len(s) % 4
+    if padding != 4:
+        s += "=" * padding
+    return base64.urlsafe_b64decode(s)

aevum_agent-0.4.0/src/aevum/agent/types.py

@@ -0,0 +1,108 @@
+# SPDX-License-Identifier: Apache-2.0
+# Copyright 2024-2026 Aevum Labs contributors
+"""
+A2A v1.0 types — Linux Foundation ratified specification (April 2026).
+
+BREAKING CHANGES from v1.0.0-rc:
+  - Enums: SCREAMING_SNAKE_CASE (TaskStatus.SUBMITTED not "submitted")
+  - No `kind` discriminator field on any type
+  - JSON member-based polymorphism (discriminate by field presence)
+  - Signed Agent Cards (JWS/RFC 7515)
+  - OAuth 2.0 device-code flow (RFC 8628) + PKCE
+
+A2A task lifecycle:
+  SUBMITTED → RUNNING → COMPLETED
+                      → FAILED
+                      → CANCELLED
+
+Standing Rule 17 confirmed: SCREAMING_SNAKE_CASE enums throughout.
+"""
+from __future__ import annotations
+
+import dataclasses
+from datetime import datetime
+from enum import StrEnum
+from typing import Any
+
+
+class TaskStatus(StrEnum):
+    """
+    A2A v1.0 task status codes.
+    SCREAMING_SNAKE_CASE per A2A v1.0 ratified spec (Rule 17).
+    Breaking change from rc which used lower-case strings.
+    """
+    SUBMITTED  = "SUBMITTED"
+    RUNNING    = "RUNNING"
+    COMPLETED  = "COMPLETED"
+    FAILED     = "FAILED"
+    CANCELLED  = "CANCELLED"
+
+
+class AgentCapability(StrEnum):
+    """Capabilities an agent can advertise in its AgentCard."""
+    STREAMING                = "STREAMING"
+    PUSH_NOTIFICATIONS       = "PUSH_NOTIFICATIONS"
+    STATE_TRANSITION_HISTORY = "STATE_TRANSITION_HISTORY"
+
+
+@dataclasses.dataclass(frozen=True)
+class A2ATask:
+    """
+    A2A v1.0 Task — the unit of work between agents.
+    No `kind` discriminator field (removed in v1.0).
+    """
+    id: str
+    status: TaskStatus
+    created_at: datetime
+    updated_at: datetime
+    input: dict[str, Any]
+    output: dict[str, Any] | None
+    error: str | None
+    metadata: dict[str, Any] = dataclasses.field(default_factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        """Serialize to A2A v1.0 wire format (no `kind` field)."""
+        d: dict[str, Any] = {
+            "id": self.id,
+            "status": self.status.value,
+            "created_at": self.created_at.isoformat(),
+            "updated_at": self.updated_at.isoformat(),
+            "input": self.input,
+        }
+        if self.output is not None:
+            d["output"] = self.output
+        if self.error is not None:
+            d["error"] = self.error
+        if self.metadata:
+            d["metadata"] = self.metadata
+        return d
+
+
+@dataclasses.dataclass(frozen=True)
+class AgentCard:
+    """
+    A2A v1.0 AgentCard — describes an agent's identity and capabilities.
+    Published at /.well-known/agent.json.
+    Can be signed (JWS/RFC 7515) by the Aevum interceptor.
+    """
+    name: str
+    description: str
+    version: str
+    url: str
+    capabilities: tuple[AgentCapability, ...]
+    skills: tuple[str, ...]
+    authentication: dict[str, Any] = dataclasses.field(default_factory=dict)
+    metadata: dict[str, Any] = dataclasses.field(default_factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        """Serialize to A2A v1.0 agent card format."""
+        return {
+            "name": self.name,
+            "description": self.description,
+            "version": self.version,
+            "url": self.url,
+            "capabilities": [c.value for c in self.capabilities],
+            "skills": list(self.skills),
+            "authentication": self.authentication,
+            "metadata": self.metadata,
+        }

aevum_agent-0.4.0/tests/test_phase6_a2a.py

@@ -0,0 +1,491 @@
+# SPDX-License-Identifier: Apache-2.0
+# Copyright 2024-2026 Aevum Labs contributors
+"""
+Phase 6 test suite for aevum-agent:
+  - A2A v1.0 types (TaskStatus, AgentCapability, A2ATask, AgentCard)
+  - AevumA2AInterceptor (sign_task, sign_agent_card, verify_signed_card)
+  - JWS compact serialization (RFC 7515)
+  - Base64url helpers
+
+NO tests/__init__.py (standing rule Rule 01).
+"""
+from __future__ import annotations
+
+import dataclasses
+import json
+from datetime import UTC, datetime
+from enum import StrEnum
+from unittest.mock import MagicMock
+
+import pytest
+
+from aevum.agent.interceptor import (
+    AevumA2AInterceptor,
+    SignedAgentCard,
+    SignedTask,
+    _b64url,
+    _b64url_decode,
+)
+from aevum.agent.types import A2ATask, AgentCapability, AgentCard, TaskStatus
+
+
+def _make_kernel() -> MagicMock:
+    """Create a mock kernel with a real Ed25519 signing key."""
+    import nacl.signing
+    ed25519_sk = nacl.signing.SigningKey.generate()
+    kernel = MagicMock()
+    kernel.signer._ed25519_sk = ed25519_sk
+    kernel.signer.ed25519_public_key = bytes(ed25519_sk.verify_key)
+    kernel.tsa_client.timestamp.return_value = None
+    return kernel
+
+
+def _make_task() -> A2ATask:
+    now = datetime.now(UTC)
+    return A2ATask(
+        id="task-1",
+        status=TaskStatus.SUBMITTED,
+        created_at=now,
+        updated_at=now,
+        input={"query": "test"},
+        output=None,
+        error=None,
+    )
+
+
+def _make_card() -> AgentCard:
+    return AgentCard(
+        name="TestAgent",
+        description="A test agent",
+        version="1.0.0",
+        url="http://localhost:8080",
+        capabilities=(AgentCapability.STREAMING,),
+        skills=("summarize", "translate"),
+    )
+
+
+class TestTaskStatus:
+    def test_is_strenum(self) -> None:
+        assert issubclass(TaskStatus, StrEnum)
+
+    def test_screaming_snake_case_submitted(self) -> None:
+        assert TaskStatus.SUBMITTED == "SUBMITTED"
+
+    def test_screaming_snake_case_running(self) -> None:
+        assert TaskStatus.RUNNING == "RUNNING"
+
+    def test_screaming_snake_case_completed(self) -> None:
+        assert TaskStatus.COMPLETED == "COMPLETED"
+
+    def test_screaming_snake_case_failed(self) -> None:
+        assert TaskStatus.FAILED == "FAILED"
+
+    def test_screaming_snake_case_cancelled(self) -> None:
+        assert TaskStatus.CANCELLED == "CANCELLED"
+
+    def test_five_statuses(self) -> None:
+        assert len(TaskStatus) == 5
+
+    def test_not_lowercase(self) -> None:
+        for status in TaskStatus:
+            assert status.value == status.value.upper(), f"{status.value} is not SCREAMING_SNAKE_CASE"
+
+    def test_string_equality(self) -> None:
+        assert str(TaskStatus.SUBMITTED) == "SUBMITTED"
+
+
+class TestAgentCapability:
+    def test_is_strenum(self) -> None:
+        assert issubclass(AgentCapability, StrEnum)
+
+    def test_streaming(self) -> None:
+        assert AgentCapability.STREAMING == "STREAMING"
+
+    def test_push_notifications(self) -> None:
+        assert AgentCapability.PUSH_NOTIFICATIONS == "PUSH_NOTIFICATIONS"
+
+    def test_state_transition_history(self) -> None:
+        assert AgentCapability.STATE_TRANSITION_HISTORY == "STATE_TRANSITION_HISTORY"
+
+    def test_three_capabilities(self) -> None:
+        assert len(AgentCapability) == 3
+
+
+class TestA2ATask:
+    def test_frozen(self) -> None:
+        task = _make_task()
+        with pytest.raises((dataclasses.FrozenInstanceError, AttributeError)):
+            task.status = TaskStatus.RUNNING  # type: ignore[misc]
+
+    def test_to_dict_no_kind_field(self) -> None:
+        task = _make_task()
+        d = task.to_dict()
+        assert "kind" not in d
+
+    def test_to_dict_has_required_fields(self) -> None:
+        task = _make_task()
+        d = task.to_dict()
+        for key in ("id", "status", "created_at", "updated_at", "input"):
+            assert key in d
+
+    def test_to_dict_status_is_screaming_snake(self) -> None:
+        task = _make_task()
+        d = task.to_dict()
+        assert d["status"] == "SUBMITTED"
+
+    def test_output_absent_when_none(self) -> None:
+        task = _make_task()
+        d = task.to_dict()
+        assert "output" not in d
+
+    def test_error_absent_when_none(self) -> None:
+        task = _make_task()
+        d = task.to_dict()
+        assert "error" not in d
+
+    def test_output_present_when_set(self) -> None:
+        task = dataclasses.replace(_make_task(), output={"result": "ok"})
+        d = task.to_dict()
+        assert "output" in d
+        assert d["output"] == {"result": "ok"}
+
+    def test_error_present_when_set(self) -> None:
+        task = dataclasses.replace(_make_task(), error="something failed")
+        d = task.to_dict()
+        assert "error" in d
+        assert d["error"] == "something failed"
+
+    def test_metadata_absent_when_empty(self) -> None:
+        task = _make_task()
+        d = task.to_dict()
+        assert "metadata" not in d
+
+    def test_metadata_present_when_set(self) -> None:
+        task = dataclasses.replace(_make_task(), metadata={"foo": "bar"})
+        d = task.to_dict()
+        assert "metadata" in d
+
+    def test_to_dict_is_json_serializable(self) -> None:
+        task = _make_task()
+        json.dumps(task.to_dict())
+
+    def test_created_at_is_iso_format(self) -> None:
+        task = _make_task()
+        d = task.to_dict()
+        # Should parse as ISO 8601
+        datetime.fromisoformat(d["created_at"])
+
+
+class TestAgentCard:
+    def test_frozen(self) -> None:
+        card = _make_card()
+        with pytest.raises((dataclasses.FrozenInstanceError, AttributeError)):
+            card.name = "other"  # type: ignore[misc]
+
+    def test_to_dict_no_kind_field(self) -> None:
+        card = _make_card()
+        d = card.to_dict()
+        assert "kind" not in d
+
+    def test_to_dict_has_required_fields(self) -> None:
+        card = _make_card()
+        d = card.to_dict()
+        for key in ("name", "description", "version", "url", "capabilities", "skills"):
+            assert key in d
+
+    def test_capabilities_are_strings(self) -> None:
+        card = _make_card()
+        d = card.to_dict()
+        assert all(isinstance(c, str) for c in d["capabilities"])
+
+    def test_capabilities_are_screaming_snake(self) -> None:
+        card = _make_card()
+        d = card.to_dict()
+        for cap in d["capabilities"]:
+            assert cap == cap.upper()
+
+    def test_skills_are_list_of_strings(self) -> None:
+        card = _make_card()
+        d = card.to_dict()
+        assert isinstance(d["skills"], list)
+        assert all(isinstance(s, str) for s in d["skills"])
+
+    def test_to_dict_is_json_serializable(self) -> None:
+        card = _make_card()
+        json.dumps(card.to_dict())
+
+    def test_empty_capabilities_allowed(self) -> None:
+        card = AgentCard(
+            name="Min", description="", version="0.1", url="http://x",
+            capabilities=(), skills=(),
+        )
+        d = card.to_dict()
+        assert d["capabilities"] == []
+
+
+class TestAevumA2AInterceptor:
+    def test_create_task_returns_signed_task(self) -> None:
+        kernel = _make_kernel()
+        interceptor = AevumA2AInterceptor(kernel)
+        signed = interceptor.create_task({"query": "hello"})
+        assert isinstance(signed, SignedTask)
+
+    def test_signed_task_has_ed25519_sig(self) -> None:
+        kernel = _make_kernel()
+        interceptor = AevumA2AInterceptor(kernel)
+        signed = interceptor.create_task({"input": "test"})
+        assert len(signed.ed25519_sig) == 128
+
+    def test_signed_task_ed25519_sig_is_hex(self) -> None:
+        kernel = _make_kernel()
+        interceptor = AevumA2AInterceptor(kernel)
+        signed = interceptor.create_task({})
+        int(signed.ed25519_sig, 16)
+
+    def test_signed_task_status_is_submitted(self) -> None:
+        kernel = _make_kernel()
+        interceptor = AevumA2AInterceptor(kernel)
+        signed = interceptor.create_task({})
+        assert signed.task.status == TaskStatus.SUBMITTED
+
+    def test_to_wire_no_kind_field(self) -> None:
+        kernel = _make_kernel()
+        interceptor = AevumA2AInterceptor(kernel)
+        signed = interceptor.create_task({"q": "test"})
+        wire = signed.to_wire()
+        assert "kind" not in wire
+
+    def test_to_wire_has_aevum_envelope(self) -> None:
+        kernel = _make_kernel()
+        interceptor = AevumA2AInterceptor(kernel)
+        signed = interceptor.create_task({})
+        wire = signed.to_wire()
+        assert "_aevum" in wire
+        assert "ed25519_sig" in wire["_aevum"]
+        assert "signed_at" in wire["_aevum"]
+
+    def test_to_wire_is_json_serializable(self) -> None:
+        kernel = _make_kernel()
+        interceptor = AevumA2AInterceptor(kernel)
+        signed = interceptor.create_task({"q": "test"})
+        json.dumps(signed.to_wire())
+
+    def test_to_wire_has_task_fields(self) -> None:
+        kernel = _make_kernel()
+        interceptor = AevumA2AInterceptor(kernel)
+        signed = interceptor.create_task({"data": 1})
+        wire = signed.to_wire()
+        assert "id" in wire
+        assert "status" in wire
+        assert "input" in wire
+
+    def test_update_task_status_to_running(self) -> None:
+        kernel = _make_kernel()
+        interceptor = AevumA2AInterceptor(kernel)
+        signed = interceptor.create_task({})
+        updated = interceptor.update_task_status(signed, TaskStatus.RUNNING)
+        assert updated.task.status == TaskStatus.RUNNING
+
+    def test_update_task_completed_with_output(self) -> None:
+        kernel = _make_kernel()
+        interceptor = AevumA2AInterceptor(kernel)
+        signed = interceptor.create_task({})
+        done = interceptor.update_task_status(
+            signed, TaskStatus.COMPLETED, output={"result": "ok"}
+        )
+        assert done.task.status == TaskStatus.COMPLETED
+        assert done.task.output == {"result": "ok"}
+
+    def test_update_task_failed_with_error(self) -> None:
+        kernel = _make_kernel()
+        interceptor = AevumA2AInterceptor(kernel)
+        signed = interceptor.create_task({})
+        failed = interceptor.update_task_status(
+            signed, TaskStatus.FAILED, error="timeout"
+        )
+        assert failed.task.status == TaskStatus.FAILED
+        assert failed.task.error == "timeout"
+
+    def test_update_task_is_re_signed(self) -> None:
+        kernel = _make_kernel()
+        interceptor = AevumA2AInterceptor(kernel)
+        signed = interceptor.create_task({})
+        updated = interceptor.update_task_status(signed, TaskStatus.RUNNING)
+        # Each sign produces a new signature over new payload
+        assert isinstance(updated.ed25519_sig, str)
+        assert len(updated.ed25519_sig) == 128
+
+    def test_mldsa65_sig_none_without_oqs(self) -> None:
+        kernel = _make_kernel()
+        interceptor = AevumA2AInterceptor(kernel)
+        signed = interceptor.create_task({})
+        from aevum.core.signing import _OQS_AVAILABLE
+        if not _OQS_AVAILABLE:
+            assert signed.mldsa65_sig is None
+
+    def test_signed_at_is_recent(self) -> None:
+        kernel = _make_kernel()
+        interceptor = AevumA2AInterceptor(kernel)
+        signed = interceptor.create_task({})
+        now = datetime.now(UTC)
+        diff = abs((now - signed.signed_at).total_seconds())
+        assert diff < 5
+
+    def test_tsa_url_is_none_when_circuit_breaker_returns_none(self) -> None:
+        kernel = _make_kernel()
+        interceptor = AevumA2AInterceptor(kernel)
+        signed = interceptor.create_task({})
+        assert signed.tsa_url is None
+
+
+class TestSignedAgentCard:
+    def test_sign_returns_signed_card(self) -> None:
+        kernel = _make_kernel()
+        interceptor = AevumA2AInterceptor(kernel)
+        signed = interceptor.sign_agent_card(_make_card())
+        assert isinstance(signed, SignedAgentCard)
+
+    def test_jws_token_is_three_parts(self) -> None:
+        kernel = _make_kernel()
+        interceptor = AevumA2AInterceptor(kernel)
+        signed = interceptor.sign_agent_card(_make_card())
+        parts = signed.jws_token.split(".")
+        assert len(parts) == 3
+
+    def test_jws_header_is_correct(self) -> None:
+        kernel = _make_kernel()
+        interceptor = AevumA2AInterceptor(kernel)
+        signed = interceptor.sign_agent_card(_make_card())
+        header_b64 = signed.jws_token.split(".")[0]
+        header = json.loads(_b64url_decode(header_b64))
+        assert header["alg"] == "EdDSA"
+        assert header["crv"] == "Ed25519"
+
+    def test_jws_payload_contains_card_fields(self) -> None:
+        kernel = _make_kernel()
+        interceptor = AevumA2AInterceptor(kernel)
+        signed = interceptor.sign_agent_card(_make_card())
+        payload_b64 = signed.jws_token.split(".")[1]
+        payload = json.loads(_b64url_decode(payload_b64))
+        assert payload["name"] == "TestAgent"
+
+    def test_verify_signed_card_valid(self) -> None:
+        kernel = _make_kernel()
+        interceptor = AevumA2AInterceptor(kernel)
+        signed = interceptor.sign_agent_card(_make_card())
+        ed25519_pub = bytes(kernel.signer._ed25519_sk.verify_key)
+        assert interceptor.verify_signed_card(signed.jws_token, ed25519_pub)
+
+    def test_verify_tampered_payload_fails(self) -> None:
+        kernel = _make_kernel()
+        interceptor = AevumA2AInterceptor(kernel)
+        signed = interceptor.sign_agent_card(_make_card())
+        parts = signed.jws_token.split(".")
+        tampered_token = parts[0] + "." + _b64url(b'{"tampered":true}') + "." + parts[2]
+        ed25519_pub = bytes(kernel.signer._ed25519_sk.verify_key)
+        assert not interceptor.verify_signed_card(tampered_token, ed25519_pub)
+
+    def test_verify_wrong_key_fails(self) -> None:
+        import nacl.signing
+        kernel = _make_kernel()
+        interceptor = AevumA2AInterceptor(kernel)
+        signed = interceptor.sign_agent_card(_make_card())
+        wrong_key = bytes(nacl.signing.SigningKey.generate().verify_key)
+        assert not interceptor.verify_signed_card(signed.jws_token, wrong_key)
+
+    def test_verify_bad_format_fails(self) -> None:
+        kernel = _make_kernel()
+        interceptor = AevumA2AInterceptor(kernel)
+        assert not interceptor.verify_signed_card("not.a.valid.jws.token", b"\x00" * 32)
+
+    def test_to_well_known_response_has_jws(self) -> None:
+        kernel = _make_kernel()
+        interceptor = AevumA2AInterceptor(kernel)
+        signed = interceptor.sign_agent_card(_make_card())
+        resp = signed.to_well_known_response()
+        assert "_aevum_jws" in resp
+        assert "_aevum_signed_at" in resp
+
+    def test_to_well_known_response_has_card_fields(self) -> None:
+        kernel = _make_kernel()
+        interceptor = AevumA2AInterceptor(kernel)
+        signed = interceptor.sign_agent_card(_make_card())
+        resp = signed.to_well_known_response()
+        assert "name" in resp
+        assert resp["name"] == "TestAgent"
+
+    def test_to_well_known_response_no_kind_field(self) -> None:
+        kernel = _make_kernel()
+        interceptor = AevumA2AInterceptor(kernel)
+        signed = interceptor.sign_agent_card(_make_card())
+        resp = signed.to_well_known_response()
+        assert "kind" not in resp
+
+    def test_jws_no_padding_in_token(self) -> None:
+        kernel = _make_kernel()
+        interceptor = AevumA2AInterceptor(kernel)
+        signed = interceptor.sign_agent_card(_make_card())
+        assert "=" not in signed.jws_token
+
+
+class TestB64url:
+    def test_roundtrip(self) -> None:
+        data = b"hello world"
+        assert _b64url_decode(_b64url(data)) == data
+
+    def test_no_padding_chars(self) -> None:
+        encoded = _b64url(b"test data")
+        assert "=" not in encoded
+
+    def test_url_safe_chars_only(self) -> None:
+        encoded = _b64url(b"\xff\xfe\xfd")
+        assert "+" not in encoded
+        assert "/" not in encoded
+
+    def test_empty_bytes(self) -> None:
+        assert _b64url(b"") == ""
+
+    def test_decode_empty(self) -> None:
+        assert _b64url_decode("") == b""
+
+    def test_roundtrip_binary(self) -> None:
+        data = bytes(range(256))
+        assert _b64url_decode(_b64url(data)) == data
+
+
+class TestAevumAgentPackage:
+    def test_package_exports_task_status(self) -> None:
+        from aevum.agent import TaskStatus
+        assert TaskStatus is not None
+
+    def test_package_exports_a2a_task(self) -> None:
+        from aevum.agent import A2ATask
+        assert A2ATask is not None
+
+    def test_package_exports_agent_card(self) -> None:
+        from aevum.agent import AgentCard
+        assert AgentCard is not None
+
+    def test_package_exports_interceptor(self) -> None:
+        from aevum.agent import AevumA2AInterceptor
+        assert AevumA2AInterceptor is not None
+
+    def test_package_exports_signed_task(self) -> None:
+        from aevum.agent import SignedTask
+        assert SignedTask is not None
+
+    def test_package_exports_signed_agent_card(self) -> None:
+        from aevum.agent import SignedAgentCard
+        assert SignedAgentCard is not None
+
+    def test_package_version(self) -> None:
+        from aevum.agent import __version__
+        assert __version__ == "0.4.0"
+
+    def test_all_contains_expected_exports(self) -> None:
+        import aevum.agent
+        for name in (
+            "A2ATask", "AgentCard", "TaskStatus", "AgentCapability",
+            "AevumA2AInterceptor", "SignedTask", "SignedAgentCard",
+        ):
+            assert name in aevum.agent.__all__