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

package/packages/repo-controls/package/adl-compliance/src/adl_compliance/checks/release/version_release/check.py

@@ -0,0 +1,202 @@
+"""REL-004 — VERSION, CHANGELOG.md, and the two workflow manifests, aligned.
+
+Ported from `compliance_new/checks/release/version-release/check.sh`. Entirely
+`structural`: every file this gate reads — VERSION, CHANGELOG.md, and the two
+entries in the shell's `versioned_files` array — is a FIXED, named path, never
+a member of the given set. That script's own comment says the same thing:
+"This gate reads no file set: the manifests it aligns are a FIXED list, named
+in the row's `engine.scope` so the runner selects it when one of them
+changes." There is no `graded` override for the same reason `COV-003` and
+`PIP-001` have none: nothing here is answered by iterating the given set.
+
+Two tiers, ported as two distinct behaviours because the shell script itself
+keeps them apart:
+
+  VERREL-INPUT   the shell's own bare `fail()` calls — VERSION missing, empty,
+                 or not `x.y.z`; CHANGELOG.md missing or carrying no readable
+                 latest-release heading; a versioned manifest missing or
+                 carrying no readable version field. Each is a HARD STOP in
+                 `check.sh`: it calls `fail`, which prints to stderr and does
+                 `exit 1` directly, WITHOUT ever calling `report_finding` —
+                 so at most one such condition is ever surfaced per run, and
+                 the script never reaches the alignment checks below it once
+                 one has fired. This port matches that: every branch below
+                 yields at most one `VERREL-INPUT` finding and returns. No
+                 shell rule id exists for this tier; `VERREL-INPUT` is invented
+                 here the same way `COV-003`'s port invented `COVBASE-INPUT`
+                 and `PIP-001`'s invented `PIPTR-INPUT`, both for shell scripts
+                 that only ever wrote ad hoc prose to stderr on this same kind
+                 of precondition failure.
+
+  VER-001        the shell's own `report_finding VER-001 ...` calls — a
+                 manifest's or CHANGELOG.md's version does not match VERSION's.
+                 ACCUMULATING, exactly as the shell script's `for` loop and
+                 trailing CHANGELOG.md comparison never stop after the first
+                 mismatch: every versioned file is graded independently, and
+                 the CHANGELOG.md comparison always runs afterward regardless
+                 of what the loop found.
+
+`read_toml_version`'s case-statement arm (`check.sh`'s `case "$file" in
+*.json) ...;; *) toml;; esac`) is ported as `_TOML_VERSION` even though both of
+today's `VERSIONED_FILES` entries are `.json` and never reach it — the shell
+dispatches on each entry's own suffix, not on a fixed list of json-only names,
+so a future `.toml` entry would already be handled correctly by this port too.
+"""
+
+from __future__ import annotations
+
+import re
+from collections.abc import Iterable
+from typing import ClassVar
+
+from ....core.check import Check
+from ....core.context import Context
+from ....core.finding import Report
+
+
+class VersionRelease(Check):
+    id: ClassVar[str] = "REL-004"
+    rule: ClassVar[str] = "VER-001"
+
+    INPUT: ClassVar[str] = "VERREL-INPUT"
+
+    # check.sh's own `versioned_files` array, verbatim order: changesets
+    # first, then the workflow root manifest. Fixed 2026-09-15 (K-42 sweep):
+    # these were hardcoded `.workflows/...` literals read directly via
+    # `self.text(ctx, relative)`, bypassing `ctx.inputs`/tree resolution
+    # entirely — a repository declaring `workflows` away from its packaged
+    # default got both manifests reported as flatly missing (LOUD, but
+    # against the wrong path).
+    inputs: ClassVar[dict[str, str]] = {
+        "changesets_package": "<workflows>/changesets/package.json",
+        "workflows_package": "<workflows>/package.json",
+    }
+
+    _SEMVER: ClassVar[re.Pattern[str]] = re.compile(r"^[0-9]+\.[0-9]+\.[0-9]+$")
+    # `read_json_version`'s sed: leading whitespace tolerated before the key.
+    _JSON_VERSION: ClassVar[re.Pattern[str]] = re.compile(r'^\s*"version"\s*:\s*"([^"]*)".*$')
+    # `read_toml_version`'s sed: no leading whitespace tolerated at all.
+    _TOML_VERSION: ClassVar[re.Pattern[str]] = re.compile(r'^version = "([^"]*)".*$')
+    # `tr -d '[:space:]'`'s POSIX class, spelled out rather than Python's wider
+    # (Unicode-including) `\s`.
+    _POSIX_SPACE: ClassVar[re.Pattern[str]] = re.compile(r"[ \t\n\r\v\f]")
+    _UNRELEASED_BRACKET: ClassVar[re.Pattern[str]] = re.compile(r"^## \[Unreleased\]")
+
+    def structural(self, ctx: Context) -> Iterable[Report]:
+        version_body = self.text(ctx, "VERSION")
+        if version_body is None:
+            yield self._input(
+                "VERSION", "VERSION is missing",
+                "create a VERSION file at the repository root holding the "
+                "canonical semantic version",
+            )
+            return
+
+        canonical_version = self._POSIX_SPACE.sub("", version_body)
+        if not canonical_version:
+            yield self._input(
+                "VERSION", "VERSION is empty",
+                "write the canonical semantic version into VERSION",
+            )
+            return
+        if not self._SEMVER.match(canonical_version):
+            yield self._input(
+                "VERSION", f"VERSION is not semantic x.y.z: {canonical_version}",
+                f"rewrite VERSION to hold a semantic x.y.z version instead of "
+                f"'{canonical_version}'",
+            )
+            return
+
+        changelog_body = self.text(ctx, "CHANGELOG.md")
+        if changelog_body is None:
+            yield self._input(
+                "CHANGELOG.md", "CHANGELOG.md is missing",
+                "create CHANGELOG.md recording the release history",
+            )
+            return
+
+        changelog_version = self._latest_changelog_version(changelog_body)
+        if not changelog_version:
+            yield self._input(
+                "CHANGELOG.md",
+                "unable to read latest CHANGELOG.md release version",
+                "add a release heading to CHANGELOG.md (## x.y.z or "
+                "## [x.y.z]) naming the current release",
+            )
+            return
+
+        for name in ("changesets_package", "workflows_package"):
+            path = ctx.inputs[name]
+            relative = ctx.relative(path)
+            body = self.text(ctx, path)
+            if body is None:
+                yield self._input(
+                    relative, f"{relative} is missing",
+                    f"create {relative} declaring a version field",
+                )
+                return
+            file_version = self._file_version(relative, body)
+            if not file_version:
+                yield self._input(
+                    relative, f"unable to read version from {relative}",
+                    f"add a version field to {relative}",
+                )
+                return
+            if file_version != canonical_version:
+                yield self.report(
+                    relative,
+                    f"{relative} has version {file_version}, expected "
+                    f"{canonical_version} (from VERSION)",
+                    f"update {relative}'s version field to {canonical_version}",
+                )
+
+        if changelog_version != canonical_version:
+            yield self.report(
+                "CHANGELOG.md",
+                f"CHANGELOG.md's latest release heading is {changelog_version}, "
+                f"expected {canonical_version} (from VERSION)",
+                f"add or rename CHANGELOG.md's latest release heading to "
+                f"## {canonical_version}",
+            )
+
+    # ------------------------------------------------------------- hard stops
+
+    def _input(self, path: str, message: str, fix: str) -> Report:
+        return self.report(path, message, fix, rule=self.INPUT)
+
+    # ------------------------------------------------------------- reading
+
+    def _file_version(self, relative: str, body: str) -> str | None:
+        pattern = self._JSON_VERSION if relative.endswith(".json") else self._TOML_VERSION
+        for line in body.splitlines():
+            match = pattern.match(line)
+            if match is not None:
+                return match.group(1)
+        return None
+
+    def _latest_changelog_version(self, body: str) -> str | None:
+        """awk's one-pass scan: the FIRST `## ` heading that is not the
+        Unreleased section, stripped of its `## [`/`]…`/`## ` wrapping —
+        in that fixed order, so a bracketed and a bare heading both resolve to
+        the bare version text."""
+        for line in body.splitlines():
+            if not line.startswith("## "):
+                continue
+            if self._UNRELEASED_BRACKET.match(line):
+                continue
+            if line == "## Unreleased":
+                continue
+            return self._strip_heading(line)
+        return None
+
+    @staticmethod
+    def _strip_heading(line: str) -> str:
+        text = line
+        if text.startswith("## ["):
+            text = text[4:]
+        end = text.find("]")
+        if end != -1:
+            text = text[:end]
+        if text.startswith("## "):
+            text = text[3:]
+        return text

