chp-adapter-audit 0.8.0__tar.gz

chp_adapter_audit-0.8.0/.gitignore

@@ -0,0 +1,23 @@
+node_modules/
+dist/
+.yalc/
+yalc.lock
+*.tgz
+.env
+.env.*
+coverage/
+dashboard/
+components/
+.tech-hub-cache/
+__pycache__/
+*.py[cod]
+.pytest_cache/
+.chp/
+.DS_Store
+.coverage
+.forge/
+.hypothesis/
+.claude/
+
+# chp-agent evidence store
+.chp-agent/sessions.sqlite

chp_adapter_audit-0.8.0/PKG-INFO

@@ -0,0 +1,20 @@
+Metadata-Version: 2.4
+Name: chp-adapter-audit
+Version: 0.8.0
+Summary: CHP capability adapter — queryable audit log over the host evidence store
+Author: Auxo
+License: Apache-2.0
+Keywords: adapter,audit,capability-host-protocol,chp,evidence,governance
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.10
+Requires-Dist: chp-core>=0.7.0
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0; extra == 'dev'

chp_adapter_audit-0.8.0/chp_adapter_audit/__init__.py

@@ -0,0 +1,20 @@
+"""chp-adapter-audit — queryable audit log over the CHP host evidence store.
+
+Exposes three capabilities: ``query_invocations``, ``get_invocation``, and
+``stats``. Uses ``on_register(host)`` to capture the host's evidence store.
+An injectable ``store`` on the config allows tests to bypass the host.
+
+Usage::
+
+    from chp_core import LocalCapabilityHost, register_adapter
+    from chp_adapter_audit import AuditAdapter, AuditConfig
+
+    host = LocalCapabilityHost()
+    register_adapter(host, AuditAdapter())  # binds to host.store automatically
+"""
+
+from __future__ import annotations
+
+from .adapter import AuditAdapter, AuditConfig
+
+__all__ = ["AuditAdapter", "AuditConfig"]

chp_adapter_audit-0.8.0/chp_adapter_audit/adapter.py

