mcp-blast-radius 0.2.1__tar.gz

mcp_blast_radius-0.2.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 AOS Standard Contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

mcp_blast_radius-0.2.1/PKG-INFO

@@ -0,0 +1,105 @@
+Metadata-Version: 2.4
+Name: mcp-blast-radius
+Version: 0.2.1
+Summary: See what any MCP server can touch — static blast-radius report for every target; manifest optional for divergence detection.
+Author: AOS Standard Contributors
+License-Expression: MIT
+Project-URL: Homepage, https://pypi.org/project/mcp-blast-radius/
+Project-URL: Documentation, https://github.com/aos-standard/AOS-spec#compliance-validation-official
+Project-URL: Repository, https://github.com/aos-standard/AOS-spec
+Project-URL: Issues, https://github.com/aos-standard/AOS-spec/issues
+Keywords: mcp,blast-radius,static-analysis,supply-chain,agent-security,ci-gate,mcp-server
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+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 :: Security
+Classifier: Topic :: Software Development :: Quality Assurance
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: mcp>=1.0.0
+Dynamic: license-file
+
+# MCP Blast-Radius Auditor
+
+> **See what any MCP server can actually touch — before you add it to your agent.**
+
+No manifest? You still get the full blast-radius report. Add a manifest to also catch divergences.
+
+> Also, if the server declares a manifest: **Catch an MCP server that touches files it said it wouldn't — and block the merge in CI.**
+
+Statically extract what a third-party MCP server can reach (files, network, subprocess, env) via surface-level analysis. Compare against declared boundaries when a manifest is present.
+
+## 30-second scan
+
+```bash
+pipx run mcp-blast-radius  # MCP server
+pip install . && mcp-blast-radius-gate --gate-mode blocking --target-dir /path/to/mcp-server
+```
+
+- **Red (blocking):** divergence detected — code touches paths or capabilities not declared in manifest.
+- **Green:** no divergences (or no manifest — blast radius report only, advisory pass).
+
+## Install
+
+```bash
+python3 -m venv .venv
+source .venv/bin/activate
+pip install .
+```
+
+## CLI entry
+
+```bash
+mcp-blast-radius          # MCP stdio server
+mcp-blast-radius-gate     # CI gate (default blocking, exit 1 on fail)
+```
+
+### CI blocking gate
+
+```bash
+mcp-blast-radius-gate --gate-mode blocking --target-dir .
+# no divergences → exit 0 / divergences or declaration violations → exit 1
+```
+
+## MCP tools
+
+- `aos_compliance_validate` — scan one MCP server directory (`target_dir` required; `tool_id` optional label)
+- `aos_compliance_self_test` — wiring smoke test
+
+Default `gate_mode=advisory`. Use `gate_mode=blocking` in CI to fail on divergences.
+
+## What is extracted
+
+| Layer | Scope | Confidence |
+|-------|-------|------------|
+| Dependencies | `requirements.txt`, `pyproject.toml`, `package.json` | `declared` |
+| Python AST | imports, file I/O, network, env, subprocess; MCP tool attribution | `observed-static` / `cannot-determine` |
+| Divergence | manifest `permitted_output_paths` / `oracle_paths` vs observed access | blocking when mismatch |
+
+**Limitations:** Static analysis only. Dynamic imports, `getattr`/`eval`, obfuscation, and native extensions may hide capabilities. We do not claim complete coverage — every finding includes a `confidence` label.
+
+## Environment
+
+| Variable | Purpose |
+|----------|---------|
+| `AOS_VALIDATOR_TARGET_DIR` | Default scan root when `target_dir` is omitted |
+| `AOS_VALIDATOR_MCP_LOG` | JSONL path for local tool call log (never sent externally) |
+| `AOS_VALIDATOR_CALLER` | Caller label (`ci`, `smoke_self_call`, etc.) |
+
+## Example
+
+```bash
+aos_compliance_validate target_dir=/path/to/my-mcp-server gate_mode=blocking
+```
+
+## License
+
+MIT

mcp_blast_radius-0.2.1/README.md

