opencomplai-cli 0.9.2__tar.gz → 0.10.0__tar.gz

{opencomplai_cli-0.9.2 → opencomplai_cli-0.10.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: opencomplai-cli
-Version: 0.9.2
+Version: 0.10.0
 Summary: Opencomplai command-line interface for AI compliance: the EU AI Act, and NIST AI RMF derived from the same evidence
 Project-URL: Homepage, https://opencomplai.com
 Project-URL: Documentation, https://docs.opencomplai.com
@@ -18,7 +18,7 @@ Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Topic :: Software Development :: Quality Assurance
 Requires-Python: >=3.11
-Requires-Dist: opencomplai-core[reports]>=0.9.2
+Requires-Dist: opencomplai-core[reports]>=0.10.0
 Requires-Dist: questionary>=2.0.0
 Requires-Dist: rich>=13.0.0
 Requires-Dist: typer>=0.9.0
@@ -76,11 +76,12 @@ meta-package instead.
 | `opencomplai accept` | Write a signed, committable record accepting a system's high-risk classification |
 | `opencomplai verify-output` | Verify an AI output claim against ground-truth sources |
 | `opencomplai verify` | Verify a signed artifact (`--kind` artifact, dossier or agent-attestation; `--expect KEY=VALUE` adds offline checks) |
+| `opencomplai export` | Write one neutral evidence package (JSON, or a flat CSV with `--format csv`) from a `compliance-artifact.json`, with the signed artifact embedded unchanged |
 | `opencomplai version` | Show the installed Opencomplai version |
 | `opencomplai info` | Show full package metadata (`pip show`-style, across the whole suite) |
 
 Also available as command groups (`opencomplai <group> --help` for their own subcommands):
-`docs` (Annex IV dossier generation), `instructions` (Art. 13 instructions-for-use), `deployer-pack` (seal instructions-for-use into a hash-named, offline-verifiable pack), `risk` (risk classification), `sync` (metadata sync),
+`docs` (Annex IV dossier generation), `instructions` (Art. 13 instructions-for-use), `deployer-pack` (seal instructions-for-use into a hash-named, offline-verifiable pack; `deployer-pack import` records a provider's pack as upstream evidence), `risk` (risk classification), `sync` (metadata sync),
 `keys` (signing-key rotation), `ai` (optional AI-intent plugin configuration), `controls`
 (control-register status), `fria` (fundamental rights impact assessment), `qms` (Art. 17 quality-management-system documents), `dashboard` (Premium Dashboard connection management),
 `incident` (incident records and deadline clocks),

{opencomplai_cli-0.9.2 → opencomplai_cli-0.10.0}/README.md

@@ -43,11 +43,12 @@ meta-package instead.
 | `opencomplai accept` | Write a signed, committable record accepting a system's high-risk classification |
 | `opencomplai verify-output` | Verify an AI output claim against ground-truth sources |
 | `opencomplai verify` | Verify a signed artifact (`--kind` artifact, dossier or agent-attestation; `--expect KEY=VALUE` adds offline checks) |
+| `opencomplai export` | Write one neutral evidence package (JSON, or a flat CSV with `--format csv`) from a `compliance-artifact.json`, with the signed artifact embedded unchanged |
 | `opencomplai version` | Show the installed Opencomplai version |
 | `opencomplai info` | Show full package metadata (`pip show`-style, across the whole suite) |
 
 Also available as command groups (`opencomplai <group> --help` for their own subcommands):
-`docs` (Annex IV dossier generation), `instructions` (Art. 13 instructions-for-use), `deployer-pack` (seal instructions-for-use into a hash-named, offline-verifiable pack), `risk` (risk classification), `sync` (metadata sync),
+`docs` (Annex IV dossier generation), `instructions` (Art. 13 instructions-for-use), `deployer-pack` (seal instructions-for-use into a hash-named, offline-verifiable pack; `deployer-pack import` records a provider's pack as upstream evidence), `risk` (risk classification), `sync` (metadata sync),
 `keys` (signing-key rotation), `ai` (optional AI-intent plugin configuration), `controls`
 (control-register status), `fria` (fundamental rights impact assessment), `qms` (Art. 17 quality-management-system documents), `dashboard` (Premium Dashboard connection management),
 `incident` (incident records and deadline clocks),

{opencomplai_cli-0.9.2 → opencomplai_cli-0.10.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "opencomplai-cli"
-version = "0.9.2"
+version = "0.10.0"
 description = "Opencomplai command-line interface for AI compliance: the EU AI Act, and NIST AI RMF derived from the same evidence"
 readme = "README.md"
 license = { text = "AGPL-3.0-only" }
@@ -17,7 +17,7 @@ classifiers = [
     "Topic :: Software Development :: Quality Assurance",
 ]
 dependencies = [
-    "opencomplai-core[reports]>=0.9.2",
+    "opencomplai-core[reports]>=0.10.0",
     "typer>=0.9.0",
     "rich>=13.0.0",
     "questionary>=2.0.0",

{opencomplai_cli-0.9.2 → opencomplai_cli-0.10.0}/src/opencomplai_cli/__init__.py

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

{opencomplai_cli-0.9.2 → opencomplai_cli-0.10.0}/src/opencomplai_cli/check_signing.py

@@ -23,20 +23,25 @@ def stamp_artifact(
     *,
     now: datetime,
     manifest_bytes: bytes | None = None,
+    repo_root: Path | None = None,
 ) -> ScanStatusArtifact:
     """Fill the fields ``publish.prepare_scan_status_artifact`` would add at push,
-    plus the four provenance stamps, only when unset.
+    plus the four provenance stamps and the two tree stamps (``tree_sha256``,
+    ``tree_dirty``), only when unset.
 
     Stamping before signing makes ``prepared == original`` at push time, so the
     signature survives. ``manifest_sha256`` stays None without ``manifest_bytes``;
     CRLF is hashed as LF so one manifest hashes the same on Windows and Linux.
+    The tree stamps need ``repo_root`` to be a git work tree and stay None
+    otherwise.
     """
     from opencomplai_core.json_schemas import SCHEMA_VERSION
     from opencomplai_core.rules import RULE_SET_VERSION
 
+    from opencomplai_cli.provenance import tree_provenance
     from opencomplai_cli.publish import _cli_version
 
-    update: dict[str, str] = {}
+    update: dict[str, object] = {}
     if not artifact.timestamp:
         update["timestamp"] = now.isoformat().replace("+00:00", "Z")
     if not artifact.policy_bundle_version:
@@ -50,4 +55,8 @@ def stamp_artifact(
     if not artifact.manifest_sha256 and manifest_bytes is not None:
         lf_bytes = manifest_bytes.replace(b"\r\n", b"\n")
         update["manifest_sha256"] = hashlib.sha256(lf_bytes).hexdigest()
+    if repo_root is not None and not artifact.tree_sha256:
+        tree = tree_provenance(repo_root)
+        if tree is not None:
+            update["tree_sha256"], update["tree_dirty"] = tree
     return artifact.model_copy(update=update) if update else artifact

{opencomplai_cli-0.9.2 → opencomplai_cli-0.10.0}/src/opencomplai_cli/commands/accept.py

@@ -20,6 +20,7 @@ from pathlib import Path
 
 import typer
 from opencomplai_core.acceptance import (
+    ART_6_3_EXEMPTION,
     CLASSIFICATION_ACCEPTANCE,
     TRAP_APPROVAL,
     build_record,
@@ -30,7 +31,12 @@ from opencomplai_core.acceptance import (
 )
 from opencomplai_core.control_identity import fingerprint_manifest
 from opencomplai_core.engine import assess
-from opencomplai_core.models import AssessmentInput, ModelMetadata, RiskLevel
+from opencomplai_core.models import (
+    ART_6_3_GROUND_IDS,
+    AssessmentInput,
+    ModelMetadata,
+    RiskLevel,
+)
 from opencomplai_core.signing import SigningKeyError, resolve_key
 
 from opencomplai_cli.commands.halt import OutputFormat
@@ -88,6 +94,19 @@ def accept_cmd(
     change_context: str | None = typer.Option(
         None, "--change-context", help="The change being approved (trap approval only)"
     ),
+    exemption: bool = typer.Option(
+        False,
+        "--exemption",
+        help="Record a declaration that an Annex III system relies on the Art. 6(3) "
+        "exceptions (a declaration, not a legal finding; needs legal review)",
+    ),
+    ground: list[str] | None = typer.Option(
+        None,
+        "--ground",
+        help="Art. 6(3) ground relied on, repeatable (exemption only): hr3_art_6_3, "
+        "hr4_narrow_task, hr5_no_significant_risk or hr6_accessory. Default: the "
+        "manifest's checker_session.derogation_grounds",
+    ),
     key: Path | None = typer.Option(
         None,
         "--key",
@@ -102,10 +121,25 @@ def accept_cmd(
     prohibited (Art. 5) system; nothing is written on exit 2.
     """
     main_mod = _main_module()
-    record_type = TRAP_APPROVAL if trap_approval else CLASSIFICATION_ACCEPTANCE
+    if trap_approval:
+        record_type = TRAP_APPROVAL
+    elif exemption:
+        record_type = ART_6_3_EXEMPTION
+    else:
+        record_type = CLASSIFICATION_ACCEPTANCE
 
     if not accepted_by.strip() or not statement.strip():
         _fail("--accepted-by and --statement must not be empty.")
+    if exemption and trap_approval:
+        _fail("--exemption and --trap-approval cannot be combined.")
+    if ground and not exemption:
+        _fail("--ground only applies with --exemption.")
+    unknown = [g for g in ground or [] if g not in ART_6_3_GROUND_IDS]
+    if unknown:
+        _fail(
+            f"unknown --ground {', '.join(unknown)}; "
+            f"use one of: {', '.join(ART_6_3_GROUND_IDS)}."
+        )
     if trap_approval and not (change_context and change_context.strip()):
         _fail("--trap-approval needs --change-context.")
     if change_context is not None and not trap_approval:
@@ -132,6 +166,17 @@ def accept_cmd(
             "an acceptance cannot apply to it."
         )
 
+    grounds: list[str] | None = None
+    if exemption:
+        cs = manifest.checker_session
+        grounds = list(ground) if ground else list(cs.derogation_grounds if cs else [])
+        if not grounds:
+            _fail(
+                "an exemption needs --ground (one or more of: "
+                f"{', '.join(ART_6_3_GROUND_IDS)}); the manifest's checker session "
+                "has no derogation_grounds to default from."
+            )
+
     fingerprint = fingerprint_manifest(manifest)
     record = sign_record(
         build_record(
@@ -143,6 +188,7 @@ def accept_cmd(
             accepted_at=datetime.now(UTC).strftime("%Y-%m-%dT%H:%M:%SZ"),
             public_key_pem=public_pem,
             change_context=change_context.strip() if trap_approval else None,
+            grounds=grounds,
         ),
         key_path,
     )
@@ -155,20 +201,26 @@ def accept_cmd(
     )
 
     if output == OutputFormat.json:
-        main_mod.console.print_json(
-            json.dumps(
-                {
-                    "path": str(path),
-                    "record_type": record_type,
-                    "key_id": key_id_for(public_pem),
-                    "manifest_fingerprint": fingerprint,
-                }
-            )
-        )
+        payload = {
+            "path": str(path),
+            "record_type": record_type,
+            "key_id": key_id_for(public_pem),
+            "manifest_fingerprint": fingerprint,
+        }
+        if grounds is not None:
+            payload["grounds"] = record["grounds"]
+        main_mod.console.print_json(json.dumps(payload))
     else:
         main_mod.console.print(
             f"Wrote {record_type} record: {path}", soft_wrap=True, markup=False
         )
+        if grounds is not None:
+            main_mod.console.print(
+                "This record is a declaration by a person, not a legal finding; "
+                "it needs legal review.",
+                soft_wrap=True,
+                markup=False,
+            )
         main_mod.console.print(
             "Commit this file so `opencomplai check` finds it in the repository.",
             soft_wrap=True,

{opencomplai_cli-0.9.2 → opencomplai_cli-0.10.0}/src/opencomplai_cli/commands/checker.py

@@ -22,6 +22,7 @@ from opencomplai_core.compliance_checker import (
     render_markdown,
     render_pdf,
 )
+from opencomplai_core.compliance_checker.bridge import derogation_grounds
 from opencomplai_core.compliance_checker.catalog import load_help_content
 from opencomplai_core.compliance_checker.merge import (
     MergedCheckerResult,
@@ -462,4 +463,7 @@ def build_checker_session_ref(
         ref["obligation_ids"] = list(obligation_ids)
     if rationale:
         ref["rationale"] = list(rationale)
+    grounds = derogation_grounds(result)
+    if grounds:
+        ref["derogation_grounds"] = grounds
     return ref

{opencomplai_cli-0.9.2 → opencomplai_cli-0.10.0}/src/opencomplai_cli/commands/checker_manifest.py

@@ -104,6 +104,9 @@ def write_or_append_manifest(
         old = old if isinstance(old, dict) else {}
         session = dict(old)
         session.update(ref)
+        if "derogation_grounds" not in ref:
+            # Grounds follow the latest run; a stale one must not outlive its answers.
+            session.pop("derogation_grounds", None)
         if _rank(old.get("verdict")) < _rank(ref["verdict"]):
             session["verdict"] = old["verdict"]
         if report_path is None and old.get("report_json_path"):

{opencomplai_cli-0.9.2 → opencomplai_cli-0.10.0}/src/opencomplai_cli/commands/deployer_pack.py

@@ -1,9 +1,10 @@
-"""`opencomplai deployer-pack build` and the `deployer-pack` verify kind.
+"""`opencomplai deployer-pack build` / `import` and the `deployer-pack` verify kind.
 
 Seals the Art. 13(3) instructions-for-use JSON (written by `opencomplai
 instructions generate`) into one portable pack named after its own SHA-256. The
 pack is generated offline and never uploaded; only its hash and counts reach the
-artifact `summaries.packs` (see `opencomplai_core.deployer_pack`).
+artifact `summaries.packs` (see `opencomplai_core.deployer_pack`). `import`
+records a provider's received pack in the manifest `imported_evidence`.
 
 `console`/`err_console` and the key paths are obtained lazily from
 `opencomplai_cli.main` (it imports this module to register the sub-typer, so a
@@ -23,7 +24,10 @@ from pathlib import Path
 import typer
 from opencomplai_core import deployer_pack as core
 from opencomplai_core.instructions_for_use import IFUDocument
+from opencomplai_core.models import SystemManifest
 from opencomplai_core.signing import SigningKeyError
+from pydantic import ValidationError
+from rich.markup import escape
 
 from opencomplai_cli.commands.verify import (
     VerifyInputError,
@@ -140,6 +144,100 @@ def build_cmd(
     )
 
 
+@app.command("import")
+def import_cmd(
+    pack: Path = typer.Argument(..., help="A provider's deployer_pack_<id>.json"),
+    manifest: Path = typer.Option(
+        Path("system-manifest.json"), "--manifest", "-m", help="Your system manifest"
+    ),
+    pub_key: Path | None = typer.Option(
+        None, "--pub-key", help="Provider's public key; same meaning as `verify`"
+    ),
+    output: OutputFormat = typer.Option(OutputFormat.human, "--output", "-o"),
+) -> None:
+    """Record a provider's deployer pack in the manifest as upstream evidence.
+
+    Verifies the pack first and refuses an invalid one. The record is provenance
+    only: `check` and `gaps` do not read it, so verdicts do not change.
+    """
+    from opencomplai_cli import main as _main
+
+    try:
+        result = verify_deployer_pack(pack, pub_key)
+    except VerifyInputError as exc:
+        _fail(str(exc))
+    if result.status == "invalid":
+        _fail(
+            f"{pack} is not a valid deployer pack: {result.detail}; "
+            "nothing was imported"
+        )
+    parsed = core.DeployerPack.model_validate(json.loads(pack.read_bytes()))
+
+    try:
+        payload = json.loads(manifest.read_text(encoding="utf-8-sig"))
+        if not isinstance(payload, dict):
+            raise ValueError("not a JSON object")
+        SystemManifest.model_validate(payload)
+    except (OSError, ValueError) as exc:  # ValidationError is a ValueError
+        _fail(f"cannot use manifest {manifest}: {exc}")
+
+    key, entry = core.upstream_evidence(
+        parsed, result.status, source_file=pack.name, imported_on=_today()
+    )
+    stored = payload.get("imported_evidence")
+    stored = stored.get(key) if isinstance(stored, dict) else None
+    recorded = True
+    if isinstance(stored, dict):
+        if stored.get("pack_sha256") != entry.pack_sha256:
+            _fail(
+                f"{manifest} already holds a different pack under {key}; "
+                "nothing was imported"
+            )
+        if (stored.get("verification"), stored.get("signer_key_id")) == (
+            entry.verification,
+            entry.signer_key_id,
+        ):
+            recorded = False  # keep the first import date, write nothing
+    if recorded:
+        payload.setdefault("imported_evidence", {})[key] = entry.model_dump(mode="json")
+        try:
+            SystemManifest.model_validate(payload)
+        except ValidationError as exc:
+            _fail(f"{manifest} would be invalid, nothing was imported: {exc}")
+        manifest.write_text(
+            json.dumps(payload, indent=2, ensure_ascii=False), encoding="utf-8"
+        )
+
+    pack_id = key.split(":", 1)[1]
+    if output == OutputFormat.json:
+        print(
+            json.dumps(
+                {
+                    "pack_id": pack_id,
+                    "pack_sha256": entry.pack_sha256,
+                    "provider_system_id": entry.provider_system_id,
+                    "verification": entry.verification,
+                    "signer_key_id": entry.signer_key_id,
+                    "manifest": str(manifest),
+                    "recorded": recorded,
+                }
+            )
+        )
+        return
+    verb = "Recorded" if recorded else "Already imported"
+    _main.console.print(
+        f"[bold]{verb}[/bold] deployer pack {pack_id} from provider system "
+        f"{escape(entry.provider_system_id)} ({entry.verification}) in "
+        f"{escape(str(manifest))}",
+        soft_wrap=True,
+    )
+    if entry.verification == "unsigned":
+        _main.console.print(
+            "  unsigned: only the hash was checked, no signature was checked",
+            soft_wrap=True,
+        )
+
+
 def verify_deployer_pack(path: Path, pub_key: Path | None) -> VerifyResult:
     import jsonschema
 

opencomplai_cli-0.10.0/src/opencomplai_cli/commands/export.py

@@ -0,0 +1,74 @@
+"""`opencomplai export` -- write one neutral evidence package from an artifact.
+
+Moves data, never gates: exit 0 whatever the verdict inside. Reads only the
+artifact path it is given; writes only `--out` and `--artifact-out`. Nothing is
+sent anywhere. `err_console` comes lazily from `opencomplai_cli.main` (a
+module-level import back into main would be circular).
+"""
+
+from __future__ import annotations
+
+import json
+import sys
+from enum import StrEnum
+from pathlib import Path
+
+import typer
+from opencomplai_core.evidence_package import build_evidence_package, package_to_csv
+from rich.markup import escape
+
+from opencomplai_cli.inputs import read_json_file
+
+
+class ExportFormat(StrEnum):
+    json = "json"
+    csv = "csv"
+
+
+def export_cmd(
+    artifact: Path = typer.Argument(
+        ..., help="Path to a compliance-artifact.json written by `check --with-gaps`"
+    ),
+    fmt: ExportFormat = typer.Option(
+        ExportFormat.json,
+        "--format",
+        help="json (the package) or csv (one row per article)",
+    ),
+    out: Path | None = typer.Option(
+        None, "--out", help="Write the package to this file instead of stdout"
+    ),
+    artifact_out: Path | None = typer.Option(
+        None,
+        "--artifact-out",
+        help="Also write the embedded artifact, ready for `opencomplai verify`",
+    ),
+) -> None:
+    """Export one neutral, schema-validated evidence package (JSON or CSV)."""
+    from opencomplai_cli import main as _main
+
+    try:
+        raw = read_json_file(artifact)
+        pkg = build_evidence_package(raw)
+    except (OSError, ValueError) as e:
+        _main.err_console.print(f"[red]Error:[/red] {escape(str(e))}")
+        sys.exit(2)
+
+    if fmt == ExportFormat.csv:
+        text = package_to_csv(pkg)
+    else:
+        text = pkg.model_dump_json(indent=2) + "\n"
+    try:
+        if artifact_out is not None:
+            # Same bytes semantics the signature covers: parses to the same model.
+            artifact_out.write_text(
+                json.dumps(pkg.artifact, indent=2) + "\n",
+                encoding="utf-8",
+                newline="",
+            )
+        if out is not None:
+            out.write_text(text, encoding="utf-8", newline="")
+    except OSError as e:
+        _main.err_console.print(f"[red]Error:[/red] {escape(str(e))}")
+        sys.exit(2)
+    if out is None:
+        typer.echo(text, nl=False)

{opencomplai_cli-0.9.2 → opencomplai_cli-0.10.0}/src/opencomplai_cli/main.py

@@ -50,6 +50,7 @@ from opencomplai_core.deployer_pack import with_pack_summary
 from opencomplai_core.engine import assess
 from opencomplai_core.eval_engine import eval_summary_from_report, run_evals
 from opencomplai_core.evaluators.seed_corpus import seed_sample_set
+from opencomplai_core.exemption_gap import apply_exemption_gate
 from opencomplai_core.frameworks import (
     EU_AI_ACT,
     evaluate_targets,
@@ -184,6 +185,7 @@ from opencomplai_cli.commands.deployer_pack import (  # noqa: E402
     app as deployer_pack_app,
 )
 from opencomplai_cli.commands.diff import diff_cmd  # noqa: E402
+from opencomplai_cli.commands.export import export_cmd  # noqa: E402
 from opencomplai_cli.commands.halt import approve_cmd, resume_cmd  # noqa: E402
 from opencomplai_cli.commands.incident import app as incident_app  # noqa: E402
 from opencomplai_cli.commands.instructions import app as instructions_app  # noqa: E402
@@ -231,6 +233,7 @@ app.command("resume")(resume_cmd)
 app.command("accept")(accept_cmd)
 app.command("diff")(diff_cmd)
 app.command("verify")(verify_cmd)
+app.command("export")(export_cmd)
 
 console = Console()
 err_console = Console(stderr=True)
@@ -3259,6 +3262,14 @@ def check_cmd(
             "Replaces opencomplai.yaml's gate.fail_on."
         ),
     ),
+    require_exemption_record: bool = typer.Option(
+        False,
+        "--require-exemption-record",
+        help=(
+            "Opt-in: fail (exit 1) when the checker session relies on the "
+            "Art. 6(3) derogation and no valid signed exemption record exists."
+        ),
+    ),
     output_dir: Path = typer.Option(
         Path("."),
         "--output-dir",
@@ -3459,6 +3470,9 @@ def check_cmd(
         corroboration_report=scan_report,
         sample_set=sample_set,
     )
+    artifact = apply_exemption_gate(
+        artifact, manifest, repo_root=repo_root, require=require_exemption_record
+    )
 
     # HALT-WIRE / E-12(a): halt trigger — trap always halts; an unresolved
     # HIGH-risk corroboration gap (--scan --fail-on ... failed) halts too,
@@ -3562,6 +3576,7 @@ def check_cmd(
         artifact,
         now=datetime.now(UTC),
         manifest_bytes=manifest_file.read_bytes() if manifest_file.is_file() else None,
+        repo_root=repo_root,
     )
     # Before signing, so the signature covers the packs and other summaries.
     artifact = with_pack_summary(artifact, repo_root / "deployer-pack")

opencomplai_cli-0.10.0/src/opencomplai_cli/provenance.py

@@ -0,0 +1,49 @@
+"""Tree provenance for ``check``: content digest and dirty flag from git."""
+
+from __future__ import annotations
+
+import os
+import subprocess
+from pathlib import Path
+
+from opencomplai_core.tree_digest import tree_digest
+
+
+def _git(repo_root: Path, *args: str) -> bytes | None:
+    try:
+        proc = subprocess.run(
+            ["git", *args],
+            cwd=repo_root,
+            capture_output=True,
+            timeout=30,
+            check=False,
+        )
+    except (OSError, subprocess.SubprocessError):
+        return None
+    return proc.stdout if proc.returncode == 0 else None
+
+
+def tree_provenance(repo_root: Path) -> tuple[str, bool] | None:
+    """``(tree_sha256, tree_dirty)`` for the git tree at ``repo_root``, else None.
+
+    The digest covers tracked plus untracked non-ignored file content. Dirty is
+    true for any tracked modification or any untracked non-ignored file. The
+    ``.`` pathspec keeps paths relative to ``repo_root``, so one tree in two
+    directories gives one digest.
+
+    ponytail: whole-file reads, submodules are not descended, and a
+    ``.gitattributes`` text conversion can report a clean checkout as dirty on
+    one platform; add streaming or conversion handling if that bites.
+    """
+    tracked = _git(repo_root, "ls-files", "-z", "--", ".")
+    untracked = _git(
+        repo_root, "ls-files", "-z", "--others", "--exclude-standard", "--", "."
+    )
+    status = _git(repo_root, "status", "--porcelain", "--", ".")
+    if not tracked or untracked is None or status is None:
+        return None
+    paths = {
+        os.fsdecode(p) for blob in (tracked, untracked) for p in blob.split(b"\0") if p
+    }
+    digest = tree_digest((p, repo_root / p) for p in paths)
+    return digest, bool(status.strip())