@amsterdamdatalabs/adl-agent-control-darwin-arm64 0.1.4

package/packages/repo-controls/package/adl-compliance/src/adl_compliance/checks/layout/scripts_size_depth/test_check.py

@@ -0,0 +1,163 @@
+"""LAY-014 — ported from
+`compliance_new/checks/layout/scripts-size-depth/test.sh`.
+
+ONE corpus, two sets, copied byte-for-byte from the shell tree's fixtures
+(`fixtures/scripts-layout/`): 16 direct files under `.workflows/scripts` plus
+one file exactly at the depth limit (`a/b/c/d/at-limit.sh`, 4 levels down) and
+one past it (`a/b/c/d/e/too-deep.sh`, 5 levels down). The gate counts direct
+files and measures depth over the GIVEN SET, so the SAME tree grades clean or
+over-limit depending only on what it was handed — test.sh's point, carried
+over unchanged.
+
+This check is not yet wired into `checks/__init__.py` (a later step wires this
+port's whole wave into the registry in one shot, to avoid concurrent edits to
+that shared file), so `runner.run` would report "no check implements LAY-014"
+before ever reaching this check's own logic. Every test below therefore calls
+`ScriptsSizeDepth().run(...)` directly and assembles the verdict with
+`decide()` itself — the same bypass `MarkdownTrees`' test module already uses
+for the same reason.
+
+test.sh's "no set: could not run" case is a shell-only mechanism: check.sh
+refuses to run at all when `ADL_CHANGED_FILES` is unset. A Python check is
+never handed "unset" — it is handed a `FileSet`, always — so the equivalent
+here is the generic could-not-run path `runner.run` takes for every check when
+the row's `engine.scope` intersects an exhaustively-given set to nothing (see
+`core/verdict.py`'s `could_not_run` and `runner.run`'s `exhaustive` guard).
+That is a property of the runner shared by every gate, not of this one, so it
+is verified at the scope layer directly, exactly as `MarkdownTrees`' own
+`test_the_rows_scope_selects_nothing_from_an_empty_given_set` does.
+"""
+
+from __future__ import annotations
+
+import pathlib
+
+from pathlib import Path
+
+from helpers import corpus_files
+
+from adl_compliance.checks.layout.scripts_size_depth import ScriptsSizeDepth
+from adl_compliance.core import scope
+from adl_compliance.core.context import Context, FileSet
+from adl_compliance.core.finding import Finding
+from adl_compliance.core.verdict import Outcome, decide
+from adl_compliance.policy.registry import load
+
+FIXTURES = pathlib.Path(__file__).parent / "fixtures"
+CORPUS = FIXTURES / "scripts-layout"
+ROW = load().by_id("LAY-014")
+
+GIVEN = corpus_files(CORPUS)
+# rg -v 'direct-16\.sh$|too-deep\.sh$' — the clean set drops the 16th direct
+# file and the one-past-the-limit nested file.
+NARROWED = tuple(
+    p for p in GIVEN
+    if not p.endswith("direct-16.sh") and not p.endswith("too-deep.sh")
+)
+
+
+def verdict(given: tuple[str, ...], root: Path = CORPUS, scripts_root: str = ".workflows/scripts"):
+    # The scripts root is a RESOLVED INPUT now, not a class constant. The corpus
+    # keeps the packaged default's shape, so every count and limit asserted
+    # below is unchanged — only where the root comes from moved.
+    ctx = Context(root=root, row=ROW, inputs={"scripts_root": root / scripts_root})
+    findings = tuple(
+        r for r in ScriptsSizeDepth().run(ctx, FileSet(paths=given))
+        if isinstance(r, Finding)
+    )
+    return decide(ROW, findings, 0, ())
+
+
+# -------------------------------------------------------------------- premise
+def test_the_premise_holds() -> None:
+    """Asserted, not assumed: a mistyped suffix would leave both sets
+    identical and every case below would agree for nothing."""
+    assert len(GIVEN) == 18
+    assert len(NARROWED) == 16
+
+
+# ------------------------------------------------------- exactly at the limits
+def test_exactly_at_both_limits_is_clean() -> None:
+    """15 direct files and 4 levels are permitted, so a finding on either
+    number is a breach of the limit and not merely the gate counting."""
+    result = verdict(NARROWED)
+    assert result.outcome is Outcome.CLEAN, result.render()
+    assert result.findings == ()
+
+
+# ------------------------------------------------ one file and one level over
+def test_one_file_and_one_level_over_is_reported() -> None:
+    result = verdict(GIVEN)
+    assert result.outcome is Outcome.FINDINGS, result.render()
+
+    text = result.render()
+    assert ".workflows/scripts: has 16 direct files; limit is 15" in text
+    assert "a/b/c/d/e: is 5 levels below .workflows/scripts; limit is 4" in text
+
+
+def test_exactly_two_findings_fire() -> None:
+    """Without this, a gate that also fired on `at-limit.sh`'s own directory
+    (which sits exactly at the depth limit, not past it) would also pass."""
+    result = verdict(GIVEN)
+    assert len(result.findings) == 2
+    assert {f.rule for f in result.findings} == {"LAY-014"}
+
+
+# --------------------------------------------------------- isolation proof
+def test_every_finding_resolves_inside_the_corpus() -> None:
+    """This checkout has its own `.workflows/scripts` tree, larger and deeper
+    than the corpus. A check that resolved a repository root instead of
+    reading the `Context` it was handed would name paths from it."""
+    for finding in verdict(GIVEN).findings:
+        assert (CORPUS / finding.path).is_dir(), finding.render()
+
+
+# ------------------------------------------------------------- the given set
+def test_the_stray_files_outside_the_given_set_are_not_reported() -> None:
+    """Both breaches are still on disk; a set that omits them must report
+    neither — the same "intersection, half one" case every ported gate proves."""
+    result = verdict(tuple(p for p in NARROWED if not p.endswith("at-limit.sh")))
+    assert result.outcome is Outcome.CLEAN, result.render()
+
+
+# --------------------------------------------------- no set: could not run
+def test_the_rows_scope_selects_nothing_from_an_empty_given_set() -> None:
+    assert scope.intersect(ROW.resolved_scope(), ()) == ()
+
+
+# ------------------------------------------------- the root is not a constant
+def test_the_scripts_root_follows_the_declared_tree(tmp_path: Path) -> None:
+    """The regression guard for a literal `.workflows/scripts` in the package.
+
+    enact-m5 keeps CI in `workflows/` while `.workflows/` is repo-controls' own
+    install artefact, so the hardcoded constant made this gate report
+    `missing .workflows/scripts` and then call all 44 real scripts "outside
+    scripts root" — 45 findings, not one of them true. Its printed remedy was
+    "update SCRIPTS_ROOT in check.py": the gate asking a consumer to edit the
+    shared package.
+    """
+    root = tmp_path / "repo"
+    over_limit = root / "ci/scripts/tools"
+    over_limit.mkdir(parents=True)
+    for index in range(ScriptsSizeDepth.MAX_DIRECT_FILES + 1):
+        (over_limit / f"s{index}.sh").write_text("#!/bin/sh\n")
+
+    given = tuple(
+        f"ci/scripts/tools/s{index}.sh"
+        for index in range(ScriptsSizeDepth.MAX_DIRECT_FILES + 1)
+    )
+    result = verdict(given, root=root, scripts_root="ci/scripts")
+
+    text = result.render()
+    assert "missing" not in text, text
+    assert "outside scripts root" not in text, text
+    # graded under the declared root, and named by it
+    assert "ci/scripts/tools: has 16 direct files; limit is 15" in text, text
+    assert ".workflows" not in text, text
+
+
+def test_a_missing_scripts_root_names_the_declared_path_not_a_constant(tmp_path: Path) -> None:
+    result = verdict((), root=tmp_path, scripts_root="ci/scripts")
+    text = result.render()
+    assert "missing ci/scripts" in text, text
+    assert ".workflows" not in text, text