@@ -0,0 +1,76 @@
+# MCP Blast-Radius Auditor
+
+> **See what any MCP server can actually touch — before you add it to your agent.**
+
+No manifest? You still get the full blast-radius report. Add a manifest to also catch divergences.
+
+> Also, if the server declares a manifest: **Catch an MCP server that touches files it said it wouldn't — and block the merge in CI.**
+
+Statically extract what a third-party MCP server can reach (files, network, subprocess, env) via surface-level analysis. Compare against declared boundaries when a manifest is present.
+
+## 30-second scan
+
+```bash
+pipx run mcp-blast-radius  # MCP server
+pip install . && mcp-blast-radius-gate --gate-mode blocking --target-dir /path/to/mcp-server
+```
+
+- **Red (blocking):** divergence detected — code touches paths or capabilities not declared in manifest.
+- **Green:** no divergences (or no manifest — blast radius report only, advisory pass).
+
+## Install
+
+```bash
+python3 -m venv .venv
+source .venv/bin/activate
+pip install .
+```
+
+## CLI entry
+
+```bash
+mcp-blast-radius          # MCP stdio server
+mcp-blast-radius-gate     # CI gate (default blocking, exit 1 on fail)
+```
+
+### CI blocking gate
+
+```bash
+mcp-blast-radius-gate --gate-mode blocking --target-dir .
+# no divergences → exit 0 / divergences or declaration violations → exit 1
+```
+
+## MCP tools
+
+- `aos_compliance_validate` — scan one MCP server directory (`target_dir` required; `tool_id` optional label)
+- `aos_compliance_self_test` — wiring smoke test
+
+Default `gate_mode=advisory`. Use `gate_mode=blocking` in CI to fail on divergences.
+
+## What is extracted
+
+| Layer | Scope | Confidence |
+|-------|-------|------------|
+| Dependencies | `requirements.txt`, `pyproject.toml`, `package.json` | `declared` |
+| Python AST | imports, file I/O, network, env, subprocess; MCP tool attribution | `observed-static` / `cannot-determine` |
+| Divergence | manifest `permitted_output_paths` / `oracle_paths` vs observed access | blocking when mismatch |
+
+**Limitations:** Static analysis only. Dynamic imports, `getattr`/`eval`, obfuscation, and native extensions may hide capabilities. We do not claim complete coverage — every finding includes a `confidence` label.
+
+## Environment
+
+| Variable | Purpose |
+|----------|---------|
+| `AOS_VALIDATOR_TARGET_DIR` | Default scan root when `target_dir` is omitted |
+| `AOS_VALIDATOR_MCP_LOG` | JSONL path for local tool call log (never sent externally) |
+| `AOS_VALIDATOR_CALLER` | Caller label (`ci`, `smoke_self_call`, etc.) |
+
+## Example
+
+```bash
+aos_compliance_validate target_dir=/path/to/my-mcp-server gate_mode=blocking
+```
+
+## License
+
+MIT

mcp_blast_radius-0.2.1/aos_validator_mcp/__init__.py

@@ -0,0 +1,3 @@
+"""MCP Blast-Radius Auditor — external MCP distribution package."""
+
+__version__ = "0.2.1"

mcp_blast_radius-0.2.1/aos_validator_mcp/_validate_pure.py