@@ -0,0 +1,390 @@
+"""AuditAdapter — queryable governance audit log over the CHP evidence store.
+
+Three capabilities:
+
+* ``query_invocations`` — filter by capability_id, outcome, time window, limit;
+  returns per-invocation summaries (never raw event payloads).
+* ``get_invocation`` — fetch all events for one invocation_id; returns only
+  metadata (event_type, timestamp, outcome) to avoid leaking sensitive payloads
+  that may have been stored by other adapters.
+* ``stats`` — aggregate counts by outcome and by capability over a time window.
+
+Evidence hygiene: only counts, IDs, event_types, and timestamps are stored or
+returned. The stored event payloads (which may carry PII, tokens, or secrets
+from other adapters) are NEVER included in audit evidence or return values.
+"""
+
+from __future__ import annotations
+
+from collections import defaultdict
+from dataclasses import dataclass
+from typing import Any
+
+from chp_core import BaseAdapter, capability
+
+_EMITS = ["audit_query", "audit_result", "audit_error"]
+
+
+@dataclass
+class AuditConfig:
+    """Config for AuditAdapter.
+
+    ``max_results`` caps the maximum rows returned by any query.
+    ``store`` is injectable for tests (bypasses host.store binding).
+    """
+
+    max_results: int = 1000
+    store: Any = None
+
+
+class AuditAdapter(BaseAdapter):
+    """Static adapter exposing the host's evidence store as governed capabilities."""
+
+    adapter_id = "chp.adapters.audit"
+    adapter_name = "Audit Log"
+    adapter_description = "Query the CHP evidence store with filters and aggregate stats."
+    adapter_category = "governance"
+    adapter_tags = ["audit", "governance", "evidence", "meta"]
+
+    def __init__(self, config: AuditConfig | None = None) -> None:
+        self._config = config or AuditConfig()
+        self._store: Any = self._config.store  # None until on_register if not injected
+
+    def on_register(self, host: Any) -> None:
+        if self._store is None:
+            self._store = host.store
+
+    # ------------------------------------------------------------------
+    # query_invocations
+    # ------------------------------------------------------------------
+
+    @capability(
+        id="chp.adapters.audit.query_invocations",
+        version="1.0.0",
+        description="Query invocation records from the audit log with optional filters.",
+        category="governance",
+        risk="low",
+        input_schema={
+            "type": "object",
+            "properties": {
+                "capability_id": {"type": "string", "description": "Filter by exact capability ID."},
+                "outcome": {
+                    "type": "string",
+                    "enum": ["success", "failure", "denied", "skipped"],
+                    "description": "Filter by invocation outcome.",
+                },
+                "since": {"type": "string", "description": "ISO-8601 lower bound (inclusive)."},
+                "until": {"type": "string", "description": "ISO-8601 upper bound (inclusive)."},
+                "limit": {"type": "integer", "minimum": 1, "default": 100},
+            },
+            "additionalProperties": False,
+        },
+        emits=_EMITS,
+        tags=["audit", "governance"],
+    )
+    async def query_invocations(self, ctx: Any, payload: dict) -> dict:
+        if self._store is None:
+            ctx.emit("audit_error", {"reason": "store_not_bound"}, redacted=False)
+            raise RuntimeError("AuditAdapter: store not bound — register with a host first")
+
+        limit = min(payload.get("limit") or 100, self._config.max_results)
+        cap_id = payload.get("capability_id")
+        outcome = payload.get("outcome")
+        since = payload.get("since")
+        until = payload.get("until")
+
+        ctx.emit("audit_query", {
+            "op": "query_invocations",
+            "filters": {k: v for k, v in {
+                "capability_id": cap_id, "outcome": outcome, "since": since, "until": until,
+            }.items() if v is not None},
+            "limit": limit,
+        }, redacted=False)
+
+        events = self._store.query(
+            capability_id=cap_id,
+            outcome=outcome,
+            since=since,
+            until=until,
+            limit=limit * 10,  # over-fetch to group by invocation
+        )
+
+        # Exclude the current audit invocation so it doesn't appear in results
+        current_inv_id = ctx.envelope.invocation_id
+        events = [e for e in events if e.get("invocation_id") != current_inv_id]
+
+        invocations = _group_by_invocation(events, limit)
+
+        ctx.emit("audit_result", {
+            "op": "query_invocations",
+            "total": len(invocations),
+        }, redacted=False)
+
+        return {"invocations": invocations, "total": len(invocations)}
+
+    # ------------------------------------------------------------------
+    # get_invocation
+    # ------------------------------------------------------------------
+
+    @capability(
+        id="chp.adapters.audit.get_invocation",
+        version="1.0.0",
+        description="Fetch event metadata for a specific invocation ID.",
+        category="governance",
+        risk="low",
+        input_schema={
+            "type": "object",
+            "properties": {
+                "invocation_id": {"type": "string"},
+            },
+            "required": ["invocation_id"],
+            "additionalProperties": False,
+        },
+        emits=_EMITS,
+        tags=["audit", "governance"],
+    )
+    async def get_invocation(self, ctx: Any, payload: dict) -> dict:
+        if self._store is None:
+            ctx.emit("audit_error", {"reason": "store_not_bound"}, redacted=False)
+            raise RuntimeError("AuditAdapter: store not bound")
+
+        invocation_id = payload["invocation_id"]
+
+        ctx.emit("audit_query", {
+            "op": "get_invocation",
+            "invocation_id": invocation_id,
+        }, redacted=False)
+
+        events = self._store.by_invocation(invocation_id)
+
+        if not events:
+            ctx.emit("audit_error", {
+                "reason": "not_found", "invocation_id": invocation_id,
+            }, redacted=False)
+            raise ValueError(f"Invocation not found: {invocation_id!r}")
+
+        # Strip payloads — only metadata (event_type, timestamp, outcome) returned
+        stripped = [
+            {
+                "event_id": e.get("event_id"),
+                "event_type": e.get("event_type"),
+                "timestamp": e.get("timestamp"),
+                "outcome": e.get("outcome"),
+                "sequence": e.get("sequence"),
+            }
+            for e in events
+        ]
+
+        ctx.emit("audit_result", {
+            "op": "get_invocation",
+            "invocation_id": invocation_id,
+            "event_count": len(stripped),
+        }, redacted=False)
+
+        return {
+            "invocation_id": invocation_id,
+            "events": stripped,
+            "event_count": len(stripped),
+        }
+
+    # ------------------------------------------------------------------
+    # token_report
+    # ------------------------------------------------------------------
+
+    @capability(
+        id="chp.adapters.audit.token_report",
+        version="1.0.0",
+        description=(
+            "Aggregate sovereign inference token usage by model. Returns per-model "
+            "token totals, call counts, backfill summary (calls before token tracking "
+            "was added on 2026-06-17), and estimated frontier-equivalent cost."
+        ),
+        category="observability",
+        risk="low",
+        input_schema={
+            "type": "object",
+            "properties": {
+                "since": {"type": "string", "description": "ISO-8601 lower bound."},
+                "until": {"type": "string", "description": "ISO-8601 upper bound."},
+                "frontier_price_per_1m_input": {
+                    "type": "number",
+                    "description": "Frontier input token price per 1M tokens (default 3.0, Claude Sonnet rate).",
+                },
+                "frontier_price_per_1m_output": {
+                    "type": "number",
+                    "description": "Frontier output token price per 1M tokens (default 15.0, Claude Sonnet rate).",
+                },
+            },
+            "additionalProperties": False,
+        },
+        emits=_EMITS,
+        tags=["audit", "governance", "tokens", "observability"],
+    )
+    async def token_report(self, ctx: Any, payload: dict) -> dict:
+        if self._store is None:
+            ctx.emit("audit_error", {"reason": "store_not_bound"}, redacted=False)
+            raise RuntimeError("AuditAdapter: store not bound")
+
+        since = payload.get("since")
+        until = payload.get("until")
+        input_price = float(payload.get("frontier_price_per_1m_input") or 3.0)
+        output_price = float(payload.get("frontier_price_per_1m_output") or 15.0)
+
+        ctx.emit("audit_query", {"op": "token_report", "since": since, "until": until}, redacted=False)
+
+        events = self._store.query(
+            capability_id="chp.adapters.http.request",
+            since=since,
+            until=until,
+        )
+        http_responses = [e for e in events if e.get("event_type") == "http_response"]
+
+        with_tokens = [e for e in http_responses if "prompt_tokens" in e.get("payload", {})]
+        without_tokens = [e for e in http_responses if "prompt_tokens" not in e.get("payload", {})]
+
+        by_model: dict[str, dict] = {}
+        for e in with_tokens:
+            p = e["payload"]
+            m = p.get("model", "unknown")
+            rec = by_model.setdefault(m, {"model": m, "prompt_tokens": 0, "completion_tokens": 0, "calls": 0})
+            rec["prompt_tokens"] += p.get("prompt_tokens", 0)
+            rec["completion_tokens"] += p.get("completion_tokens", 0)
+            rec["calls"] += 1
+
+        total_prompt = sum(r["prompt_tokens"] for r in by_model.values())
+        total_completion = sum(r["completion_tokens"] for r in by_model.values())
+        frontier_cost = (
+            total_prompt / 1_000_000 * input_price
+            + total_completion / 1_000_000 * output_price
+        )
+
+        earliest_tracked = min(
+            (e["timestamp"] for e in with_tokens if e.get("timestamp")), default=None
+        )
+
+        result = {
+            "window": {"since": since, "until": until},
+            "sovereign": {
+                "total_prompt_tokens": total_prompt,
+                "total_completion_tokens": total_completion,
+                "total_tokens": total_prompt + total_completion,
+                "by_model": sorted(by_model.values(), key=lambda r: -r["calls"]),
+            },
+            "backfill": {
+                "calls_without_token_data": len(without_tokens),
+                "note": "Calls before token tracking (2026-06-17). Counts only, no token data.",
+                "earliest_tracked": earliest_tracked,
+            },
+            "estimated_frontier_cost_usd": round(frontier_cost, 4),
+            "pricing_basis": f"${input_price}/1M input, ${output_price}/1M output (Claude Sonnet rates)",
+        }
+
+        ctx.emit("audit_result", {
+            "op": "token_report",
+            "total_tokens": total_prompt + total_completion,
+            "models": list(by_model.keys()),
+        }, redacted=False)
+        return result
+
+    # ------------------------------------------------------------------
+    # stats
+    # ------------------------------------------------------------------
+
+    @capability(
+        id="chp.adapters.audit.stats",
+        version="1.0.0",
+        description="Aggregate invocation counts by outcome and capability over a time window.",
+        category="governance",
+        risk="low",
+        input_schema={
+            "type": "object",
+            "properties": {
+                "since": {"type": "string", "description": "ISO-8601 lower bound."},
+                "until": {"type": "string", "description": "ISO-8601 upper bound."},
+            },
+            "additionalProperties": False,
+        },
+        emits=_EMITS,
+        tags=["audit", "governance"],
+    )
+    async def stats(self, ctx: Any, payload: dict) -> dict:
+        if self._store is None:
+            ctx.emit("audit_error", {"reason": "store_not_bound"}, redacted=False)
+            raise RuntimeError("AuditAdapter: store not bound")
+
+        since = payload.get("since")
+        until = payload.get("until")
+
+        ctx.emit("audit_query", {
+            "op": "stats",
+            "since": since,
+            "until": until,
+        }, redacted=False)
+
+        events = self._store.query(since=since, until=until)
+
+        # Exclude the current audit invocation
+        current_inv_id = ctx.envelope.invocation_id
+        events = [e for e in events if e.get("invocation_id") != current_inv_id]
+
+        # Count only terminal lifecycle events (execution_started = one per invocation)
+        started = [e for e in events if e.get("event_type") == "execution_started"]
+        total = len(started)
+
+        by_outcome: dict[str, int] = defaultdict(int)
+        by_cap: dict[str, int] = defaultdict(int)
+        for e in started:
+            out = e.get("outcome") or "unknown"
+            by_outcome[out] += 1
+            cap = e.get("capability_id") or "unknown"
+            by_cap[cap] += 1
+
+        error_rate = (by_outcome.get("failure", 0) / total) if total > 0 else 0.0
+        by_capability = sorted(
+            [{"id": k, "count": v} for k, v in by_cap.items()],
+            key=lambda x: x["count"],
+            reverse=True,
+        )
+
+        ctx.emit("audit_result", {
+            "op": "stats",
+            "total_invocations": total,
+        }, redacted=False)
+
+        return {
+            "total_invocations": total,
+            "by_outcome": dict(by_outcome),
+            "by_capability": by_capability,
+            "error_rate": round(error_rate, 4),
+        }
+
+
+# --------------------------------------------------------------------------
+# Helpers
+# --------------------------------------------------------------------------
+
+def _group_by_invocation(events: list[dict], limit: int) -> list[dict]:
+    """Group a flat event list into per-invocation summaries, capped at ``limit``."""
+    seen: dict[str, dict] = {}
+    for e in events:
+        inv_id = e.get("invocation_id")
+        if inv_id is None:
+            continue
+        if inv_id not in seen:
+            if len(seen) >= limit:
+                continue
+            seen[inv_id] = {
+                "invocation_id": inv_id,
+                "capability_id": e.get("capability_id"),
+                "started_at": e.get("timestamp"),
+                "outcome": None,
+                "event_count": 0,
+            }
+        seen[inv_id]["event_count"] += 1
+        # Capture outcome from terminal lifecycle event
+        if e.get("event_type") in ("execution_completed", "execution_failed", "execution_denied"):
+            seen[inv_id]["outcome"] = e.get("outcome")
+        if e.get("timestamp"):
+            seen[inv_id]["completed_at"] = e.get("timestamp")
+
+    return list(seen.values())