package/packages/repo-controls/package/adl-compliance/src/adl_compliance/checks/release/version_release/fixtures/aligned/.workflows/changesets/package.json

@@ -0,0 +1,5 @@
+{
+  "name": "changesets-fixture",
+  "version": "1.2.3",
+  "private": true
+}

package/packages/repo-controls/package/adl-compliance/src/adl_compliance/checks/release/version_release/fixtures/aligned/.workflows/package.json

@@ -0,0 +1,5 @@
+{
+  "name": "workflows-fixture",
+  "version": "1.2.3",
+  "private": true
+}

package/packages/repo-controls/package/adl-compliance/src/adl_compliance/checks/release/version_release/fixtures/aligned/CHANGELOG.md

@@ -0,0 +1,5 @@
+# Changelog
+
+## 1.2.3
+
+- fixture: aligned release notes

package/packages/repo-controls/package/adl-compliance/src/adl_compliance/checks/release/version_release/fixtures/aligned/VERSION

@@ -0,0 +1 @@
+1.2.3

package/packages/repo-controls/package/adl-compliance/src/adl_compliance/checks/release/version_release/fixtures/mismatched/.workflows/changesets/package.json

@@ -0,0 +1,5 @@
+{
+  "name": "changesets-fixture",
+  "version": "1.2.3",
+  "private": true
+}

