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

package/packages/repo-controls/package/adl-compliance/src/adl_compliance/checks/layout/agents_layout/fixtures/.workflows/CLAUDE.md

@@ -0,0 +1 @@
+@AGENTS.md

package/packages/repo-controls/package/adl-compliance/src/adl_compliance/checks/layout/agents_layout/fixtures/AGENTS.md

@@ -0,0 +1,3 @@
+# Root guide
+
+The corpus root guide. Rule 1 probes this path on disk.

package/packages/repo-controls/package/adl-compliance/src/adl_compliance/checks/layout/agents_layout/fixtures/CLAUDE.md

@@ -0,0 +1,2 @@
+@AGENTS.md
+# Additional root context

package/packages/repo-controls/package/adl-compliance/src/adl_compliance/checks/layout/agents_layout/fixtures/INVARIANTS.md

@@ -0,0 +1,3 @@
+# Invariants
+
+Rule 1 probes this path on disk too.

package/packages/repo-controls/package/adl-compliance/src/adl_compliance/checks/layout/agents_layout/fixtures/bad-pointer/AGENTS.md

@@ -0,0 +1,3 @@
+# Bad pointer
+
+The CLAUDE.md beside this one points at it in prose.

package/packages/repo-controls/package/adl-compliance/src/adl_compliance/checks/layout/agents_layout/fixtures/bad-pointer/CLAUDE.md

@@ -0,0 +1 @@
+See AGENTS.md

package/packages/repo-controls/package/adl-compliance/src/adl_compliance/checks/layout/agents_layout/fixtures/docs/AGENTS.md

@@ -0,0 +1 @@
+# Docs guide

package/packages/repo-controls/package/adl-compliance/src/adl_compliance/checks/layout/agents_layout/fixtures/docs/CLAUDE.md

@@ -0,0 +1 @@
+@AGENTS.md

package/packages/repo-controls/package/adl-compliance/src/adl_compliance/checks/layout/agents_layout/fixtures/missing-pair/AGENTS.md

@@ -0,0 +1,3 @@
+# Missing pair
+
+No CLAUDE.md sibling exists beside this guide.

package/packages/repo-controls/package/adl-compliance/src/adl_compliance/checks/layout/agents_layout/fixtures/owned/AGENTS.md

@@ -0,0 +1 @@
+# Owned guide

package/packages/repo-controls/package/adl-compliance/src/adl_compliance/checks/layout/agents_layout/fixtures/owned/CLAUDE.md

@@ -0,0 +1,2 @@
+@AGENTS.md
+# Additional local context

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