package/packages/repo-controls/package/adl-compliance/src/adl_compliance/checks/lfs/__init__.py

@@ -0,0 +1 @@
+"""lfs."""

package/packages/repo-controls/package/adl-compliance/src/adl_compliance/checks/lfs/integrity/__init__.py

@@ -0,0 +1,11 @@
+"""The `lfs.integrity` gate.
+
+A folder rather than a module because the ported test carries its own fixture
+corpus beside the check, same as every other gate in this package.
+"""
+
+from __future__ import annotations
+
+from .check import Integrity
+
+__all__ = ["Integrity"]

package/packages/repo-controls/package/adl-compliance/src/adl_compliance/checks/lfs/integrity/check.py

@@ -0,0 +1,169 @@
+"""LFS-001 (`lfs.integrity`) — a blob over 1 MiB entering the repository must
+go through the LFS filter, or it is `LFS-002`.
+
+Ported from `compliance_new/checks/lfs/integrity/check.sh`. The row id
+(`LFS-001`) and the finding id (`LFS-002`) are different on purpose — that
+split already exists in check.sh itself (its own header names the row
+`LFS-002` because an EARLIER row, also called `LFS-001`, was retired when this
+one absorbed its question; see check.sh's opening comment). This port keeps
+both spellings exactly as the source has them: `id` is the row this class
+implements, `rule` is the one finding it emits, the same `id` != `rule` shape
+`REP-002`'s `LCK-001`/`LCK-002` already uses.
+
+**Reconstructing check.sh's text.** Every `check.sh`/`test.sh` file under
+`compliance_new/checks/lfs/integrity/` has had the literal word "git" removed
+from it (verified: `rg -c git compliance_new/checks/lfs/integrity/check.sh`
+returns 0, and the same is true of 94 of the tree's 98 `check.sh` files, so
+this is a property of the reference corpus, not of this one gate). The
+finding text below restores it, and this is a RECONSTRUCTION, not a
+transcription — recorded here rather than done silently:
+
+  message   check.sh has `"... entering  without the LFS filter"` (note the
+            double space). Restored to `"... entering Git without the LFS
+            filter"` — a single removed word explains the exact gap.
+  fix       check.sh has `.attributes` and `' lfs track'`. Restored to
+            `.gitattributes` and `'git lfs track'`.
+  pointer   check.sh compares the object's first line against
+            `'version https://-lfs.hub.com/spec/v1'`. Restored to
+            `'version https://git-lfs.github.com/spec/v1'`.
+
+The pointer restoration is not a guess: `test.sh` proves it. Its clean-pass
+case runs a REAL `git lfs install --local --force` and
+`git add --renormalize`, which produces a real Git LFS pointer file — and a
+real pointer file's first line is the well-known, standard
+`version https://git-lfs.github.com/spec/v1`, never the garbled
+`.../-lfs.hub.com/...` string check.sh's own source literally contains. If
+check.sh's comparison used the literal garbled string, that same clean-pass
+case would report a finding instead of passing. The restored string is the
+only one consistent with test.sh's own asserted outcome.
+
+**Two deviations this port does NOT resolve, only documents**, because
+`compliance_py`'s architecture makes check.sh's literal design unstatable
+here rather than merely inconvenient:
+
+1. **No git object reads (K-41).** check.sh deliberately reads the path from
+   the index (`:path`, pre-commit) or `HEAD` (`HEAD:path`, elsewhere) via
+   `git cat-file`, and its own comment explains why at length: the WORKTREE
+   file is not a safe source, because a correctly-tracked LFS pointer is
+   smudged back to full content on disk, and a check reading the worktree
+   would flag the very files that are doing the right thing. check.sh calls
+   this risk "latent, not hypothetical" for the shell tree's OWN prior
+   design, which read the worktree and was replaced because of it.
+
+   `compliance_py` has exactly one file that calls `git` or resolves a root
+   — `cli.py` — and every check, this one included, is handed a `Context`
+   and a `FileSet` with no way to reach a git object store (see
+   `core/check.py`'s docstring and `INVARIANTS.md`'s K-41 entry, verified
+   there as `git: 1 module`). There is no established mechanism in this
+   package for a check to read `:path`/`HEAD:path` instead of the worktree
+   file, and none is added here. `graded` below reads the WORKTREE file
+   `ctx.path(rel)` resolves to, which means it inherits the exact risk
+   check.sh's comment names — a large file whose LFS pointer HAS been
+   smudged back to full content by an active `git-lfs` filter would be
+   misreported as a violation. check.sh's own measurement on the checkout it
+   was written against found no case of this actually happening (one sampled
+   LFS-tracked file was the same byte count in the worktree as in `HEAD`),
+   so the risk carries over as documented rather than as an active defect —
+   but it is a real, named gap, not a silent one, and resolving it needs
+   either a git-object-reading mechanism added to this package's
+   architecture or an accepted exception for this one gate.
+
+2. **No phase (K-43).** check.sh branches its object read on
+   `ADL_GATE_PHASE` (index at pre-commit, `HEAD` everywhere else).
+   `compliance_py` reads no phase anywhere — "nothing reads a phase" is
+   K-43, and K-33 records phase-conditional behaviour as retired by
+   construction. There is one behaviour here, not two: `graded` grades
+   whatever the caller's `FileSet` contains, exactly like every other check
+   in this package.
+
+`.gitattributes` matching is scoped to the repository-root file only, using
+"last matching pattern wins" (`core.scope.matches`, the same rule real
+`.gitattributes` files and this package's own `engine.scope` both use).
+check.sh's `git check-attr` resolves the full multi-directory and global
+attribute stack; this does not, and every case `test.sh` exercises uses a
+single root-level file, so this is enough to prove the branch, not a claim
+of full `check-attr` parity.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Iterable
+from pathlib import Path
+from typing import ClassVar
+
+from ....core import scope
+from ....core.check import Check
+from ....core.context import Context, FileSet
+from ....core.finding import Report
+
+
+class Integrity(Check):
+    id: ClassVar[str] = "LFS-001"
+    rule: ClassVar[str] = "LFS-002"
+
+    THRESHOLD: ClassVar[int] = 1024 * 1024
+    """check.sh: `threshold=$((1024 * 1024))`. A blob strictly larger fails."""
+
+    POINTER: ClassVar[str] = "version https://git-lfs.github.com/spec/v1"
+    """The first line of a real Git LFS pointer file. See the module
+    docstring's "Reconstructing check.sh's text" for why this is restored
+    rather than the garbled string check.sh's own source contains."""
+
+    GITATTRIBUTES: ClassVar[str] = ".gitattributes"
+    FILTER_LFS: ClassVar[str] = "filter=lfs"
+
+    def graded(self, ctx: Context, files: FileSet) -> Iterable[Report]:
+        for rel in files:
+            target = ctx.path(rel)
+            if not target.is_file():
+                # check.sh: a path `cat-file --batch-check` answers `missing`
+                # for -- deleted from the index, or never tracked -- is not a
+                # blob entering the repository, so there is nothing to
+                # enforce (its own comment on the `blob` type test).
+                continue
+
+            size = target.stat().st_size
+            if size <= self.THRESHOLD:
+                continue
+
+            if self._tracked_by_lfs(ctx, rel) and self._first_line(target) == self.POINTER:
+                continue
+
+            # check.sh: both conditions are required, not either one -- a
+            # `.gitattributes` rule alone does not excuse content that was
+            # never actually converted to a pointer, and a pointer-shaped
+            # first line alone does not excuse a path with no rule tracking
+            # it. See "attribute-without-conversion" in this gate's fixtures.
+            yield self.report(
+                rel,
+                f"{rel} is a {size}-byte blob entering Git without the LFS filter",
+                f"add a .gitattributes rule matching {rel} to filter=lfs, run "
+                f"'git lfs track' for that pattern, then re-add {rel}",
+            )
+
+    # ------------------------------------------------------------- reading
+
+    def _tracked_by_lfs(self, ctx: Context, rel: str) -> bool:
+        """Root `.gitattributes` only; see the module docstring's scope note."""
+        body = self.text(ctx, self.GITATTRIBUTES)
+        if body is None:
+            return False
+        matched = False
+        for line in body.splitlines():
+            stripped = line.strip()
+            if not stripped or stripped.startswith("#"):
+                continue
+            pattern, *attrs = stripped.split()
+            if scope.matches(pattern, rel):
+                matched = self.FILTER_LFS in attrs
+        return matched
+
+    @staticmethod
+    def _first_line(target: Path) -> str:
+        """Only a small prefix is read -- check.sh's own comment measures the
+        cost of reading whole oversized blobs and avoids it with
+        `--batch-check`; this avoids it by never opening more than one
+        buffer's worth of an already-known-oversized file."""
+        with target.open("rb") as handle:
+            prefix = handle.read(4096)
+        return prefix.split(b"\n", 1)[0].decode("utf-8", errors="replace").rstrip("\r")

