opencomplai-cli 0.7.0__tar.gz → 0.7.1__tar.gz

{opencomplai_cli-0.7.0 → opencomplai_cli-0.7.1}/PKG-INFO

@@ -1,13 +1,13 @@
 Metadata-Version: 2.5
 Name: opencomplai-cli
-Version: 0.7.0
+Version: 0.7.1
 Summary: Opencomplai command-line interface for EU AI Act compliance assessment
 Project-URL: Homepage, https://opencomplai.com
 Project-URL: Documentation, https://docs.opencomplai.com
 Author-email: Opencomplai <hello@opencomplai.com>
 License: AGPL-3.0-only
 Requires-Python: >=3.11
-Requires-Dist: opencomplai-core[reports]>=0.1.0
+Requires-Dist: opencomplai-core[reports]>=0.7.1
 Requires-Dist: questionary>=2.0.0
 Requires-Dist: rich>=13.0.0
 Requires-Dist: typer>=0.9.0

{opencomplai_cli-0.7.0 → opencomplai_cli-0.7.1}/pyproject.toml

@@ -1,13 +1,13 @@
 [project]
 name = "opencomplai-cli"
-version = "0.7.0"
+version = "0.7.1"
 description = "Opencomplai command-line interface for EU AI Act compliance assessment"
 readme = "README.md"
 license = { text = "AGPL-3.0-only" }
 authors = [{ name = "Opencomplai", email = "hello@opencomplai.com" }]
 requires-python = ">=3.11"
 dependencies = [
-    "opencomplai-core[reports]>=0.1.0",
+    "opencomplai-core[reports]>=0.7.1",
     "typer>=0.9.0",
     "rich>=13.0.0",
     "questionary>=2.0.0",

{opencomplai_cli-0.7.0 → opencomplai_cli-0.7.1}/src/opencomplai_cli/__init__.py

@@ -1,6 +1,6 @@
 """Opencomplai CLI."""
 
-__version__ = "0.7.0"
+__version__ = "0.7.1"
 
 # Canonical project metadata — single source of truth for the `--version`
 # flag and the `opencomplai info` command. Mirrors the [project] table in

{opencomplai_cli-0.7.0 → opencomplai_cli-0.7.1}/src/opencomplai_cli/commands/checker.py

@@ -14,6 +14,7 @@ from opencomplai_core.compliance_checker import (
     CheckerSession,
     ComplianceCheckerResult,
     EntityType,
+    bridge_to_manifest_fields,
     evaluate,
     export_all,
     render_json,
@@ -363,4 +364,5 @@ def build_checker_session_ref(
         "session_id": result.session_id or str(uuid.uuid4()),
         "completed_at": datetime.now(UTC).isoformat(),
         "report_json_path": str(report_json_path) if report_json_path else "",
+        "verdict": str(bridge_to_manifest_fields(result)["checker_verdict"]),
     }

{opencomplai_cli-0.7.0 → opencomplai_cli-0.7.1}/src/opencomplai_cli/commands/interactive_init.py

@@ -41,23 +41,19 @@ def run_interactive_init(
             report_path = output_file.parent / "eu-ai-act-result.json"
             write_exports(checker_result, export_json=report_path)
             bridged = bridge_to_manifest_fields(checker_result)
-            default_purpose = bridged.get("intended_purpose", "")
             default_role = bridged.get("operator_role", "")
             default_hr = bridged.get("high_risk_presumption", False)
         else:
-            default_purpose = ""
             default_role = ""
             default_hr = False
     else:
-        default_purpose = ""
         default_role = ""
         default_hr = False
 
     system_id = typer.prompt("System ID", default="my-ai-system")
-    intended_purpose = typer.prompt(
-        "Intended purpose (Annex III mapping)",
-        default=str(default_purpose) if default_purpose else "",
-    )
+    # The checker verdict travels in checker_session.verdict; the purpose is
+    # the text the EU rules keyword-match, so it has no checker default.
+    intended_purpose = typer.prompt("Intended purpose (Annex III mapping)", default="")
     high_risk = typer.confirm(
         "Presume high-risk classification?",
         default=bool(default_hr),

{opencomplai_cli-0.7.0 → opencomplai_cli-0.7.1}/src/opencomplai_cli/main.py

@@ -11,8 +11,10 @@ Exit codes (contractual — never deviate):
 
 from __future__ import annotations
 
+import codecs
 import importlib.metadata
 import json
+import locale
 import os
 import re
 import sys
@@ -27,6 +29,7 @@ from typing import TYPE_CHECKING
 from urllib.parse import urlparse
 
 import typer
+from opencomplai_core.compliance_checker import CHECKER_VERDICTS
 from opencomplai_core.compliance_checker.models import ComplianceCheckerResult
 from opencomplai_core.control_assessment import build_controls_block, derive_controls
 from opencomplai_core.control_catalog import get_catalog
@@ -586,6 +589,58 @@ def _result_from_local(risk_result) -> tuple[ScanResult, list[str]]:
     return ScanResult.PASS, failed_ids
 
 
+# Checker verdicts `check` enforces, and the result + control each one fails.
+_VERDICT_FAILURES: dict[str, tuple[ScanResult, str]] = {
+    "prohibited_practice": (ScanResult.POLICY_BLOCK, "EU_AIA_ART5_UNACCEPTABLE"),
+    "high_risk_ai_system": (ScanResult.CONTROL_FAIL, "EU_AIA_ART6_HIGH_RISK"),
+}
+# Results a verdict may raise, by severity. TRAP_DETECTED and VALIDATION_FAIL
+# are absent on purpose: a verdict never replaces them.
+_VERDICT_RAISABLE_RANK = {
+    ScanResult.PASS: 0,
+    ScanResult.DEGRADED_COMPLETE: 0,
+    ScanResult.CONTROL_FAIL: 1,
+    ScanResult.POLICY_BLOCK: 2,
+}
+
+
+def _apply_checker_verdict(
+    artifact: ScanStatusArtifact, manifest: SystemManifest
+) -> tuple[ScanStatusArtifact, bool]:
+    """Fail the artifact on a prohibited or high-risk applicability verdict.
+
+    The EU rules only keyword-match `intended_purpose`, so a system the
+    checker classified prohibited or high-risk would otherwise pass. The
+    verdict comes from `checker_session.verdict`; a 0.7.0 manifest wrote it
+    into `intended_purpose` instead, which is still honoured with a warning.
+    Only ever escalates the result. Returns `(artifact, escalated)`, with
+    `escalated` True when the verdict is prohibited or high-risk.
+    """
+    cs = manifest.checker_session
+    verdict = cs.verdict if cs is not None else None
+    if manifest.intended_purpose in CHECKER_VERDICTS:
+        err_console.print(
+            "[yellow]WARN:[/yellow] intended_purpose is the checker verdict "
+            f"'{manifest.intended_purpose}', not a purpose. Replace it with what "
+            "the system does so the EU rules can classify it."
+        )
+        verdict = verdict or manifest.intended_purpose
+    if verdict not in _VERDICT_FAILURES:
+        return artifact, False
+    result, control = _VERDICT_FAILURES[verdict]
+    if artifact.result not in _VERDICT_RAISABLE_RANK:
+        return artifact, True
+    if _VERDICT_RAISABLE_RANK[artifact.result] >= _VERDICT_RAISABLE_RANK[result]:
+        result = artifact.result
+    failed_controls = list(dict.fromkeys([*artifact.failed_controls, control]))
+    return (
+        artifact.model_copy(
+            update={"result": result, "failed_controls": failed_controls}
+        ),
+        True,
+    )
+
+
 def _maybe_halt_system(system_id: str, commit_ref: str, reason: str) -> None:
     """HALT-WIRE / E-12(a): persist HALTED_PENDING_REVIEW when this `check`
     run hit a trap or an unresolved HIGH-risk corroboration gap, via the
@@ -1030,6 +1085,11 @@ def checker_cmd(
     write_manifest: Path | None = typer.Option(
         None, "--write-manifest", help="Write bridged fields into manifest at this path"
     ),
+    intended_purpose: str | None = typer.Option(
+        None,
+        "--intended-purpose",
+        help="With --write-manifest: what the system does (prompted when omitted)",
+    ),
     web: bool = typer.Option(
         False, "--web", help="Open the browser-based checker on the docs site"
     ),
@@ -1083,9 +1143,12 @@ def checker_cmd(
         report_path = export_json or (
             export_all_base.with_suffix(".json") if export_all_base else None
         )
+        system_id = typer.prompt("System ID", default="my-ai-system")
+        if intended_purpose is None:
+            intended_purpose = typer.prompt("Intended purpose (what the system does)")
         payload: dict = {
-            "system_id": typer.prompt("System ID", default="my-ai-system"),
-            "intended_purpose": bridged["intended_purpose"],
+            "system_id": system_id,
+            "intended_purpose": intended_purpose,
             "compliance_target": "EU_AI_ACT",
             "high_risk_presumption": bridged["high_risk_presumption"],
             "commit_ref": "HEAD",
@@ -1161,6 +1224,29 @@ def _load_sample_set(
     return sample
 
 
+def _read_gap_report(path: Path) -> GapReport:
+    """Load a `--gap-report` file: a bare GapReport or the envelope that
+    `opencomplai gaps --output json` prints (report nested under `payload`).
+
+    Windows PowerShell 5.1 `>` redirection writes UTF-16LE with a BOM, so a
+    UTF-16 BOM selects UTF-16; anything else is read as UTF-8 (BOM optional),
+    falling back to the locale encoding: a cmd.exe or Git Bash `>` redirect on
+    Windows writes the ANSI code page (cp1252), e.g. an em dash as 0x97.
+    """
+    data = path.read_bytes()
+    if data.startswith((codecs.BOM_UTF16_LE, codecs.BOM_UTF16_BE)):
+        text = data.decode("utf-16")
+    else:
+        try:
+            text = data.decode("utf-8-sig")
+        except UnicodeDecodeError:
+            text = data.decode(locale.getpreferredencoding(False))
+    raw = json.loads(text)
+    if isinstance(raw, dict) and "payload" in raw and "tool_version" in raw:
+        raw = raw["payload"]
+    return GapReport.model_validate(raw)
+
+
 _GAP_STATUS_STYLE = {
     GapStatus.MET: "[green]MET[/green]",
     GapStatus.PARTIAL: "[yellow]PARTIAL[/yellow]",
@@ -1418,7 +1504,7 @@ def recommend_cmd(
                 f"[red]Error:[/red] gap report not found: {gap_report_file}"
             )
             sys.exit(2)
-        report = GapReport.model_validate(json.loads(gap_report_file.read_text()))
+        report = _read_gap_report(gap_report_file)
     else:
         if not manifest_file.exists():
             err_console.print(
@@ -1639,7 +1725,8 @@ def report_cmd(
     gap_report_file: Path | None = typer.Option(
         None,
         "--gap-report",
-        help="Path to a GapReport JSON file (overrides any gap_report embedded in --artifact)",
+        help="Path to a GapReport JSON file, e.g. from `opencomplai gaps --output json` "
+        "(overrides any gap_report embedded in --artifact)",
     ),
     output_file: Path = typer.Option(
         Path("report.html"), "--output", "-o", help="Output path (.html or .pdf)"
@@ -1676,7 +1763,7 @@ def report_cmd(
                 f"[red]Error:[/red] gap report not found: {gap_report_file}"
             )
             sys.exit(2)
-        gap_report = GapReport.model_validate(json.loads(gap_report_file.read_text()))
+        gap_report = _read_gap_report(gap_report_file)
 
     assessment_input = AssessmentInput(
         model=ModelMetadata(
@@ -2632,7 +2719,14 @@ def check_cmd(
     run_code_scan: bool = typer.Option(
         False, "--scan", help="Run code corroboration scan (opt-in)"
     ),
-    repo_root: Path = typer.Option(Path("."), "--repo-root"),
+    repo_root: Path = typer.Option(
+        Path("."),
+        "--repo-root",
+        help=(
+            "Repository root for the --scan code scan and the --with-gaps "
+            "artifact path probes (Arts. 9/13/14/16/24/43)"
+        ),
+    ),
     emit_scan_evidence: bool = typer.Option(True, "--emit-evidence/--no-emit-evidence"),
     scan_fail_on: FailOnLevel = typer.Option(
         FailOnLevel.none,
@@ -2734,7 +2828,6 @@ def check_cmd(
             commit_ref,
             scan_mode,
             install_id,
-            sign,
             eval_summary,
             eval_failed,
             eval_hashes,
@@ -2747,7 +2840,6 @@ def check_cmd(
             commit_ref,
             scan_mode,
             install_id,
-            sign,
             eval_summary,
             eval_failed,
             eval_hashes,
@@ -2761,6 +2853,9 @@ def check_cmd(
             dict.fromkeys([*artifact.failed_controls, "CODE_CORROBORATION_GAP"])
         )
 
+    artifact, escalated = _apply_checker_verdict(artifact, manifest)
+    risk_high |= escalated
+
     # HALT-WIRE / E-12(a): halt trigger — trap always halts; an unresolved
     # HIGH-risk corroboration gap (--scan --fail-on ... failed) halts too,
     # even when the artifact result itself stays CONTROL_FAIL rather than
@@ -2797,6 +2892,7 @@ def check_cmd(
             risk_result=gap_risk_result,
             corroboration_report=scan_report,
             eval_report=gap_eval_report,
+            repo_root=repo_root.resolve(),
         )
         derived_controls = _sync_controls_to_vault(
             gap_report, manifest, quiet=(output == OutputFormat.json)
@@ -2819,6 +2915,17 @@ def check_cmd(
             }
         )
 
+    # Sign only now: the scan override, checker verdict and --with-gaps
+    # blocks above all change the bytes the signature has to cover.
+    artifact = _sign_artifact(artifact, sign)
+
+    if api_available:
+        # Step 8 — append the final artifact to the ledger
+        _emit_event(
+            "scan_status_artifact",
+            json.loads(artifact.model_dump_json()),
+        )
+
     # Write artifact to disk for CI consumption
     artifact_path = Path("compliance-artifact.json")
     artifact_path.write_text(artifact.model_dump_json(indent=2))
@@ -2842,7 +2949,6 @@ def _run_service_check(
     commit_ref: str,
     scan_mode: str,
     install_id: str,
-    sign: bool,
     eval_summary: EvalSummary | None = None,
     eval_failed: list[str] | None = None,
     eval_hashes: list[str] | None = None,
@@ -2898,7 +3004,6 @@ def _run_service_check(
                     "sha256:validation_failed",
                     0,
                     int((time.monotonic() - start_ms) * 1000),
-                    sign,
                 ),
                 False,
             )
@@ -2929,7 +3034,6 @@ def _run_service_check(
                     "sha256:classify_failed",
                     0,
                     int((time.monotonic() - start_ms) * 1000),
-                    sign,
                 ),
                 False,
             )
@@ -2975,7 +3079,6 @@ def _run_service_check(
                 rationale_hash,
                 0,
                 int((time.monotonic() - start_ms) * 1000),
-                sign,
             ),
             risk_high,
         )
@@ -3057,7 +3160,6 @@ def _run_service_check(
         rationale_hash,
         pending_verifications_count,
         duration_ms,
-        sign,
         eval_summary=eval_summary,
         scan_summary=scan_summary,
     )
@@ -3084,12 +3186,8 @@ def _run_service_check(
         },
     )
 
-    # Step 8 — append artifact to ledger
-    _emit_event(
-        "scan_status_artifact",
-        json.loads(artifact.model_dump_json()),
-    )
-
+    # Step 8 (appending the artifact to the ledger) happens in `check_cmd`,
+    # once the artifact is final and signed.
     return artifact, risk_high
 
 
@@ -3098,7 +3196,6 @@ def _run_local_check(
     commit_ref: str,
     scan_mode: str,
     install_id: str,
-    sign: bool,
     eval_summary: EvalSummary | None = None,
     eval_failed: list[str] | None = None,
     eval_hashes: list[str] | None = None,
@@ -3151,7 +3248,6 @@ def _run_local_check(
             rationale_hash,
             0,
             duration_ms,
-            sign,
             eval_summary=eval_summary,
             scan_summary=scan_summary,
         ),
@@ -3170,12 +3266,11 @@ def _finalize_artifact(
     rationale_hash: str,
     pending_verifications_count: int,
     duration_ms: int,
-    sign: bool,
     eval_summary: EvalSummary | None = None,
     scan_summary: ScanSummary | None = None,
 ) -> ScanStatusArtifact:
-    """Build and optionally sign the ScanStatusArtifact."""
-    artifact = ScanStatusArtifact(
+    """Build the unsigned ScanStatusArtifact (`check_cmd` signs it last)."""
+    return ScanStatusArtifact(
         install_id=install_id,
         system_id=system_id,
         commit_ref=commit_ref,
@@ -3190,15 +3285,23 @@ def _finalize_artifact(
         scan_summary=scan_summary,
     )
 
-    if sign and _SIGNING_KEY.exists():
-        try:
-            from opencomplai_core.signing import sign_artifact
 
-            artifact.signature = sign_artifact(artifact, _SIGNING_KEY)
-        except Exception as exc:
-            err_console.print(f"[yellow]Warning: signing failed — {exc}[/yellow]")
+def _sign_artifact(artifact: ScanStatusArtifact, sign: bool) -> ScanStatusArtifact:
+    """Return a signed copy of `artifact` when `sign` is set and a key exists.
 
-    return artifact
+    The signature covers every other field, so this must run only once the
+    artifact is final — anything changed afterwards no longer verifies.
+    """
+    if not (sign and _SIGNING_KEY.exists()):
+        return artifact
+    try:
+        from opencomplai_core.signing import sign_artifact
+
+        signature = sign_artifact(artifact, _SIGNING_KEY)
+    except Exception as exc:
+        err_console.print(f"[yellow]Warning: signing failed — {exc}[/yellow]")
+        return artifact
+    return artifact.model_copy(update={"signature": signature})
 
 
 def _print_artifact_human(artifact: ScanStatusArtifact) -> None:
@@ -3787,11 +3890,9 @@ def docs_generate_cmd(
 
     # Local fallback
     try:
+        from opencomplai_core.dossier import validate_dossier_schema
+        from opencomplai_core.dossier_generator import generate_dossier
         from opencomplai_core.engine import assess as _assess
-        from opencomplai_doc_generator.generator import (
-            generate_dossier,
-            validate_dossier_schema,
-        )
 
         manifest = (
             loaded_manifest.model_copy(update={"commit_ref": commit_ref})

{opencomplai_cli-0.7.0 → opencomplai_cli-0.7.1}/src/opencomplai_cli/publish.py

@@ -160,8 +160,8 @@ def prepare_scan_status_artifact(
     Every field the OSS model produces (``install_id``, ``system_id``,
     ``commit_ref``, ``result``, ``failed_controls``, ``evidence_hashes``,
     ``rationale_hash``, ``duration_ms``, ``pending_verifications_count``,
-    ``signature``, ``eval_summary``, ``scan_summary``, ``gap_report``)
-    passes through unchanged -- the widened schema (G-4) now accepts all of
+    ``signature``, ``eval_summary``, ``scan_summary``, ``gap_report``,
+    ``nist_rmf_report``, ``controls``) passes through unchanged -- the widened schema (G-4) now accepts all of
     them. Only the fields the OSS model has no concept of at all are
     synthesized here, and each synthesis is documented:
 

opencomplai_cli-0.7.1/tests/test_check_signing.py

@@ -0,0 +1,129 @@
+"""
+`check --sign` signs the artifact it writes, not an earlier draft of it.
+
+`check` used to sign inside `_finalize_artifact` and then change the
+artifact: the `--scan --fail-on` override, the checker verdict and the
+`--with-gaps` blocks all landed after the signature, so the signed
+compliance-artifact.json never verified. Each test signs with a throwaway
+keypair and verifies the file on disk (and, in service mode, the copy
+appended to the ledger) against its public key.
+"""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+from opencomplai_cli import main
+from opencomplai_cli.main import app
+from opencomplai_core.models import ScanStatusArtifact, SystemManifest
+from opencomplai_core.signing import generate_keypair, verify_artifact
+from typer.testing import CliRunner
+
+runner = CliRunner()
+
+
+def _setup(tmp_path: Path, monkeypatch) -> tuple[Path, Path]:
+    """Chdir to tmp_path, force the local path, point `check` at a fresh
+    keypair, and write a manifest. Returns `(manifest_file, pub_key)`."""
+    monkeypatch.chdir(tmp_path)
+    monkeypatch.delenv("OPENCOMPLAI_API_URL", raising=False)
+    monkeypatch.delenv("OPENCOMPLAI_VAULT_URL", raising=False)
+    monkeypatch.delenv("SIGNING_KEY_PRIVATE", raising=False)
+    monkeypatch.setenv("OPENCOMPLAI_STATE_DIR", str(tmp_path / "state"))
+    key_dir = tmp_path / "keys"
+    generate_keypair(key_dir)
+    monkeypatch.setattr(main, "_SIGNING_KEY", key_dir / "signing.key")
+
+    manifest_file = tmp_path / "system-manifest.json"
+    manifest_file.write_text(
+        SystemManifest(
+            system_id="sign-sys",
+            intended_purpose="customer support chatbot",
+            compliance_target="EU_AI_ACT",
+            high_risk_presumption=False,
+            commit_ref="HEAD",
+        ).model_dump_json(),
+        encoding="utf-8",
+    )
+    return manifest_file, key_dir / "signing.pub"
+
+
+def _written_artifact(tmp_path: Path) -> ScanStatusArtifact:
+    return ScanStatusArtifact.model_validate_json(
+        (tmp_path / "compliance-artifact.json").read_text(encoding="utf-8")
+    )
+
+
+def test_signed_artifact_with_gaps_verifies(tmp_path, monkeypatch):
+    manifest_file, pub_key = _setup(tmp_path, monkeypatch)
+
+    result = runner.invoke(
+        app, ["check", "--manifest", str(manifest_file), "--sign", "--with-gaps"]
+    )
+    assert result.exit_code == 0, result.output
+
+    artifact = _written_artifact(tmp_path)
+    assert artifact.gap_report is not None
+    assert verify_artifact(artifact, pub_key) is True
+
+
+def test_signed_artifact_after_failed_scan_override_verifies(tmp_path, monkeypatch):
+    manifest_file, pub_key = _setup(tmp_path, monkeypatch)
+    repo = tmp_path / "repo"
+    repo.mkdir()
+    (repo / "requirements.txt").write_text("face_recognition\n", encoding="utf-8")
+    (repo / "face.py").write_text("import face_recognition\n", encoding="utf-8")
+
+    result = runner.invoke(
+        app,
+        [
+            "check",
+            "--manifest",
+            str(manifest_file),
+            "--repo-root",
+            str(repo),
+            "--scan",
+            "--fail-on",
+            "major",
+            "--sign",
+        ],
+    )
+    assert result.exit_code == 1, result.output
+
+    artifact = _written_artifact(tmp_path)
+    assert "CODE_CORROBORATION_GAP" in artifact.failed_controls
+    assert verify_artifact(artifact, pub_key) is True
+
+
+def test_service_mode_ledgers_the_final_signed_artifact(tmp_path, monkeypatch):
+    manifest_file, pub_key = _setup(tmp_path, monkeypatch)
+    monkeypatch.setenv("OPENCOMPLAI_API_URL", "http://gateway.invalid")
+
+    def fake_call_service(path: str, payload: dict) -> tuple[int, dict]:
+        if path == "/v1/risk/classify":
+            return 200, {
+                "risk_class": "minimal",
+                "rationale_hash": "sha256:" + "a" * 64,
+            }
+        if path == "/v1/verify/claims":
+            return 200, {"outcome": "verified"}
+        return 200, {}
+
+    events: list[tuple[str, dict]] = []
+    monkeypatch.setattr(main, "_call_service", fake_call_service)
+    monkeypatch.setattr(
+        main,
+        "_emit_event",
+        lambda event_type, payload, *a, **kw: events.append((event_type, payload)),
+    )
+
+    result = runner.invoke(
+        app, ["check", "--manifest", str(manifest_file), "--sign", "--with-gaps"]
+    )
+    assert result.exit_code == 0, result.output
+
+    artifact = _written_artifact(tmp_path)
+    assert verify_artifact(artifact, pub_key) is True
+    ledgered = [p for t, p in events if t == "scan_status_artifact"]
+    assert ledgered == [json.loads(artifact.model_dump_json())]

{opencomplai_cli-0.7.0 → opencomplai_cli-0.7.1}/tests/test_checker_cmd.py

@@ -120,3 +120,95 @@ def test_checker_web_local_serves_and_stops_via_page_button() -> None:
 
     assert not thread.is_alive(), "CLI did not stop after the shutdown route was hit"
     assert result_holder["result"].exit_code == 0, result_holder["result"].stdout
+
+
+def _isolate(tmp_path: Path, monkeypatch) -> None:
+    monkeypatch.chdir(tmp_path)
+    monkeypatch.delenv("OPENCOMPLAI_API_URL", raising=False)
+    monkeypatch.setenv("OPENCOMPLAI_STATE_DIR", str(tmp_path / "state"))
+
+
+def _write_checker_manifest(tmp_path: Path, fixture_name: str) -> Path:
+    fixture = json.loads((FIXTURES / fixture_name).read_text(encoding="utf-8"))
+    answers_path = tmp_path / "answers.json"
+    answers_path.write_text(json.dumps(fixture["session"]), encoding="utf-8")
+    manifest_path = tmp_path / "system-manifest.json"
+
+    result = runner.invoke(
+        app,
+        [
+            "checker",
+            "--answers",
+            str(answers_path),
+            "--write-manifest",
+            str(manifest_path),
+            "--intended-purpose",
+            "Summarises internal documents",
+        ],
+        input="doc-summariser\n",
+    )
+    assert result.exit_code == 0, result.output
+    return manifest_path
+
+
+def test_checker_write_manifest_keeps_purpose_and_records_verdict(
+    tmp_path: Path, monkeypatch
+) -> None:
+    """The tier label belongs in checker_session.verdict: the EU rules
+    keyword-match intended_purpose, so a label there classifies nothing."""
+    _isolate(tmp_path, monkeypatch)
+    manifest_path = _write_checker_manifest(tmp_path, "05_prohibited.json")
+
+    data = json.loads(manifest_path.read_text(encoding="utf-8"))
+    assert data["system_id"] == "doc-summariser"
+    assert data["intended_purpose"] == "Summarises internal documents"
+    assert data["checker_session"]["verdict"] == "prohibited_practice"
+
+
+def test_check_blocks_prohibited_checker_verdict(tmp_path: Path, monkeypatch) -> None:
+    """A purpose the rules find harmless must not PASS a system the checker
+    classified prohibited."""
+    _isolate(tmp_path, monkeypatch)
+    manifest_path = _write_checker_manifest(tmp_path, "05_prohibited.json")
+
+    result = runner.invoke(app, ["check", "-m", str(manifest_path), "-o", "json"])
+    assert result.exit_code == 3, result.output
+    artifact = json.loads((tmp_path / "compliance-artifact.json").read_text())
+    assert artifact["result"] == "policy_block"
+    assert artifact["failed_controls"].count("EU_AIA_ART5_UNACCEPTABLE") == 1
+
+
+def test_check_honours_legacy_verdict_in_intended_purpose(
+    tmp_path: Path, monkeypatch
+) -> None:
+    """0.7.0 wrote the verdict into intended_purpose; check still fails on
+    it and tells the user to put the real purpose there."""
+    _isolate(tmp_path, monkeypatch)
+    manifest_path = tmp_path / "system-manifest.json"
+    manifest_path.write_text(
+        json.dumps(
+            {
+                "system_id": "legacy-sys",
+                "intended_purpose": "high_risk_ai_system",
+                "compliance_target": "EU_AI_ACT",
+                "high_risk_presumption": True,
+                "commit_ref": "HEAD",
+                "operator_role": "provider",
+                "checker_session": {
+                    "checker_version": "checker-2026-07-24",
+                    "session_id": "legacy-session",
+                    "completed_at": "2026-09-01T00:00:00+00:00",
+                    "report_json_path": "",
+                },
+            }
+        ),
+        encoding="utf-8",
+    )
+
+    result = runner.invoke(app, ["check", "-m", str(manifest_path), "-o", "json"])
+    assert result.exit_code == 1, result.output
+    assert "WARN" in result.stderr
+    assert "high_risk_ai_system" in result.stderr
+    artifact = json.loads(result.stdout)
+    assert artifact["result"] == "control_fail"
+    assert "EU_AIA_ART6_HIGH_RISK" in artifact["failed_controls"]