@@ -0,0 +1,116 @@
+"""LAY-001 — every AGENTS.md owes a sibling CLAUDE.md pointing back at it.
+
+ONE corpus, two sets. The gate takes the guides it grades out of the GIVEN SET,
+so the clean case is the same tree with the two broken pairs left out of the
+list — which is what a commit that touched neither looks like in production. A
+second corpus would have copied nine unchanged files to vary two.
+"""
+
+from __future__ import annotations
+
+from helpers import corpus, corpus_files, verdict_for
+
+from adl_compliance.core.verdict import Outcome
+
+CORPUS = corpus("layout", "agents-layout")
+BROKEN = ("missing-pair/", "bad-pointer/")
+
+
+def clean_set() -> tuple[str, ...]:
+    return tuple(p for p in corpus_files(CORPUS) if not p.startswith(BROKEN))
+
+
+def test_the_premise_holds() -> None:
+    """Asserted, not assumed: a mistyped prefix would leave both sets identical
+    and every case below would agree for nothing."""
+    assert len(corpus_files(CORPUS)) == 12
+    assert len(clean_set()) == 9
+
+
+def test_complete_pairs_are_silent() -> None:
+    verdict = verdict_for("LAY-001", CORPUS, given=clean_set())
+    assert verdict.outcome is Outcome.CLEAN, verdict.render()
+    assert verdict.findings == ()
+
+
+def test_broken_pairs_are_reported() -> None:
+    verdict = verdict_for("LAY-001", CORPUS)
+    assert verdict.outcome is Outcome.FINDINGS, verdict.render()
+
+    # One assertion per failure mode: a single "it failed" would pass on either
+    # firing alone and hide the other going quiet.
+    assert "missing-pair/CLAUDE.md" in verdict.render()
+    assert "must contain a line exactly '@AGENTS.md'" in verdict.render()
+
+
+def test_a_wrong_pointer_is_not_reported_as_a_missing_file() -> None:
+    """The two findings carry different fixes, and conflating them sends the
+    reader to create a file that is already there."""
+    assert "bad-pointer/CLAUDE.md: is missing" not in verdict_for("LAY-001", CORPUS).render()
+
+
+def test_intact_pairs_stay_silent() -> None:
+    """Without this, the cases above also pass against a gate that reports
+    every pair it reads."""
+    text = verdict_for("LAY-001", CORPUS).render()
+    for intact in ("docs", "owned", ".workflows"):
+        assert f"{intact}/CLAUDE.md" not in text
+
+
+def test_every_finding_resolves_inside_the_corpus() -> None:
+    """This checkout is full of AGENTS.md/CLAUDE.md pairs. A check that resolved
+    a repository root instead of using the root it was handed would name them.
+
+    Asserted by EXISTENCE, not by prefix: a corpus path and a checkout path are
+    the same shape, so only "does this resolve inside the corpus" separates them.
+    """
+    for finding in verdict_for("LAY-001", CORPUS).findings:
+        # missing-pair/CLAUDE.md is reported precisely because it does NOT
+        # exist, so the assertion is about its directory.
+        assert (CORPUS / finding.path).parent.exists(), finding.render()
+
+
+def test_an_empty_set_grades_nothing_from_the_set() -> None:
+    """Both broken pairs are still on disk. A check that grades only what it is
+    handed must report neither — this is the case that fails the moment one
+    falls back to walking its root."""
+    verdict = verdict_for("LAY-001", CORPUS, given=())
+    assert all("CLAUDE.md" not in f.path for f in verdict.findings), verdict.render()
+
+
+def test_the_structural_half_still_runs_on_an_empty_set() -> None:
+    """`structural` is not gated on the set: the governance files are named
+    paths, and an absent one is the finding."""
+    verdict = verdict_for("LAY-001", CORPUS, given=())
+    assert verdict.outcome is Outcome.CLEAN, verdict.render()
+
+
+def test_a_redeclared_docs_and_workflows_tree_is_still_graded(tmp_path) -> None:
+    """The LOUD false-finding this check shipped with.
+
+    The `docs/AGENTS.md` entry in GOVERNANCE_LIMITS and BOOTSTRAP_GUIDES'
+    `.workflows/AGENTS.md` were hardcoded literals, opened as named paths. A
+    repository whose docs or workflows root is not the packaged default had
+    its real guide fail that open and get reported "is missing" -- a
+    visible, wrong finding about a file that is right there.
+
+    Same content as the committed corpus's `docs/` and `.workflows/`
+    directories, copied under `documentation/` and `automation/` instead:
+    wrongly reported missing before the fix, silent after."""
+    import shutil
+
+    root = tmp_path / "repo"
+    root.mkdir()
+    shutil.copy(CORPUS / "AGENTS.md", root / "AGENTS.md")
+    shutil.copy(CORPUS / "INVARIANTS.md", root / "INVARIANTS.md")
+    shutil.copytree(CORPUS / "docs", root / "documentation")
+    shutil.copytree(CORPUS / ".workflows", root / "automation")
+
+    verdict = verdict_for(
+        "LAY-001", root, given=(),
+        inputs={"docs_root": root / "documentation", "workflows_root": root / "automation"},
+    )
+    assert verdict.outcome is Outcome.CLEAN, (
+        f"real guides under redeclared docs/workflows roots were wrongly "
+        f"reported missing: {verdict.render()}"
+    )

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