package/packages/repo-controls/package/adl-compliance/src/adl_compliance/checks/release/version_release/fixtures/mismatched/.workflows/package.json

@@ -0,0 +1,5 @@
+{
+  "name": "workflows-fixture",
+  "version": "1.2.2",
+  "private": true
+}

package/packages/repo-controls/package/adl-compliance/src/adl_compliance/checks/release/version_release/fixtures/mismatched/CHANGELOG.md

@@ -0,0 +1,5 @@
+# Changelog
+
+## 1.2.0
+
+- fixture: stale release notes, one minor behind VERSION

package/packages/repo-controls/package/adl-compliance/src/adl_compliance/checks/release/version_release/fixtures/mismatched/VERSION

@@ -0,0 +1 @@
+1.2.3

package/packages/repo-controls/package/adl-compliance/src/adl_compliance/checks/release/version_release/test_check.py

@@ -0,0 +1,162 @@
+"""REL-004 — VERSION, CHANGELOG.md, and the two workflow manifests, aligned.
+
+Not driven through `verdict_for`/`runner.run`: this wave's checks are ported in
+parallel and none may touch `checks/__init__.py`'s shared `CHECKS` tuple, so
+`lookup(row.id)` cannot find this class yet. `Context`/`FileSet` are built
+directly and `VersionRelease().run(...)` is called on them instead — the same
+pattern `tests/core/test_check.py` already uses to test a `Check` subclass in
+isolation — and `decide()` turns the resulting findings into a `Verdict` for
+readable assertions. `REL-004`'s row already exists in
+`policy/gate-registry.yaml` (with `grants: 0`), so `load().resolve("REL-004")`
+resolves it fine; only the class-lookup step is bypassed.
+
+`test_an_aligned_checkout_is_silent` and `test_a_drifted_checkout_reports_
+both_mismatches` are `test.sh`'s own two corpora (`fixtures/aligned`,
+`fixtures/mismatched`, ported byte-for-byte) and assert exactly what its `rg`
+checks assert: the same rule id (`VER-001`), the same two finding paths and
+messages, and that the corpus's one already-aligned manifest
+(`.workflows/changesets/package.json`) is never named.
+
+The remaining tests exercise `VERREL-INPUT`, the tier `check.sh`'s own bare
+`fail()` calls became (see `check.py`'s module docstring) — untested by
+`test.sh`, which never drives a corpus missing VERSION or CHANGELOG.md, the
+same way `COV-003`'s and `PIP-001`'s invented `*-INPUT` tiers are proven by
+fixtures the shell suite never had either.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Iterable
+from contextlib import ExitStack
+from pathlib import Path
+
+from helpers import corpus
+
+from adl_compliance import runner
+from adl_compliance.checks.release.version_release import VersionRelease
+from adl_compliance.core.context import Context, FileSet
+from adl_compliance.core.verdict import Outcome, Verdict, decide
+from adl_compliance.policy.registry import load
+
+CORPORA = corpus("release", "version-release")
+ALIGNED = CORPORA / "aligned"
+MISMATCHED = CORPORA / "mismatched"
+
+ROW = load().resolve("REL-004")
+
+
+def _verdict(root: Path, given: Iterable[str] = (), trees: dict[str, str] | None = None) -> Verdict:
+    with ExitStack() as stack:
+        inputs = runner.resolve_inputs(VersionRelease, root, None, stack, trees)
+        ctx = Context(root=root, row=ROW, inputs=inputs)
+        findings = tuple(VersionRelease().run(ctx, FileSet(paths=tuple(given))))
+    return decide(ROW, findings, granted=0)
+
+
+def test_an_aligned_checkout_is_silent() -> None:
+    verdict = _verdict(ALIGNED)
+    assert verdict.outcome is Outcome.CLEAN, verdict.render()
+
+
+def test_a_drifted_checkout_reports_both_mismatches() -> None:
+    verdict = _verdict(MISMATCHED)
+    assert verdict.outcome is Outcome.FINDINGS, verdict.render()
+    assert verdict.rules == ["VER-001", "VER-001"], verdict.render()
+
+    by_path = {f.path: f.message for f in verdict.findings}
+    assert by_path[".workflows/package.json"] == (
+        ".workflows/package.json has version 1.2.2, expected 1.2.3 (from VERSION)"
+    )
+    assert by_path["CHANGELOG.md"] == (
+        "CHANGELOG.md's latest release heading is 1.2.0, expected 1.2.3 (from VERSION)"
+    )
+    # .workflows/changesets/package.json is aligned (1.2.3) in this fixture and
+    # must not be reported.
+    assert ".workflows/changesets/package.json" not in verdict.render()
+
+
+def test_a_missing_version_file_is_an_input_finding(tmp_path: Path) -> None:
+    (tmp_path / "CHANGELOG.md").write_text("# Changelog\n\n## 1.2.3\n")
+    verdict = _verdict(tmp_path)
+    assert verdict.outcome is Outcome.FINDINGS, verdict.render()
+    assert verdict.rules == ["VERREL-INPUT"]
+    assert verdict.findings[0].path == "VERSION"
+    assert "VERSION is missing" in verdict.findings[0].message
+
+
+def test_an_empty_version_file_is_an_input_finding(tmp_path: Path) -> None:
+    (tmp_path / "VERSION").write_text("   \n")
+    (tmp_path / "CHANGELOG.md").write_text("# Changelog\n\n## 1.2.3\n")
+    verdict = _verdict(tmp_path)
+    assert verdict.rules == ["VERREL-INPUT"], verdict.render()
+    assert "VERSION is empty" in verdict.findings[0].message
+
+
+def test_a_non_semantic_version_is_an_input_finding(tmp_path: Path) -> None:
+    (tmp_path / "VERSION").write_text("v1.2\n")
+    (tmp_path / "CHANGELOG.md").write_text("# Changelog\n\n## 1.2.3\n")
+    verdict = _verdict(tmp_path)
+    assert verdict.rules == ["VERREL-INPUT"], verdict.render()
+    assert "not semantic x.y.z" in verdict.findings[0].message
+
+
+def test_a_missing_changelog_is_an_input_finding(tmp_path: Path) -> None:
+    (tmp_path / "VERSION").write_text("1.2.3\n")
+    verdict = _verdict(tmp_path)
+    assert verdict.rules == ["VERREL-INPUT"], verdict.render()
+    assert verdict.findings[0].path == "CHANGELOG.md"
+    assert "CHANGELOG.md is missing" in verdict.findings[0].message
+
+
+def test_a_changelog_with_no_release_heading_is_an_input_finding(tmp_path: Path) -> None:
+    (tmp_path / "VERSION").write_text("1.2.3\n")
+    (tmp_path / "CHANGELOG.md").write_text("# Changelog\n\n## [Unreleased]\n\n- wip\n")
+    verdict = _verdict(tmp_path)
+    assert verdict.rules == ["VERREL-INPUT"], verdict.render()
+    assert "unable to read latest CHANGELOG.md release version" in verdict.findings[0].message
+
+
+def test_a_missing_versioned_manifest_is_an_input_finding(tmp_path: Path) -> None:
+    (tmp_path / "VERSION").write_text("1.2.3\n")
+    (tmp_path / "CHANGELOG.md").write_text("# Changelog\n\n## 1.2.3\n")
+    verdict = _verdict(tmp_path)
+    assert verdict.rules == ["VERREL-INPUT"], verdict.render()
+    assert verdict.findings[0].path == ".workflows/changesets/package.json"
+    assert "is missing" in verdict.findings[0].message
+
+
+def test_a_redeclared_workflows_tree_is_honoured(tmp_path: Path) -> None:
+    """FIXED 2026-09-15 (K-42 sweep): `VERSIONED_FILES` used to be hardcoded
+    `.workflows/...` literals read directly via `self.text(ctx, relative)`,
+    bypassing `ctx.inputs`/tree resolution entirely. A repository declaring
+    `workflows = "my-workflows"` (with its two manifests actually living
+    there) got both reported as flatly missing — LOUD, but against a path
+    that was never real, never the redeclared one. Drives a real `<workflows>`
+    redeclaration via `effective_trees`, not the packaged-default `trees=None`
+    every other test in this file uses."""
+    from adl_compliance.policy.registry import effective_trees
+
+    (tmp_path / "VERSION").write_text("1.2.3\n")
+    (tmp_path / "CHANGELOG.md").write_text("# Changelog\n\n## 1.2.3\n")
+    workflows = tmp_path / "my-workflows"
+    (workflows / "changesets").mkdir(parents=True)
+    manifest = '{\n  "name": "fixture",\n  "version": "1.2.3"\n}\n'
+    (workflows / "package.json").write_text(manifest)
+    (workflows / "changesets" / "package.json").write_text(manifest)
+    verdict = _verdict(tmp_path, trees=effective_trees({"workflows": "my-workflows"}))
+    assert verdict.outcome is Outcome.CLEAN, verdict.render()
+
+
+def test_a_bracketed_changelog_heading_is_read_the_same_as_a_bare_one(tmp_path: Path) -> None:
+    """`## [1.2.3] - 2024-01-01` and `## 1.2.3` both resolve to `1.2.3`."""
+    (tmp_path / "VERSION").write_text("1.2.3\n")
+    (tmp_path / "CHANGELOG.md").write_text(
+        "# Changelog\n\n## [1.2.3] - 2024-01-01\n\n- release\n"
+    )
+    workflows = tmp_path / ".workflows"
+    (workflows / "changesets").mkdir(parents=True)
+    manifest = '{\n  "name": "fixture",\n  "version": "1.2.3"\n}\n'
+    (workflows / "package.json").write_text(manifest)
+    (workflows / "changesets" / "package.json").write_text(manifest)
+    verdict = _verdict(tmp_path)
+    assert verdict.outcome is Outcome.CLEAN, verdict.render()

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

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

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

@@ -0,0 +1,12 @@
+"""The `repository.no-banned-commands` gate.
+
+A folder even though this gate grades no document of its own: uniform depth
+means every `check.py` sits at exactly `checks/*/*/check.py`, so a relative
+import out of a check is right for all of them or wrong for all of them.
+"""
+
+from __future__ import annotations
+
+from .check import BannedCommands
+
+__all__ = ["BannedCommands"]

package/packages/repo-controls/package/adl-compliance/src/adl_compliance/checks/repository/banned_commands/check.py

@@ -0,0 +1,103 @@
+"""REP-004 — no executable invocation of a banned command inside this package.
+
+  GIT-001  a standalone version-control command.
+  GRP-001  a standalone legacy search command.
+
+Two rules, one table, because they differed only in the forbidden word.
+
+**This gate would report itself if written naively** (K-15). A check that
+forbids a string necessarily contains it, so both words are ASSEMBLED from
+fragments below and appear nowhere in this file as a single token — the shell
+version was flagged at its own line 85 before it did the same.
+
+The extension test is SUBJECT MATTER, not scope. It asks what KIND of file this
+is — the rule is about shell, and a `.md` file naming a command is prose. A path
+PREFIX would be a different question, "where is this file", and that is the row's
+`engine.scope` to answer; an earlier draft filtered `compliance/**` inside the
+script and that is the hand-rolled path list AGENTS.md forbids.
+
+What the port deletes is everything the shell needed to REACH the search: a
+`command -v rg` prologue, `mktemp` with a NUL-delimited list because the tree has
+paths with spaces, an `xargs -0 sh -c` batch wrapper, and the exit-status
+translation inside it — GNU `xargs` collapses every utility exit in 1..125 to
+123, so rg's "no matches" and "real error" arrived identically. `re` has no exit
+status to translate.
+"""
+
+from __future__ import annotations
+
+import re
+from collections.abc import Iterable
+from typing import ClassVar, NamedTuple
+
+from ....core.check import Check
+from ....core.context import Context, FileSet
+from ....core.finding import Report
+
+
+class Banned(NamedTuple):
+    rule: str
+    word: str
+    message: str
+    fix: str
+
+
+class BannedCommands(Check):
+    id: ClassVar[str] = "REP-004"
+
+    SHELL_SUFFIXES: ClassVar[tuple[str, ...]] = (".sh", ".bash", ".zsh")
+    JUSTFILE: ClassVar[str] = "justfile"
+
+    # Assembled, never spelled. Written as one token, this file becomes a
+    # violation of the rule it enforces -- and a true one, by the rule's own
+    # definition.
+    VCS_WORD: ClassVar[str] = "gi" + "t"
+    SEARCH_WORD: ClassVar[str] = "gr" + "ep"
+
+    BOUNDARY: ClassVar[str] = r"(?:^|[;&|()`\s'\"])"
+    """A command START. The backtick is in the class so a command substitution
+    opening with one is still recognised; the original GRP-001 pattern omitted
+    it and the original GIT-001 pattern is the one kept."""
+
+    TRAILING: ClassVar[str] = r"(?:\s|$)"
+
+    COMMENT: ClassVar[re.Pattern[str]] = re.compile(r"^\s*#")
+    """A WHOLE-LINE comment only. Deliberately conservative: a trailing comment
+    on a real command line stays flagged, because deciding whether a mid-line
+    '#' opens a comment or sits inside a quoted string needs a shell parser, and
+    over-reporting is the safe direction."""
+
+    def banned(self) -> tuple[Banned, ...]:
+        return (
+            Banned(
+                rule="GIT-001",
+                word=self.VCS_WORD,
+                message="version-control invocation is forbidden inside the compliance package",
+                fix="read the set the runner hands you, or drop the call if it only built "
+                    "a repository the assertion never needed",
+            ),
+            Banned(
+                rule="GRP-001",
+                word=self.SEARCH_WORD,
+                message="standalone legacy search command is forbidden; use rg",
+                fix="replace this invocation with an equivalent rg call",
+            ),
+        )
+
+    def graded(self, ctx: Context, files: FileSet) -> Iterable[Report]:
+        targets = sorted(p for p in files if self._is_shell(p))
+        for relative in FileSet(paths=tuple(targets)).existing(ctx.root):
+            for entry in self.banned():
+                pattern = re.compile(f"{self.BOUNDARY}{re.escape(entry.word)}{self.TRAILING}")
+                for line, found in self.scan(ctx, relative, pattern):
+                    # `found.string` is the line: `scan` matches line by line.
+                    if self.COMMENT.match(found.string):
+                        continue
+                    yield self.report(
+                        relative, f"{entry.message} ({found.string.strip()})",
+                        entry.fix, rule=entry.rule, line=line,
+                    )
+
+    def _is_shell(self, relative: str) -> bool:
+        name = relative.rsplit("/", 1)[-1]
+        return name == self.JUSTFILE or relative.endswith(self.SHELL_SUFFIXES)

package/packages/repo-controls/package/adl-compliance/src/adl_compliance/checks/repository/banned_commands/fixtures/no-banned-commands/compliance_py/checks/git-bad.sh

@@ -0,0 +1,2 @@
+#!/usr/bin/env bash
+git rev-parse --show-toplevel

package/packages/repo-controls/package/adl-compliance/src/adl_compliance/checks/repository/banned_commands/fixtures/no-banned-commands/compliance_py/checks/git-note.sh

@@ -0,0 +1,3 @@
+#!/usr/bin/env bash
+# never call git here; the runner hands this check its file set
+echo ok

package/packages/repo-controls/package/adl-compliance/src/adl_compliance/checks/repository/banned_commands/fixtures/no-banned-commands/compliance_py/checks/good.sh

@@ -0,0 +1,2 @@
+#!/usr/bin/env bash
+rg -q x file

package/packages/repo-controls/package/adl-compliance/src/adl_compliance/checks/repository/banned_commands/fixtures/no-banned-commands/compliance_py/checks/grep-bad.sh

@@ -0,0 +1,2 @@
+#!/usr/bin/env bash
+printf 'x\n' | grep -q x

package/packages/repo-controls/package/adl-compliance/src/adl_compliance/checks/repository/banned_commands/fixtures/no-banned-commands/compliance_py/checks/grep-note.sh

@@ -0,0 +1,3 @@
+#!/usr/bin/env bash
+# never use grep here; use rg
+echo ok

package/packages/repo-controls/package/adl-compliance/src/adl_compliance/checks/repository/banned_commands/fixtures/no-banned-commands/compliance_py/checks/grep-trailing.sh

@@ -0,0 +1,2 @@
+#!/usr/bin/env bash
+grep -q x file # deliberately still a violation

package/packages/repo-controls/package/adl-compliance/src/adl_compliance/checks/repository/banned_commands/fixtures/no-banned-commands/compliance_py/checks/notes.md

@@ -0,0 +1 @@
+Historic note: this repository no longer uses grep.

package/packages/repo-controls/package/adl-compliance/src/adl_compliance/checks/repository/banned_commands/fixtures/no-banned-commands/elsewhere/loose-git.sh

@@ -0,0 +1,6 @@
+#!/usr/bin/env bash
+# A REAL git invocation, deliberately outside compliance/**. It must not be
+# reported when the row's scope narrows the given set to compliance/**, and
+# it MUST be reported when the whole corpus is graded directly (the check
+# itself does no path filtering — see check.py).
+git status --porcelain

package/packages/repo-controls/package/adl-compliance/src/adl_compliance/checks/repository/banned_commands/fixtures/no-banned-commands/elsewhere/loose-grep.sh

@@ -0,0 +1,4 @@
+#!/usr/bin/env bash
+# A REAL grep invocation, deliberately outside compliance/**. Same contrast as
+# loose-git.sh: in scope, silent; graded directly, reported.
+grep -q x file