chp_adapter_audit-0.8.0/pyproject.toml

@@ -0,0 +1,40 @@
+[build-system]
+requires = ["hatchling>=1.25"]
+build-backend = "hatchling.build"
+
+[project]
+name = "chp-adapter-audit"
+version = "0.8.0"
+description = "CHP capability adapter — queryable audit log over the host evidence store"
+readme = "README.md"
+requires-python = ">=3.10"
+license = { text = "Apache-2.0" }
+authors = [{ name = "Auxo" }]
+keywords = ["chp", "capability-host-protocol", "audit", "evidence", "governance", "adapter"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: Apache Software License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+]
+dependencies = [
+    "chp-core>=0.7.0",
+]
+
+[project.entry-points."chp.adapters"]
+audit = "chp_adapter_audit:AuditAdapter"
+
+[project.optional-dependencies]
+dev = ["pytest>=8.0"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+pythonpath = ["."]
+
+[tool.hatch.build.targets.wheel]
+packages = ["chp_adapter_audit"]

chp_adapter_audit-0.8.0/tests/test_audit_adapter.py

@@ -0,0 +1,377 @@
+"""Tests for chp_adapter_audit.adapter."""
+
+from __future__ import annotations
+
+import pytest
+
+from chp_core import LocalCapabilityHost, capability, register_adapter
+from chp_core.store import SQLiteEvidenceStore
+
+from chp_adapter_audit import AuditAdapter, AuditConfig
+
+
+# --------------------------------------------------------------------------
+# Minimal echo adapter to generate invocation evidence
+# --------------------------------------------------------------------------
+
+class _EchoAdapter:
+    adapter_id = "chp.adapters.echo"
+
+    @capability(
+        id="chp.adapters.echo.ping",
+        version="1.0.0",
+        description="Echo.",
+        risk="low",
+        input_schema={
+            "type": "object",
+            "properties": {"msg": {"type": "string"}},
+            "additionalProperties": False,
+        },
+    )
+    async def ping(self, ctx, payload):
+        return {"pong": payload.get("msg", "")}
+
+    @capability(
+        id="chp.adapters.echo.fail",
+        version="1.0.0",
+        description="Always fails.",
+        risk="low",
+        input_schema={"type": "object", "properties": {}, "additionalProperties": False},
+    )
+    async def fail(self, ctx, payload):
+        raise RuntimeError("forced failure")
+
+    def capabilities(self):
+        from chp_core.adapters import HostedCapability
+        from chp_core.decorators import adapt_callable, get_capability_descriptor
+        import inspect
+        for _, method in inspect.getmembers(self, predicate=inspect.ismethod):
+            desc = get_capability_descriptor(method.__func__)
+            if desc is not None:
+                yield HostedCapability(descriptor=desc, handler=adapt_callable(method))
+
+
+def _make_host():
+    host = LocalCapabilityHost(store=SQLiteEvidenceStore(":memory:"))
+    register_adapter(host, _EchoAdapter())
+    register_adapter(host, AuditAdapter())
+    return host
+
+
+def _cap_events(store):
+    return [e for e in store.all() if "capability_uri" not in e["payload"]]
+
+
+# --------------------------------------------------------------------------
+# 1. Shaping
+# --------------------------------------------------------------------------
+
+class TestShaping:
+    def test_capability_ids(self):
+        host = _make_host()
+        ids = {c.descriptor.id for c in AuditAdapter().capabilities()}
+        assert ids == {
+            "chp.adapters.audit.query_invocations",
+            "chp.adapters.audit.get_invocation",
+            "chp.adapters.audit.stats",
+            "chp.adapters.audit.token_report",
+        }
+
+    def test_all_risk_low(self):
+        for cap in AuditAdapter().capabilities():
+            assert cap.descriptor.risk == "low"
+
+
+# --------------------------------------------------------------------------
+# 2. query_invocations
+# --------------------------------------------------------------------------
+
+class TestQueryInvocations:
+    def test_empty_store(self):
+        host = _make_host()
+        r = host.invoke("chp.adapters.audit.query_invocations", {})
+        assert r.outcome == "success"
+        assert r.data["total"] == 0
+        assert r.data["invocations"] == []
+
+    def test_returns_after_invocations(self):
+        host = _make_host()
+        host.invoke("chp.adapters.echo.ping", {"msg": "a"})
+        host.invoke("chp.adapters.echo.ping", {"msg": "b"})
+        r = host.invoke("chp.adapters.audit.query_invocations", {})
+        assert r.data["total"] == 2
+
+    def test_filter_by_capability_id(self):
+        host = _make_host()
+        host.invoke("chp.adapters.echo.ping", {"msg": "a"})
+        host.invoke("chp.adapters.echo.fail", {})
+        r = host.invoke("chp.adapters.audit.query_invocations",
+                        {"capability_id": "chp.adapters.echo.ping"})
+        assert r.data["total"] == 1
+        assert r.data["invocations"][0]["capability_id"] == "chp.adapters.echo.ping"
+
+    def test_filter_by_outcome(self):
+        host = _make_host()
+        host.invoke("chp.adapters.echo.ping", {"msg": "a"})
+        host.invoke("chp.adapters.echo.fail", {})
+        r = host.invoke("chp.adapters.audit.query_invocations", {"outcome": "success"})
+        # Only ping should appear
+        assert all(inv["outcome"] in ("success", None) for inv in r.data["invocations"])
+
+    def test_invocation_summary_keys(self):
+        host = _make_host()
+        host.invoke("chp.adapters.echo.ping", {"msg": "a"})
+        r = host.invoke("chp.adapters.audit.query_invocations", {})
+        inv = r.data["invocations"][0]
+        assert "invocation_id" in inv
+        assert "capability_id" in inv
+        assert "event_count" in inv
+
+    def test_payloads_never_in_invocation_summary(self):
+        host = _make_host()
+        host.invoke("chp.adapters.echo.ping", {"msg": "super_secret_value"})
+        r = host.invoke("chp.adapters.audit.query_invocations", {})
+        dump = str(r.data["invocations"])
+        assert "super_secret_value" not in dump
+
+    def test_extra_field_denied(self):
+        host = _make_host()
+        r = host.invoke("chp.adapters.audit.query_invocations", {"injected": "bad"})
+        assert r.outcome == "denied"
+
+
+# --------------------------------------------------------------------------
+# 3. get_invocation
+# --------------------------------------------------------------------------
+
+class TestGetInvocation:
+    def test_returns_event_metadata(self):
+        host = _make_host()
+        result = host.invoke("chp.adapters.echo.ping", {"msg": "test"})
+        inv_id = result.invocation_id
+
+        r = host.invoke("chp.adapters.audit.get_invocation", {"invocation_id": inv_id})
+        assert r.outcome == "success"
+        assert r.data["invocation_id"] == inv_id
+        assert r.data["event_count"] > 0
+
+    def test_events_have_type_and_timestamp(self):
+        host = _make_host()
+        result = host.invoke("chp.adapters.echo.ping", {"msg": "test"})
+        r = host.invoke("chp.adapters.audit.get_invocation",
+                        {"invocation_id": result.invocation_id})
+        evt = r.data["events"][0]
+        assert "event_type" in evt
+        assert "timestamp" in evt
+
+    def test_payloads_stripped_from_events(self):
+        host = _make_host()
+        result = host.invoke("chp.adapters.echo.ping", {"msg": "another_secret"})
+        r = host.invoke("chp.adapters.audit.get_invocation",
+                        {"invocation_id": result.invocation_id})
+        dump = str(r.data["events"])
+        assert "another_secret" not in dump
+        assert "payload" not in dump
+
+    def test_not_found_fails(self):
+        host = _make_host()
+        r = host.invoke("chp.adapters.audit.get_invocation",
+                        {"invocation_id": "nonexistent-id"})
+        assert r.outcome == "failure"
+
+
+# --------------------------------------------------------------------------
+# 4. stats
+# --------------------------------------------------------------------------
+
+class TestStats:
+    def test_empty_store_returns_zeros(self):
+        host = _make_host()
+        r = host.invoke("chp.adapters.audit.stats", {})
+        assert r.outcome == "success"
+        assert r.data["total_invocations"] == 0
+        assert r.data["error_rate"] == 0.0
+
+    def test_counts_invocations(self):
+        host = _make_host()
+        host.invoke("chp.adapters.echo.ping", {"msg": "a"})
+        host.invoke("chp.adapters.echo.ping", {"msg": "b"})
+        host.invoke("chp.adapters.echo.fail", {})
+        r = host.invoke("chp.adapters.audit.stats", {})
+        assert r.data["total_invocations"] >= 3
+
+    def test_by_outcome_present(self):
+        host = _make_host()
+        host.invoke("chp.adapters.echo.ping", {"msg": "a"})
+        r = host.invoke("chp.adapters.audit.stats", {})
+        assert "by_outcome" in r.data
+
+    def test_by_capability_sorted_desc(self):
+        host = _make_host()
+        host.invoke("chp.adapters.echo.ping", {"msg": "a"})
+        host.invoke("chp.adapters.echo.ping", {"msg": "b"})
+        host.invoke("chp.adapters.echo.fail", {})
+        r = host.invoke("chp.adapters.audit.stats", {})
+        by_cap = r.data["by_capability"]
+        if len(by_cap) > 1:
+            assert by_cap[0]["count"] >= by_cap[1]["count"]
+
+    def test_error_rate_computed(self):
+        host = _make_host()
+        host.invoke("chp.adapters.echo.ping", {"msg": "ok"})
+        host.invoke("chp.adapters.echo.fail", {})
+        r = host.invoke("chp.adapters.audit.stats", {})
+        assert 0.0 <= r.data["error_rate"] <= 1.0
+
+
+# --------------------------------------------------------------------------
+# 5. Evidence from audit adapter itself
+# --------------------------------------------------------------------------
+
+class TestAuditEvidence:
+    def _audit_events(self, store):
+        return [
+            e for e in store.all()
+            if e.get("capability_id", "").startswith("chp.adapters.audit")
+            and e.get("event_type") not in ("execution_started", "execution_completed", "execution_failed")
+        ]
+
+    def test_query_emits_audit_events(self):
+        host = _make_host()
+        host.invoke("chp.adapters.audit.query_invocations", {})
+        types = [e["event_type"] for e in self._audit_events(host.store)]
+        assert "audit_query" in types
+        assert "audit_result" in types
+
+    def test_stats_emits_audit_events(self):
+        host = _make_host()
+        host.invoke("chp.adapters.audit.stats", {})
+        types = [e["event_type"] for e in self._audit_events(host.store)]
+        assert "audit_query" in types
+        assert "audit_result" in types
+
+
+# --------------------------------------------------------------------------
+# 6. Injectable store
+# --------------------------------------------------------------------------
+
+class TestInjectableStore:
+    def test_injectable_store_works(self):
+        store = SQLiteEvidenceStore(":memory:")
+        # Pre-populate store by creating a host and making calls
+        host = LocalCapabilityHost(store=store)
+        register_adapter(host, _EchoAdapter())
+        host.invoke("chp.adapters.echo.ping", {"msg": "hello"})
+
+        # Now create audit adapter with injected store (no host registration needed)
+        audit = AuditAdapter(AuditConfig(store=store))
+        audit_host = LocalCapabilityHost(store=SQLiteEvidenceStore(":memory:"))
+        register_adapter(audit_host, audit)
+
+        r = audit_host.invoke("chp.adapters.audit.query_invocations", {})
+        assert r.outcome == "success"
+        assert r.data["total"] >= 1
+
+
+# --------------------------------------------------------------------------
+# 7. token_report
+# --------------------------------------------------------------------------
+
+def _seed_http_response_events(store, entries):
+    """Seed the store with synthetic http_response events for token_report tests."""
+    from chp_core.types import ExecutionEvidence, CorrelationContext, new_id
+
+    for entry in entries:
+        payload = {
+            "method": "POST",
+            "url": "http://localhost:8092/v1/chat/completions",
+            "status_code": 200,
+            "content_type": "application/json",
+            "body_length": 100,
+            "truncated": False,
+            "duration_ms": 250,
+        }
+        if "model" in entry:
+            payload.update({
+                "prompt_tokens": entry["prompt"],
+                "completion_tokens": entry["completion"],
+                "total_tokens": entry["prompt"] + entry["completion"],
+                "model": entry["model"],
+            })
+        store.append(ExecutionEvidence(
+            event_id=new_id("evt"),
+            event_type="http_response",
+            invocation_id=new_id("inv"),
+            capability_id="chp.adapters.http.request",
+            capability_version="1.0.0",
+            host_id="test-host",
+            correlation=CorrelationContext(),
+            outcome="success",
+            payload=payload,
+            redacted=False,
+        ))
+
+
+class TestTokenReport:
+    def _make_audit_with_store(self):
+        store = SQLiteEvidenceStore(":memory:")
+        audit = AuditAdapter(AuditConfig(store=store))
+        audit_host = LocalCapabilityHost(store=SQLiteEvidenceStore(":memory:"))
+        register_adapter(audit_host, audit)
+        return audit_host, store
+
+    def test_empty_store_returns_zeros(self):
+        host, _ = self._make_audit_with_store()
+        r = host.invoke("chp.adapters.audit.token_report", {})
+        assert r.outcome == "success"
+        assert r.data["sovereign"]["total_tokens"] == 0
+        assert r.data["sovereign"]["by_model"] == []
+        assert r.data["estimated_frontier_cost_usd"] == 0.0
+        assert r.data["backfill"]["calls_without_token_data"] == 0
+
+    def test_aggregates_by_model(self):
+        host, store = self._make_audit_with_store()
+        _seed_http_response_events(store, [
+            {"model": "fastcontext", "prompt": 100, "completion": 50},
+            {"model": "fastcontext", "prompt": 200, "completion": 80},
+            {"model": "vllm-qwen", "prompt": 300, "completion": 120},
+        ])
+        r = host.invoke("chp.adapters.audit.token_report", {})
+        assert r.outcome == "success"
+        by_model = {m["model"]: m for m in r.data["sovereign"]["by_model"]}
+        assert by_model["fastcontext"]["prompt_tokens"] == 300
+        assert by_model["fastcontext"]["completion_tokens"] == 130
+        assert by_model["fastcontext"]["calls"] == 2
+        assert by_model["vllm-qwen"]["calls"] == 1
+        assert r.data["sovereign"]["total_prompt_tokens"] == 600
+        assert r.data["sovereign"]["total_completion_tokens"] == 250
+
+    def test_backfill_counts_events_without_tokens(self):
+        host, store = self._make_audit_with_store()
+        _seed_http_response_events(store, [
+            {"model": "fastcontext", "prompt": 50, "completion": 20},
+            {},  # no model/tokens — pre-tracking
+            {},  # no model/tokens — pre-tracking
+        ])
+        r = host.invoke("chp.adapters.audit.token_report", {})
+        assert r.data["backfill"]["calls_without_token_data"] == 2
+
+    def test_frontier_cost_calculation(self):
+        host, store = self._make_audit_with_store()
+        _seed_http_response_events(store, [
+            {"model": "fastcontext", "prompt": 1_000_000, "completion": 1_000_000},
+        ])
+        # Default: $3/1M input, $15/1M output → $3 + $15 = $18
+        r = host.invoke("chp.adapters.audit.token_report", {})
+        assert r.data["estimated_frontier_cost_usd"] == 18.0
+
+    def test_custom_pricing(self):
+        host, store = self._make_audit_with_store()
+        _seed_http_response_events(store, [
+            {"model": "fastcontext", "prompt": 1_000_000, "completion": 0},
+        ])
+        r = host.invoke("chp.adapters.audit.token_report", {
+            "frontier_price_per_1m_input": 5.0,
+            "frontier_price_per_1m_output": 20.0,
+        })
+        assert r.data["estimated_frontier_cost_usd"] == 5.0