@@ -0,0 +1,13 @@
+"""The `layout.ci-paths` gate.
+
+A folder even though this gate grades no single named 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 CiPaths
+
+__all__ = ["CiPaths"]

package/packages/repo-controls/package/adl-compliance/src/adl_compliance/checks/layout/ci_paths/check.py

@@ -0,0 +1,380 @@
+r"""LAY-002 -- a CI-executed file must never reference a path .gitignore
+excludes from tracking.
+
+Ported from `compliance_new/checks/layout/ci-paths/check.sh`. Single rule,
+same id as the row (check.sh's own `RULE_ID=LAY-002`):
+
+  LAY-002   a CI surface (a pipeline definition, or a `*.sh` file outside
+            `tests/`) references a path-looking token that is ignored --
+            invisible to a CI checkout even though it is real on the author's
+            machine. The row's own header documents the incident this closes:
+            a CI step ran `python3 /<donor-tree>/probe.py`, which passed
+            locally (the donor clone exists on the dev machine) and could
+            never pass in CI, where `.donors/` is ignored.
+
+THE SOURCE IS CORRUPTED THE SAME WAY OTHER PORTED FILES DOCUMENT ALREADY (see
+`checks/repository/ignored_paths/check.py`'s "THE SOURCE IS CORRUPTED..."
+section, and `checks/layout/root_closed_set/check.py`): the literal word
+"git" is missing throughout `check.sh`, e.g. `` `e --show-toplevel` `` and
+`` ` check-ignore --stdin` ``. Verified directly: `'git' in
+open('compliance_new/checks/layout/ci-paths/check.sh').read()` is `False`.
+Unlike `ignored_paths`, this file still RUNS up to its one corrupted external
+call: it never resolves its own root (K-40 -- the runner sets the working
+directory), its awk pass is syntactically intact, and only
+`` check-ignore --stdin`` (a plain command-lookup failure, not a parse
+failure) would actually break execution. Every earlier step -- which files
+are a CI surface, which line is a comment, which substring is a path token,
+which token is excluded as not-a-real-path -- is real, uncorrupted, observed
+source. The missing word is unambiguously `git`: the row's own title ("Run
+retained CI paths gate"), this file's own header ("` check-ignore` below is
+SUBJECT MATTER, not scope"), and `checks/repository/ignored-paths/check.sh`'s
+identical corruption of the same subcommand all agree on
+`git check-ignore --stdin`.
+
+WHAT test.sh ASSERTS -- read in full, because it does not obviously build or
+point at a fixture corpus, and it does not: it is nine lines, and the whole
+of its body after the shebang and `set -euo pipefail` is
+
+    . "${BASH_SOURCE[0]%/*}/../../framework/_dispatch-contract.sh"
+    dispatch_contract layout.ci-paths pr_validation
+
+`_dispatch-contract.sh`'s own header says exactly what this proves and what it
+does not: "Proves the registry row still resolves to a script that actually
+runs -- nothing about the rule's behaviour". It runs the row against a
+deliberately EMPTY change set and asserts the process exits 0 or 1, never 2.
+There is no `fixtures/` directory anywhere under
+`compliance_new/checks/layout/ci-paths/` (confirmed by listing the folder),
+no inline `mktemp`/heredoc scenario, and no named input this check grades.
+This is the wiring-only shape, not a corpus this port could recover: nothing
+here is invented to fill the gap. `test_check.py` below proves the one thing
+`test.sh` proves -- an empty given set runs to a clean, non-crashing verdict
+-- plus pure-function unit tests of the literal awk logic ported below.
+Neither is a constructed end-to-end detection scenario.
+
+WHY THIS CHECK DOES NOT CALL GIT: identical reasoning to
+`checks/repository/ignored_paths` (REP-005) and stated once, not repeated, in
+`AGENTS.md`/`INVARIANTS.md`: `cli.py` is the one and only caller of `git`
+(K-31), and the version-control tool itself is banned from every check
+(`checks/repository/banned_commands` GIT-001, which this package enforces on
+itself) -- `git check-ignore` is not portable as a subprocess call the way
+`ast-grep`/`cargo` are elsewhere. `.gitignore` is read as DATA instead
+(`gitignore(5)`'s pattern grammar), reimplementing the same
+translate/compile/decide algorithm `ignored_paths` already established.
+Duplicated here rather than imported: "no check imports another" is the
+layout rule this package states in its own `AGENTS.md`, and REP-005's
+matcher is private to that module.
+
+THE REACH REDUCTION, AND WHY IT IS NOT VACUOUS FOR THIS ROW: `git
+check-ignore` consults every `.gitignore` from a candidate's directory up to
+the repository root, regardless of what changed. Forbidden from walking the
+tree or calling git, this port can only ever see two sources:
+
+  1. The repository ROOT `.gitignore`, read directly by a single fixed-path
+     probe -- the same "resolved straight off disk through `ctx.path`, never
+     filtered through the given set" precedent `checks/layout/references`
+     (LAY-011) already establishes for a target whose relevance does not
+     depend on being in this run's scope.
+  2. Any `.gitignore` that is itself present in the GIVEN SET, the same
+     reduction `ignored_paths` documents (its own "ONE KNOWN GAP" section).
+
+  This row's own `engine.scope` (`<workflows>/{scripts,pipelines,config}/**`)
+  makes source 2 real rather than always-empty: a nested `.gitignore` already
+  lives inside that scope, at `.workflows/config/coverage/.gitignore`
+  (verified: `find .workflows/scripts .workflows/pipelines .workflows/config
+  -iname '.gitignore'` names exactly that one file). A `.gitignore` elsewhere
+  in the tree governing a token a CI script references (say, under
+  `frontend/`) is invisible to this port -- a real, stated reduction versus
+  the shell tool's filesystem-wide `git check-ignore`, not a silent one.
+
+THE ROOT-NAME VALIDITY PROBE (check.sh's `ls -1A .`) is, likewise, a single
+non-recursive listing of ONE fixed, named location -- the graded root itself,
+never a walk of the tree beneath it -- ported as `ctx.root.iterdir()`, read
+once per run.
+
+TWO OF check.sh's SIX EXCLUSION CONDITIONS ARE UNREACHABLE, AND PORTED AS-IS
+RATHER THAN DROPPED: the token-extraction regex's character class
+(`[A-Za-z0-9_.-]`) contains no `:`, so a token this check ever tests can never
+contain `://` and never contains `:` at all -- `token ~ /:\/\//` and
+`index(token, ":") > 0` can never be true. check.sh carries both checks
+regardless (defensive, or a leftover from a wider tokenizer); this port keeps
+both for fidelity to the shell rule set, noted here rather than silently
+dropped, since they are genuinely inert rather than wrong.
+"""
+
+from __future__ import annotations
+
+import re
+from collections.abc import Iterable, Iterator
+from typing import ClassVar, NamedTuple
+
+from ....core.check import Check
+from ....core.context import Context, FileSet
+from ....core.finding import Report
+
+
+class _Rule(NamedTuple):
+    """One compiled `.gitignore` line. Shallowest source first, deepest last;
+    `_decide` keeps the LAST matching rule, which is git's own precedence."""
+
+    negated: bool
+    directory: str
+    """The owning `.gitignore`'s containing directory; `""` for the root."""
+
+    regex: re.Pattern[str]
+    """Matched against a candidate already made relative to `directory`."""
+
+
+def _strip_trailing_unescaped_spaces(line: str) -> str:
+    return re.sub(r"(?<!\\) +$", "", line)
+
+
+def _translate(pattern: str) -> str:
+    """`gitignore(5)`'s glob grammar -> a regex fragment.
+
+    `*` and `?` never cross `/`; `**` does, in each of its three documented
+    shapes (leading `**/`, trailing `/**`, a bracketing `/**/`). Every other
+    character is escaped; a backslash unescapes the character after it
+    literally.
+    """
+    out: list[str] = []
+    i, n = 0, len(pattern)
+    while i < n:
+        if pattern.startswith("**/", i):
+            out.append(r"(?:.*/)?")
+            i += 3
+        elif pattern.startswith("/**/", i):
+            out.append(r"/(?:.*/)?")
+            i += 4
+        elif i + 3 == n and pattern.endswith("/**"):
+            out.append(r"/.*")
+            i = n
+        elif pattern.startswith("**", i):
+            out.append(r".*")
+            i += 2
+        elif pattern[i] == "*":
+            out.append(r"[^/]*")
+            i += 1
+        elif pattern[i] == "?":
+            out.append(r"[^/]")
+            i += 1
+        elif pattern[i] == "[":
+            close = pattern.find("]", i + 1)
+            if close == -1:
+                out.append(re.escape("["))
+                i += 1
+            else:
+                out.append(pattern[i : close + 1])
+                i = close + 1
+        elif pattern[i] == "\\" and i + 1 < n:
+            out.append(re.escape(pattern[i + 1]))
+            i += 2
+        else:
+            out.append(re.escape(pattern[i]))
+            i += 1
+    return "".join(out)
+
+
+def _compile_rule(raw: str, directory: str) -> _Rule | None:
+    """One `.gitignore` line -> a `_Rule`, or `None` for blank/comment lines."""
+    line = _strip_trailing_unescaped_spaces(raw)
+    if not line:
+        return None
+    if line.startswith("\\#"):
+        line = line[1:]
+    elif line.startswith("#"):
+        return None
+
+    negated = False
+    if line.startswith("\\!"):
+        line = line[1:]
+    elif line.startswith("!"):
+        negated = True
+        line = line[1:]
+    if not line:
+        return None
+
+    dir_only = line.endswith("/") and not line.endswith("\\/")
+    if dir_only:
+        line = line[:-1]
+
+    anchored = "/" in line
+    if line.startswith("/"):
+        line = line[1:]
+        anchored = True
+
+    body = _translate(line)
+    if dir_only:
+        body += r"/.*"
+    fragment = f"^{body}$" if anchored else f"^(?:.*/)?{body}$"
+    return _Rule(negated=negated, directory=directory, regex=re.compile(fragment))
+
+
+def _parse(directory: str, body: str) -> list[_Rule]:
+    rules = []
+    for raw in body.splitlines():
+        rule = _compile_rule(raw, directory)
+        if rule is not None:
+            rules.append(rule)
+    return rules
+
+
+def _relative_to(directory: str, path: str) -> str | None:
+    """`path` expressed relative to `directory`, or `None` when not under it."""
+    if not directory:
+        return path
+    prefix = f"{directory}/"
+    return path[len(prefix) :] if path.startswith(prefix) else None
+
+
+class CiPaths(Check):
+    id: ClassVar[str] = "LAY-002"
+    rule: ClassVar[str] = "LAY-002"
+
+    inputs: ClassVar[dict[str, str]] = {"workflows_root": "<workflows>"}
+    """FIXED 2026-09-16 (K-42 sweep, SILENT form, approved): PIPELINE_SURFACES
+    was a set of hardcoded `.workflows/...` literals, tested for membership in
+    `_is_surface` -- a repository whose workflows root is not the packaged
+    default had its real pipeline definitions fail that membership test, fell
+    through the `.sh` check too (they are `.yaml`), and the gate silently
+    never scanned them at all: clean, having examined nothing. `pipelines/
+    pr-validation.yaml` and `pipelines/qua-cd.yaml` stay literal below the
+    resolved root: the settled pipeline names, not resolvable paths."""
+
+    GITIGNORE: ClassVar[str] = ".gitignore"
+    PIPELINE_NAMES: ClassVar[frozenset[str]] = frozenset(
+        {"pipelines/pr-validation.yaml", "pipelines/qua-cd.yaml"}
+    )
+
+    # `[A-Za-z0-9_.-]+(\/[A-Za-z0-9_.-]+)+` in the original awk.
+    TOKEN_RE: ClassVar[re.Pattern[str]] = re.compile(
+        r"[A-Za-z0-9_.-]+(?:/[A-Za-z0-9_.-]+)+"
+    )
+    URL_RE: ClassVar[re.Pattern[str]] = re.compile(
+        r"[A-Za-z][A-Za-z0-9+.-]*://[^\s\"')]+"
+    )
+    COMMENT_RE: ClassVar[re.Pattern[str]] = re.compile(r"^\s*#")
+
+    def graded(self, ctx: Context, files: FileSet) -> Iterable[Report]:
+        existing = files.existing(ctx.root)
+        pipeline_surfaces = self._pipeline_surfaces(ctx)
+        surfaces = sorted(p for p in existing if self._is_surface(p, pipeline_surfaces))
+        if not surfaces:
+            return
+
+        root_names = self._root_names(ctx)
+        pairs: list[tuple[str, str]] = []
+        for surface in surfaces:
+            body = self.text(ctx, surface)
+            if body is None:
+                continue
+            for raw_line in body.splitlines():
+                if self.COMMENT_RE.match(raw_line):
+                    continue
+                line = self.URL_RE.sub("", raw_line)
+                for token in self._tokens(line, root_names):
+                    pairs.append((surface, token))
+        if not pairs:
+            return
+
+        # `cut -f2 | sort -u | awk 'NF && $0 !~ /^-/'`: the deduped batch a
+        # real `git check-ignore --stdin` would have been asked about.
+        candidates = sorted({token for _, token in pairs if token and not token.startswith("-")})
+        if not candidates:
+            return
+
+        rules = self._gitignore_rules(ctx, existing)
+        if not rules:
+            return
+        ignored = {token for token in candidates if self._is_ignored(token, rules)}
+        if not ignored:
+            return
+
+        for surface, token in pairs:
+            if token not in ignored:
+                continue
+            yield self.report(
+                surface,
+                f"references '{token}', which is ignored (invisible to CI checkouts)",
+                f"remove the reference to '{token}' from {surface}, or stop "
+                f"ignoring '{token}' if CI must see it",
+            )
+
+    # ------------------------------------------------------------- surfaces
+
+    def _pipeline_surfaces(self, ctx: Context) -> frozenset[str]:
+        workflows_root = ctx.relative(ctx.inputs["workflows_root"])
+        return frozenset(f"{workflows_root}/{name}" for name in self.PIPELINE_NAMES)
+
+    def _is_surface(self, path: str, pipeline_surfaces: frozenset[str]) -> bool:
+        if path in pipeline_surfaces:
+            return True
+        if path.startswith("tests/"):
+            return False
+        return path.endswith(".sh")
+
+    # --------------------------------------------------------------- tokens
+
+    def _tokens(self, line: str, root_names: frozenset[str]) -> Iterator[str]:
+        for match in self.TOKEN_RE.finditer(line):
+            token = match.group(0)
+            if not self._excluded(token, root_names):
+                yield token
+
+    def _excluded(self, token: str, root_names: frozenset[str]) -> bool:
+        if token.startswith("http"):
+            return True
+        if "://" in token:  # unreachable: ':' is outside TOKEN_RE's charset
+            return True
+        if ".dkr." in token:
+            return True
+        if ":" in token:  # unreachable, same reason
+            return True
+        if token.startswith(".donors/"):
+            return True
+        if token.startswith("target/"):
+            return True
+        first = token.split("/", 1)[0]
+        return first not in root_names
+
+    def _root_names(self, ctx: Context) -> frozenset[str]:
+        """`ls -1A .`: the graded root's own immediate children, read once --
+        a single fixed-path probe, never a walk of the tree beneath it."""
+        try:
+            return frozenset(entry.name for entry in ctx.root.iterdir())
+        except OSError:
+            return frozenset()
+
+    # ------------------------------------------------------------ gitignore
+
+    def _gitignore_rules(self, ctx: Context, existing: FileSet) -> list[_Rule]:
+        sources: list[tuple[int, str, str]] = []  # (depth, directory, body)
+        root_body = self.text(ctx, self.GITIGNORE)
+        if root_body is not None:
+            sources.append((0, "", root_body))
+        for path in existing:
+            if not self._is_gitignore(path):
+                continue
+            body = self.text(ctx, path)
+            if body is None:
+                continue
+            directory = path.rsplit("/", 1)[0] if "/" in path else ""
+            sources.append((directory.count("/") + 1, directory, body))
+        sources.sort(key=lambda entry: entry[0])
+
+        rules: list[_Rule] = []
+        for _, directory, body in sources:
+            rules.extend(_parse(directory, body))
+        return rules
+
+    def _is_gitignore(self, path: str) -> bool:
+        return path == self.GITIGNORE or path.endswith(f"/{self.GITIGNORE}")
+
+    def _is_ignored(self, candidate: str, rules: list[_Rule]) -> bool:
+        """The LAST matching rule decides: a negation is a decision too,
+        just not an ignoring one."""
+        matched: _Rule | None = None
+        for entry in rules:
+            rel = _relative_to(entry.directory, candidate)
+            if rel is not None and entry.regex.match(rel):
+                matched = entry
+        return matched is not None and not matched.negated

package/packages/repo-controls/package/adl-compliance/src/adl_compliance/checks/layout/ci_paths/fixtures/redeclared-workflows-tree/automation/pipelines/pr-validation.yaml

@@ -0,0 +1 @@
+cat automation/config/coverage/summary.json