agentmetry 0.9.6__tar.gz → 0.9.7__tar.gz

{agentmetry-0.9.6 → agentmetry-0.9.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: agentmetry
-Version: 0.9.6
+Version: 0.9.7
 Summary: Local-first flight recorder for AI coding agents: hash-chained audit trail, MITRE-mapped sequence detection, DLP
 Project-URL: Homepage, https://agentmetry.ai
 Project-URL: Source, https://github.com/blitzcrieg1/agentmetry

{agentmetry-0.9.6 → agentmetry-0.9.7}/agentmetry/api/routes/audit.py

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+import asyncio
 from datetime import datetime, timedelta, timezone
 from pathlib import Path
 from typing import Any, Literal
@@ -100,7 +101,7 @@ class ExternalIngestBody(BaseModel):
 
     source_app: str = Field(
         ...,
-        description="cursor | claude | antigravity | codex | mcp_proxy | qwen | kimi | qoder | codebuddy | trae | crewai | opensre",
+        description="cursor | claude | antigravity | codex | copilot | mcp_proxy | qwen | kimi | qoder | codebuddy | trae | crewai | opensre",
     )
     event_type: str = Field(
         ...,
@@ -228,7 +229,7 @@ async def audit_tail(
     ),
     sources: str | None = Query(
         None,
-        description="Comma-separated source apps: agentmetry,cursor,claude,antigravity,mcp_proxy",
+        description="Comma-separated source.app values. Known names include cursor, claude, codex, copilot, antigravity, qwen, kimi, qoder, codebuddy, mcp_proxy, trae, crewai, opensre",
     ),
     since_minutes: int | None = Query(
         None,
@@ -452,6 +453,18 @@ async def audit_export_evidence():
     )
 
 
+@router.get("/machine", dependencies=[Depends(require_api_key)])
+async def machine_view():
+    """This machine's agents, posture, MCP servers and tool policy.
+
+    Read-only. The payload is the local dashboard's "This machine" page. It
+    carries no command lines, paths, or secret values.
+    """
+    from agentmetry.core.diagnostics.machine_view import snapshot
+
+    return await asyncio.to_thread(snapshot)
+
+
 @router.get("/status", dependencies=[Depends(require_api_key)])
 async def audit_status():
     """Freshness + per-source counts so the dashboard can show 'last event N min ago'.

{agentmetry-0.9.6 → agentmetry-0.9.7}/agentmetry/cli/__init__.py

@@ -529,6 +529,88 @@ def cmd_install(args: argparse.Namespace) -> int:
 _HOOK_INSTALLERS = ("cursor", "claude", "codex", "qwen", "kimi", "qoder", "codebuddy", "copilot")
 
 
+
+
+def cmd_cloud(args: argparse.Namespace) -> int:
+    """Poll a vendor cloud-agent API once and record what it exposes.
+
+    Everything this records passes through the same external ingest as the
+    hooks: canonicalized server-side, hash-chained, detected against. The
+    key comes from the environment (CURSOR_API_KEY, ANTHROPIC_COMPLIANCE_KEY)
+    and is never logged.
+    """
+    import os
+
+    import httpx
+
+    from agentmetry.core.audit.cloud_bridge import (
+        fetch_claude_messages,
+        fetch_claude_sessions,
+        fetch_cursor_agents,
+        fetch_cursor_runs,
+        map_claude_messages,
+        map_claude_session,
+        map_cursor_agent,
+    )
+
+    base = (args.url or "").strip() or None
+    posted = 0
+
+    def post(payload: dict) -> bool:
+        nonlocal posted
+        url = os.environ.get("AGENTMETRY_URL", "http://127.0.0.1:8000").rstrip("/")
+        key = os.environ.get("AGENTMETRY_API_KEY", "")
+        headers = {"Content-Type": "application/json"}
+        if key:
+            headers["Authorization"] = f"Bearer {key}"
+        resp = httpx.post(f"{url}/api/v1/audit/ingest", json=payload, headers=headers, timeout=15)
+        ok = resp.status_code < 300
+        if ok:
+            posted += 1
+        else:
+            print(f"  ingest refused ({resp.status_code}): {resp.text[:120]}")
+        return ok
+
+    if args.provider == "cursor":
+        api_key = os.environ.get("CURSOR_API_KEY", "")
+        if not api_key:
+            print("CURSOR_API_KEY is not set.")
+            return 2
+        for agent in fetch_cursor_agents(api_key, base or __import__("agentmetry.core.audit.cloud_bridge", fromlist=["CURSOR_DEFAULT_BASE"]).CURSOR_DEFAULT_BASE):
+            runs = []
+            if not args.skip_runs:
+                try:
+                    runs = fetch_cursor_runs(str(agent.get("id")), api_key, base or "https://api.cursor.com")
+                except httpx.HTTPError as exc:
+                    print(f"  runs fetch failed for {agent.get('id')}: {exc}")
+            for payload in map_cursor_agent(agent, runs):
+                post(payload)
+        print(f"cursor: {posted} events recorded.")
+        return 0
+
+    if args.provider == "claude":
+        api_key = os.environ.get("ANTHROPIC_COMPLIANCE_KEY", "")
+        if not api_key:
+            print("ANTHROPIC_COMPLIANCE_KEY is not set (a Compliance Access Key with read:compliance_user_data, not an admin key).")
+            return 2
+        kind = "remote" if args.remote else "local"
+        sessions = fetch_claude_sessions(api_key, kind=kind, base=base or "https://api.anthropic.com", limit=args.limit)
+        for session in sessions[: args.limit]:
+            post(map_claude_session(session))
+            try:
+                messages = fetch_claude_messages(api_key, kind, str(session.get("id")), base or "https://api.anthropic.com")
+            except httpx.HTTPError as exc:
+                print(f"  messages fetch failed for {session.get('id')}: {exc}")
+                continue
+            for payload in map_claude_messages(session, messages):
+                post(payload)
+        print(f"claude ({kind}): {posted} events recorded.")
+        return 0
+
+    print(f"unknown provider: {args.provider}")
+    return 2
+
+
 def _hooks_status() -> int:
     """Coverage as an exit code, for a deployment tool rather than a person.
 
@@ -1419,6 +1501,11 @@ def main(argv: list[str] | None = None) -> int:
     sub.add_parser("status", help="orchestrator health and audit export status")
     stats = sub.add_parser("stats", help="audit trail metrics for dogfood (events, detections)")
     stats.add_argument("--days", type=int, default=7)
+    cloud = sub.add_parser("cloud", help="record what a vendor cloud-agent API exposes (Cursor, Claude)")
+    cloud.add_argument("provider", choices=("cursor", "claude"))
+    cloud.add_argument("--url", default="", help="vendor API base override")
+    cloud.add_argument("--limit", type=int, default=10, help="max sessions/agents per poll")
+    cloud.add_argument("--skip-runs", action="store_true", help="cursor: agents only, skip per-run fetch")
     detections = sub.add_parser("detections", help="list detections for one session")
     detections.add_argument("correlation_id", help="correlation_id / session id")
     disposition = sub.add_parser("disposition", help="close an audit detection from the shell")
@@ -1610,6 +1697,7 @@ def main(argv: list[str] | None = None) -> int:
         "hook": cmd_hook,
         "status": cmd_status,
         "stats": cmd_stats,
+        "cloud": cmd_cloud,
         "detections": cmd_detections,
         "disposition": cmd_disposition,
         "logs": cmd_logs,

agentmetry-0.9.7/agentmetry/core/audit/cloud_bridge.py

@@ -0,0 +1,317 @@
+"""Cloud Bridge: vendor cloud-agent surfaces, recorded into the local trail.
+
+Cloud agents execute on vendor infrastructure, where no local hook can fire.
+What the vendors expose instead is an API over the agent's lifecycle, and —
+for Cursor — a live stream of its tool calls. This module turns those
+surfaces into the same external-ingest payloads the local hook client sends,
+so cloud sessions land in the same hash-chained trail, the same detections
+and the same SIEM sinks as everything else.
+
+Privacy posture, identical to the hook path: tool arguments are reduced to a
+SHA-256 over redacted, canonically serialised JSON; result and response
+bodies are hashed, never stored; no prompt or response text is forwarded.
+Vendors encode parts of their payloads (Claude delivers `tool_use.input` as a
+JSON-encoded *string*); those are decoded here, then hashed — decoding is for
+classification, never for storage.
+
+Boundary, stated once: this records what the vendor's API exposes. Cursor's
+stream covers tool calls live during a run and expires afterwards; Claude's
+Compliance API serves transcripts to an admin-scoped key. What happens inside
+a vendor VM beyond those surfaces is the vendor's custody, and this module
+does not pretend otherwise.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import json
+from typing import Any
+
+REDACT_KEYS = frozenset(
+    {"authorization", "api_key", "apikey", "password", "secret", "token", "session_key"}
+)
+_COMMAND_KEYS = ("command", "cmd", "script", "CommandLine")
+_PATH_KEYS = ("path", "filepath", "file_path", "AbsolutePath", "TargetFile")
+
+
+def redact_arguments(args: Any) -> Any:
+    if isinstance(args, dict):
+        return {
+            k: ("<redacted>" if str(k).lower() in REDACT_KEYS else v)
+            for k, v in args.items()
+        }
+    return {"value": args} if args is not None else {}
+
+
+def canonical_arguments(args: Any) -> str:
+    return json.dumps(redact_arguments(args), sort_keys=True, separators=(",", ":"), default=str)
+
+
+def hash_arguments(args: Any) -> str:
+    """SHA-256 over redacted, canonically serialised arguments.
+
+    Keep in sync with agentmetry.hooks.ingest.hash_arguments — a sync test
+    asserts both produce the same digest for the same input, so a cloud event
+    and a local event carrying the same call hash identically.
+    """
+    return hashlib.sha256(canonical_arguments(args).encode("utf-8")).hexdigest()
+
+
+def decode_maybe_encoded(value: Any) -> Any:
+    """Decode the encodings vendors put around structured fields.
+
+    Claude's Compliance API delivers `tool_use.input` as a JSON-encoded
+    string; some streams wrap payloads in base64. Decode for classification,
+    never store the decoded content: everything that reaches a canonical
+    event from here is a hash, a length or a name.
+    """
+    if not isinstance(value, str):
+        return value
+    text = value.strip()
+    if text[:1] in "{[":
+        try:
+            return json.loads(text)
+        except ValueError:
+            return value
+    try:
+        import base64
+
+        decoded = base64.b64decode(text, validate=True)
+        candidate = decoded.decode("utf-8")
+        if candidate[:1] in "{[":
+            return json.loads(candidate)
+    except (ValueError, UnicodeDecodeError):
+        # Not base64, or not UTF-8, or not JSON inside: return the original
+        # string and let the caller hash it as an opaque value.
+        return value
+    return value
+
+
+def tool_summary(args: Any) -> dict[str, Any]:
+    """The only argument content that survives: a hashed digest, a length,
+    and — for shell-shaped tools — whether the command reached a remote host.
+    Command text, paths and values do not pass through this function's output.
+    """
+    summary: dict[str, Any] = {
+        "input_hash": hash_arguments(args),
+        "input_size": len(canonical_arguments(args)),
+    }
+    if isinstance(args, dict):
+        for key in _COMMAND_KEYS:
+            val = args.get(key)
+            if isinstance(val, str) and val.strip():
+                summary["has_command"] = True
+                break
+        else:
+            for key in _PATH_KEYS:
+                if isinstance(args.get(key), str) and args[key].strip():
+                    summary["has_path"] = True
+                    break
+    return summary
+
+
+# --- Cursor Cloud Agents API -------------------------------------------------
+
+CURSOR_DEFAULT_BASE = "https://api.cursor.com"
+
+
+def map_cursor_agent(agent: dict[str, Any], runs: list[dict[str, Any]] | None = None) -> list[dict[str, Any]]:
+    """One cloud agent + its runs -> external-ingest payloads.
+
+    Cursor exposes lifecycle and outcome: agent status, run status, duration,
+    pushed branches and the PR URL. Tool-call detail is not in these
+    endpoints; when the connector attaches to a live stream (v1.1) those
+    arrive as separate tool_called events.
+    """
+    agent_id = str(agent.get("id") or "unknown")
+    status = str(agent.get("status") or "unknown")
+    out: list[dict[str, Any]] = [
+        {
+            "source_app": "cursor_cloud",
+            "adapter": "cloud_bridge",
+            "event_type": "session_start" if status == "ACTIVE" else "session_end",
+            "outcome": "success",
+            "correlation_id": f"cursor-cloud-{agent_id}",
+            "session_id": agent_id,
+            "reason": f"cloud_agent:{status}",
+        }
+    ]
+    for run in runs or []:
+        git = run.get("git") or {}
+        branches = git.get("branches") or []
+        pr_url = str(next((b.get("prUrl") for b in branches if b.get("prUrl")), "") or "")
+        out.append(
+            {
+                "source_app": "cursor_cloud",
+                "adapter": "cloud_bridge",
+                "event_type": "session_end",
+                "outcome": "success" if str(run.get("status")) == "FINISHED" else str(run.get("status") or "unknown").lower(),
+                "correlation_id": f"cursor-cloud-{agent_id}",
+                "session_id": str(run.get("id") or ""),
+                "reason": (
+                    f"cloud_run:{run.get('status')};duration_ms:{run.get('durationMs', 0)};"
+                    f"branches:{len(branches)};pr:{'yes' if pr_url else 'no'}"
+                ),
+            }
+        )
+    return out
+
+
+def map_cursor_stream_tool_call(call: dict[str, Any], agent_id: str, run_id: str) -> dict[str, Any] | None:
+    """One tool_call event from a live run stream -> a tool_called payload.
+
+    `args` arrives as an object or an encoded string; either way it becomes a
+    hash here. `result` is never forwarded — only its presence and size.
+    """
+    args = decode_maybe_encoded(call.get("args"))
+    summary = tool_summary(args)
+    name = str(call.get("name") or "unknown")
+    status = str(call.get("status") or "unknown")
+    result = call.get("result")
+    return {
+        "source_app": "cursor_cloud",
+        "adapter": "cloud_bridge",
+        "event_type": "tool_called",
+        "outcome": "success" if status == "completed" else status,
+        "correlation_id": f"cursor-cloud-{agent_id}",
+        "session_id": run_id,
+        "tool": {
+            "qualified": f"cursor_cloud.{name}",
+            "server": "cursor_cloud",
+            "input_hash": summary["input_hash"],
+            "input_size": summary["input_size"],
+            "has_result": result is not None,
+        },
+    }
+
+
+# --- Claude Compliance API ---------------------------------------------------
+
+CLAUDE_DEFAULT_BASE = "https://api.anthropic.com"
+
+
+def map_claude_tool_use(block: dict[str, Any], session_id: str) -> dict[str, Any]:
+    """One tool_use transcript block -> a tool_called payload.
+
+    Claude encodes `input` as a JSON-encoded string; decode_maybe_encoded
+    turns it back into structure so the same redact-and-hash pipeline applies
+    as for local events. Only the hash, size and tool name are forwarded.
+    """
+    decoded = decode_maybe_encoded(block.get("input"))
+    summary = tool_summary(decoded)
+    name = str(block.get("name") or "unknown")
+    truncated = bool(block.get("truncated"))
+    return {
+        "source_app": "claude_cloud",
+        "adapter": "cloud_bridge",
+        "event_type": "tool_called",
+        "outcome": "success",
+        "correlation_id": session_id,
+        "session_id": session_id,
+        "tool": {
+            "qualified": f"claude_cloud.{name}",
+            "server": "claude_cloud",
+            "input_hash": summary["input_hash"],
+            "input_size": summary["input_size"],
+            "truncated": truncated,
+        },
+    }
+
+
+def map_claude_messages(session: dict[str, Any], messages: dict[str, Any]) -> list[dict[str, Any]]:
+    """A Compliance API transcript -> tool_called payloads, one per tool_use.
+
+    Text, thinking and system content are dropped here, not stored: the
+    transcript's words belong to the vendor's retention policy, while the
+    sequence of tool calls belongs in the customer's trail.
+    """
+    session_id = str(session.get("id") or "unknown")
+    out: list[dict[str, Any]] = []
+    for message in messages.get("data", []) or []:
+        for block in message.get("content", []) or []:
+            if not isinstance(block, dict) or block.get("type") != "tool_use":
+                continue
+            out.append(map_claude_tool_use(block, session_id))
+    return out
+
+
+def map_claude_session(session: dict[str, Any]) -> dict[str, Any]:
+    """A listed session -> a session_start payload (metadata only)."""
+    return {
+        "source_app": "claude_cloud",
+        "adapter": "cloud_bridge",
+        "event_type": "session_start",
+        "outcome": "success",
+        "correlation_id": str(session.get("id") or "unknown"),
+        "session_id": str(session.get("id") or ""),
+        "reason": f"cloud_session:{session.get('created_at', '')[:10]}",
+    }
+
+
+# --- Grok Build (reserved) ----------------------------------------------------
+
+def map_grok_build_session_unsupported() -> None:
+    """Reserved for the Grok Build on-disk log parser.
+
+    Grok Build is a local CLI: its tool executions happen on this machine,
+    so the capture surface is its session logs, not a vendor cloud API. The
+    parser lands when a real session-log sample exists to write it against —
+    an invented format would be a parser that parses nothing.
+    """
+    raise NotImplementedError(
+        "grok_build capture lands with the on-disk log parser; install Grok "
+        "Build, run one session, and point the parser at its log directory."
+    )
+
+
+# --- Fetchers (poll-once semantics; the caller owns scheduling) ---------------
+
+
+def fetch_cursor_agents(api_key: str, base: str = CURSOR_DEFAULT_BASE) -> list[dict[str, Any]]:
+    import httpx
+
+    resp = httpx.get(
+        f"{base.rstrip('/')}/v1/agents",
+        headers={"Authorization": f"Bearer {api_key}"},
+        timeout=30,
+    )
+    resp.raise_for_status()
+    return resp.json().get("items", [])
+
+
+def fetch_cursor_runs(agent_id: str, api_key: str, base: str = CURSOR_DEFAULT_BASE) -> list[dict[str, Any]]:
+    import httpx
+
+    resp = httpx.get(
+        f"{base.rstrip('/')}/v1/agents/{agent_id}/runs",
+        headers={"Authorization": f"Bearer {api_key}"},
+        timeout=30,
+    )
+    resp.raise_for_status()
+    return resp.json().get("runs", []) or resp.json().get("items", [])
+
+
+def fetch_claude_sessions(api_key: str, kind: str = "local", base: str = CLAUDE_DEFAULT_BASE, limit: int = 20) -> list[dict[str, Any]]:
+    import httpx
+
+    resp = httpx.get(
+        f"{base.rstrip('/')}/v1/compliance/apps/sessions/{kind}",
+        headers={"x-api-key": api_key, "anthropic-version": "2023-06-01"},
+        params={"limit": limit},
+        timeout=30,
+    )
+    resp.raise_for_status()
+    return resp.json().get("data", [])
+
+
+def fetch_claude_messages(api_key: str, kind: str, session_id: str, base: str = CLAUDE_DEFAULT_BASE, limit: int = 500) -> dict[str, Any]:
+    import httpx
+
+    resp = httpx.get(
+        f"{base.rstrip('/')}/v1/compliance/apps/sessions/{kind}/{session_id}/messages",
+        headers={"x-api-key": api_key, "anthropic-version": "2023-06-01"},
+        params={"limit": limit},
+        timeout=30,
+    )
+    resp.raise_for_status()
+    return resp.json()

{agentmetry-0.9.6 → agentmetry-0.9.7}/agentmetry/core/audit/evidence_pack.py

@@ -27,7 +27,15 @@ from agentmetry.core.audit.run_context import resolve_operator
 from agentmetry.core.config import settings
 from agentmetry.core.version import __version__
 
-SCHEMA_VERSION = "2.1"
+SCHEMA_VERSION = "2.2"
+# One evidence export reads at most this many events. Hitting the cap used to
+# drop the rest with no mark on the pack, so a period looked complete. The pack
+# now says so in meta, and the integrity hash covers that statement.
+_EXPORT_EVENT_CAP = 200_000
+# Packs at this version and above hash `meta` (except the digest itself).
+# Older packs hashed the body only, and `verify` still accepts that scope so a
+# pack already handed to an auditor keeps verifying.
+_META_IN_INTEGRITY: tuple[int, ...] = (2, 2)
 
 
 _COMPLIANCE_MAPPING = {
@@ -79,7 +87,9 @@ _COMPLIANCE_MAPPING = {
         "audit proxy. It does not observe unmanaged assistants (browser "
         "ChatGPT, unhooked IDEs) and is not a CASB, a sandbox, or a model "
         "evaluation tool. Absence of an event is not evidence that nothing "
-        "happened outside the monitored boundary."
+        "happened outside the monitored boundary. When meta.events_truncated "
+        "is true, the export hit its event cap and this pack is a prefix of "
+        "the requested window, not the whole period."
     ),
     "disclaimer": (
         "This pack is an operator-generated audit artifact. It is not legal "
@@ -381,8 +391,39 @@ def _summarize(
     }
 
 
-def _integrity_hash(body: dict[str, Any]) -> str:
-    canonical = json.dumps(body, sort_keys=True, separators=(",", ":"), default=str)
+def _schema_tuple(version: object) -> tuple[int, ...]:
+    """`2.2` -> `(2, 2)`. A missing or non-numeric version sorts below every real one."""
+    if not isinstance(version, str) or not version:
+        return (0,)
+    parts: list[int] = []
+    for piece in version.split("."):
+        if not piece.isdigit():
+            break
+        parts.append(int(piece))
+    return tuple(parts) or (0,)
+
+
+def _covers_meta(schema_version: object) -> bool:
+    return _schema_tuple(schema_version) >= _META_IN_INTEGRITY
+
+
+def _integrity_subject(
+    body: dict[str, Any], meta: dict[str, Any] | None = None
+) -> dict[str, Any]:
+    """What the digest is computed over.
+
+    Schema 2.2 and later include `meta` with `integrity_sha256` removed, so the
+    date range, producer and trail-chain binding cannot be relabelled without
+    breaking the hash. Older packs pass `meta=None` and hash the body alone.
+    """
+    if meta is None:
+        return body
+    covered = {key: value for key, value in meta.items() if key != "integrity_sha256"}
+    return {"meta": covered, **body}
+
+
+def _integrity_hash(subject: dict[str, Any]) -> str:
+    canonical = json.dumps(subject, sort_keys=True, separators=(",", ":"), default=str)
     return hashlib.sha256(canonical.encode("utf-8")).hexdigest()
 
 
@@ -412,7 +453,10 @@ def build_evidence_pack(
         from agentmetry.core.audit.trail_db import get_trail_db
 
         trail_db = get_trail_db()
-    events = trail_db.read_between(start_ts, end_ts)
+    events = trail_db.read_between(start_ts, end_ts, limit=_EXPORT_EVENT_CAP + 1)
+    events_truncated = len(events) > _EXPORT_EVENT_CAP
+    if events_truncated:
+        events = events[:_EXPORT_EVENT_CAP]
 
     tool_calls = _extract_tool_calls(events)
     approvals = _extract_approvals(events)
@@ -449,11 +493,14 @@ def build_evidence_pack(
             "query_end_ts": end_ts,
             "source": "audit_trail",
             "raw_events_included": include_raw_events,
+            "events_truncated": events_truncated,
             "trail_chain": _trail_chain_state(),
         },
         **body,
     }
-    pack["meta"]["integrity_sha256"] = _integrity_hash(body)
+    pack["meta"]["integrity_sha256"] = _integrity_hash(
+        _integrity_subject(body, pack["meta"])
+    )
     return pack
 
 
@@ -483,8 +530,14 @@ def default_export_path(
 
 
 def verify_evidence_pack(pack: dict[str, Any]) -> tuple[bool, str]:
-    """Return (ok, message). Recomputes integrity_sha256 over the body."""
+    """Return (ok, message). Recomputes integrity_sha256.
+
+    Schema 2.2 and later cover `meta` except the digest. Earlier schemas cover
+    the body only, which is what those packs were hashed with.
+    """
     meta = pack.get("meta") or {}
+    if not isinstance(meta, dict):
+        return False, "meta must be an object"
     stored = meta.get("integrity_sha256")
     if not stored:
         return False, "missing meta.integrity_sha256"
@@ -495,7 +548,11 @@ def verify_evidence_pack(pack: dict[str, Any]) -> tuple[bool, str]:
         if not isinstance(body.get(key), dict):
             body[key] = {}
 
-    expected = _integrity_hash(body)
+    if _covers_meta(meta.get("schema_version")):
+        subject = _integrity_subject(body, meta)
+    else:
+        subject = _integrity_subject(body)
+    expected = _integrity_hash(subject)
     if expected != stored:
         return False, f"integrity mismatch (expected {expected[:16]}…, got {stored[:16]}…)"
     return True, "integrity verified"

{agentmetry-0.9.6 → agentmetry-0.9.7}/agentmetry/core/audit/external.py

@@ -20,12 +20,14 @@ from agentmetry.core.config import settings
 
 ExternalApp = Literal[
     "cursor", "claude", "antigravity", "codex", "mcp_proxy",
-    "qwen", "kimi", "qoder", "codebuddy", "trae", "crewai", "opensre", "copilot", "agentmetry",
+    "qwen", "kimi", "qoder", "codebuddy", "trae", "crewai", "opensre", "copilot", "zcode",
+    "cursor_cloud", "claude_cloud", "grok_build", "agentmetry",
 ]
 
 KNOWN_EXTERNAL_APPS = frozenset({
     "cursor", "claude", "antigravity", "codex", "mcp_proxy",
-    "qwen", "kimi", "qoder", "codebuddy", "trae", "crewai", "opensre", "copilot",
+    "qwen", "kimi", "qoder", "codebuddy", "trae", "crewai", "opensre", "copilot", "zcode",
+    "cursor_cloud", "claude_cloud", "grok_build",
 })
 
 _ACTION_MAP = {