package/packages/repo-controls/package/adl-compliance/src/adl_compliance/checks/lfs/integrity/fixtures/attribute-without-conversion/.gitattributes

@@ -0,0 +1 @@
+*.bin filter=lfs diff=lfs merge=lfs -text

package/packages/repo-controls/package/adl-compliance/src/adl_compliance/checks/lfs/integrity/fixtures/attribute-without-conversion/large file.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2cb74edba754a81d121c9db6833704a8e7d417e5b13d1a19f4a52f007d644264
+size 1048577

package/packages/repo-controls/package/adl-compliance/src/adl_compliance/checks/lfs/integrity/fixtures/clean/.gitattributes

@@ -0,0 +1 @@
+*.bin filter=lfs diff=lfs merge=lfs -text

package/packages/repo-controls/package/adl-compliance/src/adl_compliance/checks/lfs/integrity/fixtures/clean/large file.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2cb74edba754a81d121c9db6833704a8e7d417e5b13d1a19f4a52f007d644264
+size 1048577

package/packages/repo-controls/package/adl-compliance/src/adl_compliance/checks/lfs/integrity/fixtures/clean/small.txt

@@ -0,0 +1 @@
+ordinary

package/packages/repo-controls/package/adl-compliance/src/adl_compliance/checks/lfs/integrity/fixtures/unmatched-extension/.gitattributes