@@ -0,0 +1,463 @@
+"""
+AOS Compliance Validator — pure validation functions (distribution bundle).
+
+Synced from upstream canonical source. Do not edit this file directly.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import json
+from dataclasses import asdict, dataclass, field
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any, Literal
+
+try:
+    from core.blast_radius import build_blast_radius, detect_divergences
+except ImportError:
+    from aos_validator_mcp.blast_radius import build_blast_radius, detect_divergences
+
+GateMode = Literal["advisory", "blocking"]
+
+_DEFAULT_ORACLE_PATHS = ("evals/", "config/")
+_MOCK_VIOLATION_SCORE_SIM = 80.0
+
+
+@dataclass
+class ValidationResult:
+    tool_id: str
+    scanned_at: str
+    aos_score: float
+    sections: dict[str, float]
+    blocking_reasons: list[str]
+    gate_pass: bool
+    gate_mode: str
+    blocks_next_step: bool
+    target_path: str | None = None
+    source: str = "external"
+    aos_version: str | None = None
+    oracle_violations: list[str] = field(default_factory=list)
+    permitted_violations: list[str] = field(default_factory=list)
+    remediation: list[str] = field(default_factory=list)
+    blast_radius: dict[str, Any] = field(default_factory=dict)
+    divergences: list[str] = field(default_factory=list)
+
+    def to_dict(self) -> dict[str, Any]:
+        return asdict(self)
+
+
+_AOS_SPEC_URL = "https://github.com/aos-standard/AOS-spec"
+
+
+def _build_remediation(
+    blocking: list[str],
+    oracle_v: list[str],
+    permitted_v: list[str],
+    *,
+    gate_pass: bool,
+    divergences: list[str] | None = None,
+) -> list[str]:
+    if gate_pass:
+        return []
+    blob = "\n".join(blocking + oracle_v + permitted_v + (divergences or []))
+    hints: list[str] = []
+    seen: set[str] = set()
+
+    def add(msg: str) -> None:
+        if msg not in seen:
+            seen.add(msg)
+            hints.append(msg)
+
+    if divergences:
+        add(
+            "Blast-radius divergences detected: code touches capabilities or paths not "
+            "covered by manifest declarations. Review divergences[] and align code or "
+            "update permitted_output_paths / oracle_paths."
+        )
+    if "TARGET_NOT_FOUND" in blob:
+        add(
+            "To declare AOS-v0.1 compliance, add a manifest.json (or agent_card.json) at the "
+            "repo root with: {\"aos_compliant\": \"v0.1\", \"permitted_output_paths\": "
+            "[\"<dirs you write to>\"], \"oracle_paths\": [\"<read-only dirs>\"]}. "
+            f"See {_AOS_SPEC_URL}"
+        )
+    if "AOS_UNDECLARED" in blob:
+        add(
+            "manifest.json found but not AOS-declared. Add \"aos_compliant\": \"v0.1\" plus "
+            f"permitted_output_paths / oracle_paths. See {_AOS_SPEC_URL}"
+        )
+    if "AOS_VERSION_MISMATCH" in blob:
+        add(f"Set aos_compliant to \"v0.1\" in manifest.json. See {_AOS_SPEC_URL}")
+    if "PERMITTED_PATHS_MISSING" in blob or "PERMITTED_PATH_INVALID" in blob:
+        add("Add permitted_output_paths: [\"<paths your agent may write>\"] to manifest.json.")
+    if "ORACLE_PATH_INVALID" in blob:
+        add("Fix oracle_paths entries (safe relative paths, e.g. evals/, config/).")
+    if "MANIFEST_INVALID" in blob:
+        add("Fix manifest.json syntax (valid JSON required).")
+    return hints
+
+
+def _load_manifest_data(agent_dir: Path) -> tuple[dict[str, Any] | None, str | None]:
+    for name in ("manifest.json", "agent_card.json"):
+        path = agent_dir / name
+        if not path.is_file():
+            continue
+        try:
+            return json.loads(path.read_text(encoding="utf-8")), name
+        except (json.JSONDecodeError, OSError):
+            return None, name
+    return None, None
+
+
+def resolve_agent_dir(target_dir: Path, tool_id: str | None = None) -> Path | None:
+    """Resolve agent directory by manifest.json or agent_card.json presence."""
+    root = target_dir.expanduser().resolve()
+    if not root.is_dir():
+        return None
+
+    if (root / "manifest.json").is_file() or (root / "agent_card.json").is_file():
+        return root
+
+    if tool_id:
+        tid = tool_id.strip().zfill(4)
+        for manifest in sorted(root.rglob("manifest.json")):
+            tool_path = manifest.parent
+            if tool_path.name.startswith(f"{tid}_"):
+                return tool_path
+
+    for manifest in sorted(root.rglob("manifest.json")):
+        return manifest.parent
+    for card in sorted(root.rglob("agent_card.json")):
+        return card.parent
+    return None
+
+
+def _path_entry_safe(raw: Any) -> bool:
+    if not isinstance(raw, str) or not raw.strip():
+        return False
+    if raw.startswith(("/", "\\")):
+        return False
+    return ".." not in Path(raw).parts
+
+
+def aos_boundary_blocking_reasons(
+    agent_dir: Path,
+) -> tuple[list[str], list[str], list[str], str | None]:
+    """Return blocking_reasons, oracle_violations, permitted_violations, aos_version."""
+    name = agent_dir.name
+    blocking: list[str] = []
+    oracle_v: list[str] = []
+    permitted_v: list[str] = []
+    aos_version: str | None = None
+
+    data, source_name = _load_manifest_data(agent_dir)
+    if source_name and data is None:
+        blocking.append(f"[{name}] MANIFEST_INVALID: cannot parse {source_name}")
+        return blocking, oracle_v, permitted_v, aos_version
+    if data is None:
+        return blocking, oracle_v, permitted_v, aos_version
+
+    aos_val = data.get("aos_compliant") or data.get("aos_compliance")
+    if not aos_val:
+        blocking.append(
+            f"[{name}] AOS_UNDECLARED: manifest has no aos_compliant field"
+        )
+    elif str(aos_val) != "v0.1":
+        blocking.append(
+            f"[{name}] AOS_VERSION_MISMATCH: expected v0.1, got {aos_val!r}"
+        )
+    else:
+        aos_version = "v0.1"
+
+    permitted = data.get("permitted_output_paths")
+    if not isinstance(permitted, list) or len(permitted) == 0:
+        msg = "PERMITTED_PATHS_MISSING: no permitted_output_paths declared"
+        blocking.append(f"[{name}] {msg}")
+        permitted_v.append(msg)
+    else:
+        for entry in permitted:
+            if not _path_entry_safe(entry):
+                msg = f"PERMITTED_PATH_INVALID: {entry!r}"
+                blocking.append(f"[{name}] {msg}")
+                permitted_v.append(msg)
+
+    oracle = data.get("oracle_paths")
+    if not isinstance(oracle, list) or len(oracle) == 0:
+        oracle_v.append("ORACLE_PATHS_DEFAULTED: defaults evals/, config/")
+    else:
+        for entry in oracle:
+            if not _path_entry_safe(entry):
+                msg = f"ORACLE_PATH_INVALID: {entry!r}"
+                blocking.append(f"[{name}] {msg}")
+                oracle_v.append(msg)
+
+    return blocking, oracle_v, permitted_v, aos_version
+
+
+def score_manifest_declared(agent_dir: Path) -> float:
+    data, _ = _load_manifest_data(agent_dir)
+    if not data:
+        return 0.0
+    if data.get("aos_compliant") or data.get("aos_compliance"):
+        return 25.0
+    return 0.0
+
+
+def score_oracle_declared(agent_dir: Path) -> float:
+    data, _ = _load_manifest_data(agent_dir)
+    if not data:
+        return 0.0
+    oracle = data.get("oracle_paths")
+    if isinstance(oracle, list) and len(oracle) > 0:
+        return 25.0
+    return 12.5
+
+
+def score_permitted_declared(agent_dir: Path) -> float:
+    data, _ = _load_manifest_data(agent_dir)
+    if not data:
+        return 0.0
+    permitted = data.get("permitted_output_paths")
+    if isinstance(permitted, list) and len(permitted) > 0:
+        return 25.0
+    return 0.0
+
+
+def score_path_safety(agent_dir: Path) -> float:
+    _, oracle_v, permitted_v, _ = aos_boundary_blocking_reasons(agent_dir)
+    path_errors = [v for v in oracle_v + permitted_v if "INVALID" in v or "MISSING" in v]
+    if path_errors:
+        return 0.0
+    return 25.0
+
+
+def score_sections(agent_dir: Path) -> dict[str, float]:
+    return {
+        "manifest_declared": score_manifest_declared(agent_dir),
+        "oracle_declared": score_oracle_declared(agent_dir),
+        "permitted_declared": score_permitted_declared(agent_dir),
+        "path_safety": score_path_safety(agent_dir),
+    }
+
+
+def _finalize_validation(
+    *,
+    tool_id: str,
+    scan_root: Path,
+    agent_path: Path | None,
+    gate_mode: GateMode,
+    source: str,
+) -> ValidationResult:
+    """Shared validation path: blast radius always; manifest checks when present."""
+    scanned_at = datetime.now(timezone.utc).isoformat()
+    blast = build_blast_radius(scan_root)
+
+    manifest_data: dict[str, Any] | None = None
+    aos_version: str | None = None
+    blocking: list[str] = []
+    oracle_v: list[str] = []
+    permitted_v: list[str] = []
+
+    if agent_path is not None:
+        manifest_data, _ = _load_manifest_data(agent_path)
+        if manifest_data is not None:
+            blocking, oracle_v, permitted_v, aos_version = aos_boundary_blocking_reasons(
+                agent_path
+            )
+        elif (_load_manifest_data(agent_path)[1]) is not None:
+            name = agent_path.name
+            blocking.append(f"[{name}] MANIFEST_INVALID: cannot parse manifest")
+
+    agent_name = agent_path.name if agent_path else scan_root.name
+    divergences = detect_divergences(blast, manifest_data, agent_name=agent_name)
+
+    for div in divergences:
+        blocking.append(f"DIVERGENCE: {div}")
+
+    sections = score_sections(agent_path) if agent_path and manifest_data else {}
+    aos_score = round(sum(sections.values()), 1) if sections else 0.0
+
+    gate_pass = len(blocking) == 0
+    remediation = _build_remediation(
+        blocking, oracle_v, permitted_v, gate_pass=gate_pass, divergences=divergences
+    )
+
+    return ValidationResult(
+        tool_id=tool_id,
+        scanned_at=scanned_at,
+        aos_score=aos_score,
+        sections=sections,
+        blocking_reasons=blocking,
+        gate_pass=gate_pass,
+        gate_mode=gate_mode,
+        blocks_next_step=(gate_mode == "blocking" and not gate_pass),
+        target_path=str(agent_path or scan_root),
+        source=source,
+        aos_version=aos_version,
+        oracle_violations=oracle_v,
+        permitted_violations=permitted_v,
+        remediation=remediation,
+        blast_radius=blast,
+        divergences=divergences,
+    )
+
+
+def _mock_validation(tool_id: str, gate_mode: GateMode, source: str) -> ValidationResult:
+    digest = hashlib.sha256(tool_id.encode()).hexdigest()
+    h = int(digest[:8], 16)
+    aos_score = float(h % 101)
+    mock_has_violation = aos_score < _MOCK_VIOLATION_SCORE_SIM
+    reasons = (
+        ["MOCK_VIOLATION: simulated AOS compliance gap"] if mock_has_violation else []
+    )
+    gate_pass = len(reasons) == 0
+    remediation = _build_remediation(reasons, [], [], gate_pass=gate_pass)
+    return ValidationResult(
+        tool_id=tool_id.strip().zfill(4) if tool_id.isdigit() else tool_id,
+        scanned_at="2026-06-16T00:00:00+00:00",
+        aos_score=aos_score,
+        sections={"mock": aos_score},
+        blocking_reasons=reasons,
+        gate_pass=gate_pass,
+        gate_mode=gate_mode,
+        blocks_next_step=(gate_mode == "blocking" and not gate_pass),
+        target_path=None,
+        source=source,
+        remediation=remediation,
+    )
+
+
+def validate_agent(
+    target_or_tool_id: Path | str,
+    *,
+    target_dir: Path | None = None,
+    gate_mode: GateMode = "advisory",
+    mock: bool = False,
+    source: str = "external",
+) -> ValidationResult:
+    """
+    Validate one agent directory (external) or locate by tool_id under target_dir (monorepo).
+    """
+    if target_dir is not None:
+        tool_id = str(target_or_tool_id).strip().zfill(4)
+        root = target_dir.expanduser().resolve()
+        if mock:
+            return _mock_validation(tool_id, gate_mode, source)
+        agent_path = resolve_agent_dir(root, tool_id=tool_id)
+        if agent_path is None:
+            scanned_at = datetime.now(timezone.utc).isoformat()
+            blocking = [f"AGENT_NOT_FOUND: {tool_id} under {root}"]
+            gate_pass = False
+            remediation = _build_remediation(blocking, [], [], gate_pass=gate_pass)
+            blast = build_blast_radius(root)
+            return ValidationResult(
+                tool_id=tool_id,
+                scanned_at=scanned_at,
+                aos_score=0.0,
+                sections={},
+                blocking_reasons=blocking,
+                gate_pass=gate_pass,
+                gate_mode=gate_mode,
+                blocks_next_step=(gate_mode == "blocking"),
+                target_path=str(root),
+                source=source,
+                remediation=remediation,
+                blast_radius=blast,
+                divergences=[],
+            )
+        return _finalize_validation(
+            tool_id=tool_id,
+            scan_root=root,
+            agent_path=agent_path,
+            gate_mode=gate_mode,
+            source=source,
+        )
+    else:
+        root = Path(target_or_tool_id).expanduser().resolve()
+        tool_id = root.name or "agent"
+        if mock:
+            return _mock_validation(tool_id, gate_mode, source)
+        agent_path = resolve_agent_dir(root)
+        return _finalize_validation(
+            tool_id=tool_id,
+            scan_root=root,
+            agent_path=agent_path,
+            gate_mode=gate_mode,
+            source=source,
+        )
+
+
+def emit_validation_jsonl(
+    result: ValidationResult,
+    *,
+    log_path: Path,
+    target: str | None = None,
+) -> Path:
+    log_path = log_path.expanduser()
+    log_path.parent.mkdir(parents=True, exist_ok=True)
+    entry = {
+        "ts": result.scanned_at,
+        "target": target or result.target_path or "",
+        "aos_version": result.aos_version or "v0.1",
+        "oracle_violations": result.oracle_violations,
+        "permitted_violations": result.permitted_violations,
+        "gate_pass": result.gate_pass,
+        "gate_mode": result.gate_mode,
+        "source": result.source,
+    }
+    with log_path.open("a", encoding="utf-8") as handle:
+        handle.write(json.dumps(entry, ensure_ascii=False) + "\n")
+    return log_path
+
+
+def format_json_result(result: ValidationResult) -> str:
+    return json.dumps(result.to_dict(), ensure_ascii=False, indent=2)
+
+
+def format_text_result(result: ValidationResult) -> str:
+    lines = [
+        f"gate_pass: {result.gate_pass}",
+        f"gate_mode: {result.gate_mode}",
+        f"blocks_next_step: {result.blocks_next_step}",
+        f"tool_id: {result.tool_id}",
+        f"aos_score: {result.aos_score}",
+    ]
+    if result.target_path:
+        lines.append(f"target_path: {result.target_path}")
+    if result.blocking_reasons:
+        lines.append("blocking_reasons:")
+        for reason in result.blocking_reasons:
+            lines.append(f"  - {reason}")
+    if result.oracle_violations:
+        lines.append("oracle_violations:")
+        for item in result.oracle_violations:
+            lines.append(f"  - {item}")
+    if result.permitted_violations:
+        lines.append("permitted_violations:")
+        for item in result.permitted_violations:
+            lines.append(f"  - {item}")
+    if result.divergences:
+        lines.append("divergences:")
+        for item in result.divergences:
+            lines.append(f"  - {item}")
+    if result.blast_radius:
+        br = result.blast_radius
+        lines.append(f"blast_radius: python_files={br.get('python_files', 0)} "
+                     f"scanned_files={br.get('scanned_files', 0)}")
+        caps = br.get("capabilities") or {}
+        if caps:
+            lines.append("capabilities:")
+            for cap, items in sorted(caps.items()):
+                lines.append(f"  {cap}: {len(items)} finding(s)")
+                for finding in items[:3]:
+                    conf = finding.get("confidence", "?")
+                    detail = finding.get("detail", "")
+                    lines.append(f"    - [{conf}] {detail}")
+                if len(items) > 3:
+                    lines.append(f"    ... and {len(items) - 3} more")
+    if not result.gate_pass and result.remediation:
+        lines.append("Next steps:")
+        for hint in result.remediation:
+            lines.append(f"  - {hint}")
+    return "\n".join(lines)