@@ -0,0 +1 @@
+*.bin filter=lfs diff=lfs merge=lfs -text

package/packages/repo-controls/package/adl-compliance/src/adl_compliance/checks/lfs/integrity/test_check.py

@@ -0,0 +1,133 @@
+"""LFS-001 — ported from `compliance_new/checks/lfs/integrity/test.sh`.
+
+test.sh builds one fixture inline (`mktemp -d`, real `git init`/`add`/`commit`
+calls, `head -c 1048577 /dev/zero`, `git lfs install --local --force`) and
+walks it through a sequence of states, asserting the gate's verdict at each
+one. Ported here as separate COMMITTED fixture directories, one per state —
+the same shift every other ported check.sh/test.sh pair in this package
+already made, and the one this task calls out `coverage.backend-ratchet`
+(`COV-002`) as its concrete precedent for. Nothing here invents a scenario
+test.sh does not have; each fixture below is named for, and traced back to,
+one specific `run_gate`/`run_gate_tree` call in test.sh.
+
+check.sh reads `:path`/`HEAD:path` (index or `HEAD`, by `ADL_GATE_PHASE`)
+and this port reads the WORKTREE file instead — see `check.py`'s module
+docstring for why (K-41: no check calls git; K-43: no phase). Concretely,
+that collapses two of test.sh's cases into one fixture each here:
+
+  test.sh case                                           -> fixture
+  ---------------------------------------------------------------------
+  pre-commit: raw blob staged, no .gitattributes           missing-filter
+  pre-commit: .gitattributes matches, blob still raw       attribute-without-conversion
+  pre-commit: converted to a pointer, passes                clean (bin)
+  qua_deploy: same tree, whole-repo audit, passes           clean (bin, same file)
+  qua_deploy: payload.dat, large, unmatched extension       unmatched-extension
+  pre-commit: small.txt, silent                             clean (txt)
+
+`clean/` alone therefore stands in for THREE of test.sh's assertions (the
+converted-pointer pass at both phases, plus the untouched small file), which
+is exact rather than a simplification: with no phase in this port, "passes at
+pre-commit" and "passes at qua_deploy" are the same claim about the same
+file.
+"""
+
+from __future__ import annotations
+
+from helpers import corpus, corpus_files
+
+from adl_compliance import runner
+from adl_compliance.checks.lfs.integrity import Integrity
+from adl_compliance.core.verdict import Outcome
+from adl_compliance.policy.registry import load
+
+import pytest
+
+FIXTURES = corpus("lfs", "integrity")
+ROW = load().by_id("LFS-001")
+
+
+@pytest.fixture(autouse=True)
+def _wired(monkeypatch: pytest.MonkeyPatch) -> None:
+    # LFS-001 is not yet in `checks/__init__.py`'s CHECKS tuple — a later step
+    # wires this wave of checks into the registry in one shot, to avoid
+    # concurrent edits to that shared file. Until then, `runner.lookup` cannot
+    # find this row, so the dispatch path (`runner.run`) is exercised here
+    # with its one lookup call patched to resolve LFS-001 to this module's
+    # class — everything else (scope intersection, structural/graded split,
+    # verdict decision) runs for real.
+    monkeypatch.setattr(runner, "lookup", lambda gate_id: Integrity)
+
+
+def run(case: str) -> object:
+    root = FIXTURES / case
+    return runner.run(ROW, root, corpus_files(root))
+
+
+def test_the_row_identifies_this_check() -> None:
+    assert ROW.domain == "lfs"
+    assert ROW.name == "integrity"
+
+
+def test_a_large_staged_blob_outside_the_lfs_filter_is_rejected() -> None:
+    # test.sh: `run_gate pre-commit -- "large file.bin"` on a raw 1048577-byte
+    # blob with no `.gitattributes` at all must fail.
+    verdict = run("missing-filter")
+    assert verdict.outcome is Outcome.FINDINGS, verdict.render()
+    assert len(verdict.findings) == 1
+    finding = verdict.findings[0]
+    assert finding.rule == "LFS-002"
+    assert finding.path == "large file.bin"
+    assert finding.line is None
+
+
+def test_the_filename_with_spaces_is_not_truncated() -> None:
+    # test.sh: "A space in the name on purpose: a diagnostic that truncates at
+    # the space names a file nobody can find." check.sh's own shell diagnostics
+    # ran the risk of stopping at the first word; `Finding.path` and `render()`
+    # are plain Python strings with no such hazard, asserted directly rather
+    # than by absence.
+    verdict = run("missing-filter")
+    assert verdict.findings[0].path == "large file.bin"
+    assert "LFS-002 large file.bin: " in verdict.render()
+
+
+def test_the_finding_names_the_size_and_an_actionable_fix() -> None:
+    verdict = run("missing-filter")
+    finding = verdict.findings[0]
+    assert finding.message == (
+        "large file.bin is a 1048577-byte blob entering Git without the LFS filter"
+    )
+    assert finding.fix == (
+        "add a .gitattributes rule matching large file.bin to filter=lfs, run "
+        "'git lfs track' for that pattern, then re-add large file.bin"
+    )
+
+
+def test_a_matching_gitattributes_rule_does_not_excuse_a_raw_blob() -> None:
+    # test.sh: "the .attributes rule is added AFTER the blob was staged...
+    # This is the case that makes the `||` in the check load-bearing." A
+    # `.gitattributes` match alone must not pass a file that was never
+    # actually converted to an LFS pointer.
+    verdict = run("attribute-without-conversion")
+    assert verdict.outcome is Outcome.FINDINGS, verdict.render()
+    assert verdict.rules == ["LFS-002"]
+    assert verdict.findings[0].path == "large file.bin"
+
+
+def test_a_correctly_tracked_lfs_pointer_and_a_small_file_both_stay_silent() -> None:
+    # test.sh: the renormalized pointer passes at both pre-commit and
+    # qua_deploy, and `small.txt` is silent throughout — three assertions,
+    # one fixture, per this test module's own docstring.
+    verdict = run("clean")
+    assert verdict.outcome is Outcome.CLEAN, verdict.render()
+    assert verdict.findings == ()
+
+
+def test_a_large_ordinary_blob_of_an_unmatched_extension_is_reported() -> None:
+    # test.sh: "qua_deploy sees a large ordinary blob in HEAD" — .gitattributes
+    # matches `*.bin` only, so `payload.dat` is committed as an ordinary
+    # object and must still be reported.
+    verdict = run("unmatched-extension")
+    assert verdict.outcome is Outcome.FINDINGS, verdict.render()
+    assert verdict.rules == ["LFS-002"]
+    assert verdict.findings[0].path == "payload.dat"

package/packages/repo-controls/package/adl-compliance/src/adl_compliance/checks/pipeline/__init__.py

@@ -0,0 +1 @@
+"""pipeline."""

package/packages/repo-controls/package/adl-compliance/src/adl_compliance/checks/pipeline/phase_disjoint/__init__.py

@@ -0,0 +1,12 @@
+"""The `pipeline.phase-disjoint` gate.
+
+A folder rather than a module because this gate GRADES A DOCUMENT, and the
+document belongs beside the check that reads it. `check.py` is the rule;
+anything else in here is what it grades.
+"""
+
+from __future__ import annotations
+
+from .check import PhaseDisjoint
+
+__all__ = ["PhaseDisjoint"]

package/packages/repo-controls/package/adl-compliance/src/adl_compliance/checks/pipeline/phase_disjoint/check.py

@@ -0,0 +1,129 @@
+"""PIP-004 — ported from
+`compliance_new/checks/pipeline/phase-disjoint/check.sh` (rule id `MET-001`).
+
+No gate registry row may run in two mutually exclusive phases:
+
+    1. never both pre-commit and pre-push
+    2. never both pr_validation and qua_deploy
+
+Entirely `structural`: the registry is a NAMED INPUT (`Check.inputs`, resolved
+by the runner into `ctx.inputs["registry"]`) and every row it grades is inside
+that one document, so there is nothing in `graded` for this gate to read — the
+shell version's own comment says as much: it takes no arguments and holds no
+root variable, and finds the registry structurally from its own position in
+the package.
+
+`PhaseRow` and `PhaseRegistry` are `OpenModel`, not `StrictModel`. The real
+`policy/gate-registry.yaml` carries `name`, `domain`, `title`, `severity`,
+`controls`, `engine`, `test`, `grants`, `timeout_ms` on every row — none of
+which is this gate's business. `extra="forbid"` here would make this gate
+refuse to run against the real registry on every single invocation, exactly
+the trap `contracts.transport-boundaries`' own docstring names for its input.
+
+A missing registry or one that decodes to zero rows is `CouldNotRun` here,
+exactly as the shell version treats them (exit 2 in both cases) — never a
+`MET-001` finding. The shell script asserts its row count before the verdict
+for the same reason `contracts.transport-boundaries` asserts a non-empty
+`boundaries` list: an empty decode and a clean estate are the same exit code
+otherwise, and the empty one is a broken gate reporting success.
+
+**A field this repository's schema does not carry.** Neither the currently
+shipped shell registry (`compliance_new/policy/gate-registry.yaml`) nor this
+package's own (`policy/gate-registry.yaml`, whose `Row` model in
+`policy/registry.py` declares exactly `id · name · domain · title · severity ·
+controls · engine · test · grants · timeout_ms`, closed by K-09) has a single
+row carrying `phases:` today — the scheduling model this gate grades was
+already retired in favour of `engine.scope`-based triggering before this row
+was ported (see `compliance_new/AGENTS.md`, "A phase is not this tree's word",
+and this package's own K-43, "No phase here"). This gate is ported faithfully
+regardless, exactly as `check.sh` specifies it, because retiring a rule is a
+decision for whoever owns the registry row, not something a port silently
+does on its behalf — see this check's own `test_check.py` and this file's
+folder-level notes for what that means for a real run against either registry.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Iterable
+from typing import Annotated, ClassVar
+
+import yaml
+from pydantic import Field, ValidationError
+
+from ....core.check import Check
+from ....core.context import Context
+from ....core.errors import CouldNotRun
+from ....core.finding import Report
+from ....core.models import OpenModel
+
+
+class PhaseRow(OpenModel):
+    """One row of the gate registry, projected to just what MET-001 grades."""
+
+    id: str
+    phases: Annotated[tuple[str, ...], Field(strict=False)] = ()
+
+
+class PhaseRegistry(OpenModel):
+    """Open: the real document also carries `schema` at the top level."""
+
+    rows: Annotated[tuple[PhaseRow, ...], Field(strict=False)] = ()
+
+
+class PhaseDisjoint(Check):
+    id: ClassVar[str] = "PIP-004"
+    rule: ClassVar[str] = "MET-001"
+
+    inputs: ClassVar[dict[str, str]] = {
+        "registry": "<compliance>/policy/gate-registry.yaml",
+    }
+
+    PRE_COMMIT: ClassVar[str] = "pre-commit"
+    PRE_PUSH: ClassVar[str] = "pre-push"
+    PR_VALIDATION: ClassVar[str] = "pr_validation"
+    QUA_DEPLOY: ClassVar[str] = "qua_deploy"
+
+    def structural(self, ctx: Context) -> Iterable[Report]:
+        registry_path = ctx.inputs["registry"]
+        shown = ctx.relative(registry_path)
+
+        body = self.text(ctx, registry_path)
+        if body is None:
+            raise CouldNotRun(f"missing input: {shown}")
+
+        registry = self._load_registry(body, shown)
+        if not registry.rows:
+            raise CouldNotRun(f"{shown} decoded zero rows")
+
+        for row in registry.rows:
+            phases = set(row.phases)
+
+            if self.PRE_COMMIT in phases and self.PRE_PUSH in phases:
+                yield self.report(
+                    shown,
+                    f"{row.id} runs at both {self.PRE_COMMIT} and {self.PRE_PUSH}",
+                    f"drop one of {self.PRE_COMMIT} or {self.PRE_PUSH} from "
+                    f"{row.id}'s phases in {shown}",
+                )
+
+            if self.PR_VALIDATION in phases and self.QUA_DEPLOY in phases:
+                yield self.report(
+                    shown,
+                    f"{row.id} runs at both {self.PR_VALIDATION} and {self.QUA_DEPLOY}",
+                    f"drop one of {self.PR_VALIDATION} or {self.QUA_DEPLOY} from "
+                    f"{row.id}'s phases in {shown}",
+                )
+
+    # -------------------------------------------------------------- the registry
+
+    def _load_registry(self, body: str, shown: str) -> PhaseRegistry:
+        try:
+            loaded = yaml.safe_load(body)
+        except yaml.YAMLError as exc:
+            raise CouldNotRun(f"could not read .rows from {shown}: {exc}") from exc
+        if not isinstance(loaded, dict):
+            raise CouldNotRun(f"could not read .rows from {shown}: not a mapping")
+        try:
+            return PhaseRegistry.model_validate(loaded)
+        except ValidationError as exc:
+            raise CouldNotRun(f"could not read .rows from {shown}: {exc}") from exc