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

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

@@ -0,0 +1,329 @@
+"""LAY-013 — ported from `compliance_new/checks/layout/root-markdown-allowlist/test.sh`.
+
+Two corpora, byte-for-byte from the shell tree's fixtures:
+`root-markdown-clean/` holds every literal-name exception, every basename
+exception, every tree exception, one nested README, and one stray root
+Markdown file — the two violators live inside the same conforming tree, so a
+corpus flips between clean and broken by changing only which paths are in the
+given set, exactly as test.sh's own comment describes. `root-markdown-missing-
+guide/` holds only the four files the structural rule reads, with
+`.specs/AGENTS.md` absent.
+
+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-013"
+before ever reaching this check's own logic — `lookup()` runs before scope
+narrowing. Every test below therefore calls `RootMarkdownAllowlist` directly,
+the same `decide()`-around-`graded()`/`structural()` shape
+`layout/markdown_trees/test_check.py` and
+`repository/banned_commands/test_check.py` already use to bypass the unwired
+`lookup()`; nothing here is a new pattern.
+
+A `full()` helper additionally exercises `Check.run()` itself — structural and
+graded together — for the corpus-level cases, matching check.sh's own combined
+exit status (one process, both rule classes contributing to one verdict).
+
+Registry-row note, not fixed here (this task does not touch
+`policy/gate-registry.yaml`): LAY-013's registered `engine.scope` is `'*.md'`
+(root-only — `*` does not cross `/` in `core.scope`'s matcher) plus
+`'**/README.md'`, with no `'**/*.md'` companion of the kind LAY-006 carries for
+the identical reason (see that row's own comment). Read through `runner.run`,
+every nested non-README path in the clean corpus (`.plans/AGENTS.md`,
+`docs/AGENTS.md`, `.changeset/some-change.md`, ...) would be narrowed away
+before this check ever ran — which is exactly why every test below calls the
+check directly with the full given set, rather than through the row's scope.
+"""
+
+from __future__ import annotations
+
+import pathlib
+
+from adl_compliance.checks.layout.root_markdown_allowlist import RootMarkdownAllowlist
+from adl_compliance.core import scope
+from adl_compliance.core.context import Context, FileSet
+from adl_compliance.core.verdict import Outcome, decide
+from adl_compliance.policy.registry import load
+
+FIXTURES = pathlib.Path(__file__).parent / "fixtures"
+ROW = load().by_id("LAY-013")
+
+CLEAN = FIXTURES / "root-markdown-clean"
+MISSING_GUIDE = FIXTURES / "root-markdown-missing-guide"
+
+# The clean corpus, exactly as test.sh's own clean-case invocation states it —
+# both real violators (STRAY.md, frontend/README.md) live on disk but are
+# absent from this list.
+CLEAN_GIVEN = (
+    "AGENTS.md",
+    "INVARIANTS.md",
+    "CLAUDE.md",
+    "CHANGELOG.md",
+    "RELEASE.md",
+    "INDEPENDENT-VERIFICATION.md",
+    "README.md",
+    ".workflows/AGENTS.md",
+    ".plans/AGENTS.md",
+    ".specs/AGENTS.md",
+    "docs/AGENTS.md",
+    "docs/architecture/note.md",
+    ".changeset/some-change.md",
+)
+# Every file the clean corpus actually holds on disk, violators included —
+# the shape a tree-scoped phase (or test.sh's `corpus_set` with no explicit
+# given-path arguments) would hand over.
+ALL_CLEAN_FILES = CLEAN_GIVEN + ("STRAY.md", "frontend/README.md")
+
+MISSING_GUIDE_FILES = (
+    ".plans/AGENTS.md",
+    ".workflows/AGENTS.md",
+    "AGENTS.md",
+    "README.md",
+)
+
+
+def graded(root: pathlib.Path, given: tuple[str, ...]):
+    """Bypasses row-scope narrowing entirely — the graded rules only.
+    Mirrors the shell test's direct `check.sh` invocation."""
+    # Every root is a RESOLVED INPUT now, not a class constant -- the packaged
+    # defaults, which every fixture below already uses.
+    ctx = Context(
+        root=root, row=ROW,
+        inputs={
+            "workflows_root": root / ".workflows",
+            "plans_root": root / "plans",
+            "specs_root": root / ".specs",
+            "docs_root": root / "docs",
+            "rust_root": root / "backend",
+            "frontend_root": root / "frontend",
+        },
+    )
+    findings = tuple(RootMarkdownAllowlist().graded(ctx, FileSet(paths=given)))
+    return decide(ROW, findings, 0, ())
+
+
+def structural(root: pathlib.Path):
+    """The named-path probe, which reads no given set at all."""
+    # Every root is a RESOLVED INPUT now, not a class constant -- the packaged
+    # defaults, which every fixture below already uses.
+    ctx = Context(
+        root=root, row=ROW,
+        inputs={
+            "workflows_root": root / ".workflows",
+            "plans_root": root / "plans",
+            "specs_root": root / ".specs",
+            "docs_root": root / "docs",
+            "rust_root": root / "backend",
+            "frontend_root": root / "frontend",
+        },
+    )
+    findings = tuple(RootMarkdownAllowlist().structural(ctx))
+    return decide(ROW, findings, 0, ())
+
+
+def full(root: pathlib.Path, given: tuple[str, ...]):
+    """`Check.run()` itself — both hooks combined into one verdict, the same
+    shape check.sh's single exit code always was."""
+    # Every root is a RESOLVED INPUT now, not a class constant -- the packaged
+    # defaults, which every fixture below already uses.
+    ctx = Context(
+        root=root, row=ROW,
+        inputs={
+            "workflows_root": root / ".workflows",
+            "plans_root": root / "plans",
+            "specs_root": root / ".specs",
+            "docs_root": root / "docs",
+            "rust_root": root / "backend",
+            "frontend_root": root / "frontend",
+        },
+    )
+    findings = tuple(RootMarkdownAllowlist().run(ctx, FileSet(paths=given)))
+    return decide(ROW, findings, 0, ())
+
+
+# ---------------------------------------------------------------------- clean
+def test_a_conforming_tree_is_silent() -> None:
+    verdict = full(CLEAN, CLEAN_GIVEN)
+    assert verdict.outcome is Outcome.CLEAN, verdict.render()
+    assert verdict.findings == ()
+
+
+def test_each_allowlist_family_is_independently_load_bearing() -> None:
+    """Without per-family coverage, a corpus of nothing but allowed paths also
+    passes against a check that reports every `.md` it is handed, and any one
+    exception branch (literal name, basename, tree, donor/frontend/code-asset
+    exception) could rot unnoticed. Mirrors test.sh's negative-assertion
+    block, one path per exception family instead of one substring check."""
+    for path in CLEAN_GIVEN:
+        assert graded(CLEAN, (path,)).findings == (), path
+
+
+# ------------------------------------------------- per-path rule: nested README
+def test_a_nested_readme_is_reported() -> None:
+    verdict = graded(CLEAN, ("frontend/README.md",))
+    assert verdict.outcome is Outcome.FINDINGS
+    assert len(verdict.findings) == 1, verdict.render()
+    finding = verdict.findings[0]
+    assert finding.rule == "LAY-013"
+    assert finding.path == "frontend/README.md"
+    assert finding.message == (
+        "README.md is allowed only at repository root; use AGENTS.md elsewhere"
+    )
+
+
+def test_the_root_readme_in_the_same_corpus_is_not_reported() -> None:
+    verdict = graded(CLEAN, ("frontend/README.md", "README.md"))
+    assert len(verdict.findings) == 1
+    assert verdict.findings[0].path == "frontend/README.md"
+
+
+# ------------------------------------------- per-path rule: the root allowlist
+def test_a_stray_root_markdown_file_is_reported() -> None:
+    verdict = graded(CLEAN, ("STRAY.md",))
+    assert verdict.outcome is Outcome.FINDINGS
+    assert len(verdict.findings) == 1, verdict.render()
+    finding = verdict.findings[0]
+    assert finding.rule == "LAY-013"
+    assert finding.path == "STRAY.md"
+    assert finding.message == "tracked Markdown is outside the root allowlist"
+
+
+def test_a_stray_file_is_never_graded_as_a_nested_readme() -> None:
+    verdict = graded(CLEAN, ("STRAY.md",))
+    assert all("README" not in f.message for f in verdict.findings)
+
+
+# --------------------------------------------------- the whole corpus as the set
+def test_the_whole_corpus_reports_exactly_the_two_real_violators() -> None:
+    verdict = full(CLEAN, ALL_CLEAN_FILES)
+    assert verdict.outcome is Outcome.FINDINGS
+    assert len(verdict.findings) == 2, verdict.render()
+    paths = {f.path for f in verdict.findings}
+    assert paths == {"STRAY.md", "frontend/README.md"}
+
+
+# ------------------------------------------------------- deletions are not findings
+def test_a_path_no_longer_on_disk_is_not_a_finding() -> None:
+    """check.sh's `given_files()` filters the set to `Path(line).is_file()`
+    before grading anything: a removed Markdown file cannot violate an
+    allowlist. `FileSet.existing` is the same filter, applied inside
+    `check.py`'s own `graded`."""
+    verdict = graded(CLEAN, ("DELETED-STRAY.md", "STRAY.md"))
+    assert len(verdict.findings) == 1
+    assert verdict.findings[0].path == "STRAY.md"
+
+
+# ------------------------------------------------------------ structural rule
+def test_a_required_guide_missing_is_reported() -> None:
+    verdict = structural(MISSING_GUIDE)
+    assert verdict.outcome is Outcome.FINDINGS
+    assert len(verdict.findings) == 1, verdict.render()
+    finding = verdict.findings[0]
+    assert finding.rule == "LAY-013"
+    assert finding.path == "docs/AGENTS.md"
+    assert finding.message == "tree has no AGENTS.md guide"
+
+
+def test_the_present_guides_are_not_reported() -> None:
+    """`.workflows/` and `plans/` both carry a guide in this corpus; `docs/`
+    exists without one, and that is the only tree that may fire."""
+    reported = {f.path for f in structural(MISSING_GUIDE).findings}
+    assert ".workflows/AGENTS.md" not in reported
+    assert "plans/AGENTS.md" not in reported
+
+
+def test_a_tree_that_does_not_exist_is_not_asked_for_a_guide() -> None:
+    """The rule is that an existing tree is documented, not that a fixed list
+    of paths is present. This corpus has no `specs/` tree, so demanding
+    `specs/AGENTS.md` would tell a repository to write a guide for a directory
+    it deliberately never made — which is what the previous fixed-list version
+    did."""
+    reported = {f.path for f in structural(MISSING_GUIDE).findings}
+    assert "specs/AGENTS.md" not in reported
+    assert ".specs/AGENTS.md" not in reported
+
+
+def test_the_missing_guide_corpus_reports_only_the_structural_finding() -> None:
+    """The whole corpus, both hooks combined: none of its files violate the
+    graded rules (README.md at root, AGENTS.md by basename), so the only
+    finding is `docs/` existing without a guide."""
+    verdict = full(MISSING_GUIDE, MISSING_GUIDE_FILES)
+    assert verdict.outcome is Outcome.FINDINGS
+    assert len(verdict.findings) == 1, verdict.render()
+    assert verdict.findings[0].path == "docs/AGENTS.md"
+
+
+# --------------------------------------------------- no set: could not run
+def test_the_rows_scope_selects_nothing_from_an_empty_given_set() -> None:
+    """test.sh's ADL_CHANGED_FILES-unset case turns into could-not-run
+    through `runner.run`'s generic empty-and-`exhaustive` guard (core/verdict,
+    see AGENTS.md's Applicable scope) — a property of the runner shared by
+    every check, not of this one. Verified at the scope layer directly,
+    because `runner.run` would hit the not-yet-wired `lookup()` first (see
+    module docstring) and never reach that guard."""
+    assert scope.intersect(ROW.resolved_scope(), ()) == ()
+
+
+def test_a_plugin_root_readme_is_a_published_description(tmp_path: pathlib.Path) -> None:
+    """`.claude-plugin/<name>/README.md` is what the plugin marketplace shows, so it is
+    a published description and not a tree guide — the same case d841de1 settled for
+    `packages/`. The per-host plugin migration created roots this list did not cover and
+    reintroduced the false positive, one per host."""
+    given = (
+        "AGENTS.md",
+        "README.md",
+        ".claude-plugin/enact-repo/README.md",
+        ".codex-plugin/enact-repo/README.md",
+        ".cursor-plugin/enact-repo/README.md",
+    )
+    verdict = graded(tmp_path, given)
+    assert not [
+        f for f in verdict.findings
+        if "README.md is allowed only at repository root" in f.message
+    ]
+
+
+def test_a_redeclared_estate_still_allows_the_resolved_tree_exceptions(
+    tmp_path: pathlib.Path,
+) -> None:
+    """The LOUD false-finding this check shipped with.
+
+    Every `backend/...`/`frontend/...`/`.workflows/...`/`plans/...`/
+    `.specs/...`/`docs/...` entry in `_allowed_markdown` was a hardcoded
+    literal. A repository whose roots are not the packaged defaults had a
+    real, legitimately-allowed Markdown file (a crate's CHANGELOG, a
+    workflows coverage note, a docs page) fail every one of those tests and
+    get reported "outside the root allowlist" -- a visible, wrong finding
+    about a file the allowlist exists to admit.
+
+    Every root redeclared away from its packaged default, one real file
+    exercising each resolved check: wrongly flagged before the fix, silent
+    after."""
+    given = (
+        "roadmap/AGENTS.md",
+        "roadmap/note.md",
+        "specifications/AGENTS.md",
+        "specifications/note.md",
+        "documentation/AGENTS.md",
+        "documentation/architecture/note.md",
+        "automation/AGENTS.md",
+        "automation/COVERAGE.md",
+        "rustcode/CHANGELOG.md",
+        "webapp/CHANGELOG.md",
+    )
+    ctx = Context(
+        root=tmp_path, row=ROW,
+        inputs={
+            "workflows_root": tmp_path / "automation",
+            "plans_root": tmp_path / "roadmap",
+            "specs_root": tmp_path / "specifications",
+            "docs_root": tmp_path / "documentation",
+            "rust_root": tmp_path / "rustcode",
+            "frontend_root": tmp_path / "webapp",
+        },
+    )
+    findings = tuple(RootMarkdownAllowlist().graded(ctx, FileSet(paths=given)))
+    verdict = decide(ROW, findings, 0, ())
+    assert verdict.outcome is Outcome.CLEAN, (
+        f"real files under redeclared roots were wrongly reported outside "
+        f"the allowlist: {verdict.render()}"
+    )

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

@@ -0,0 +1,12 @@
+"""The `layout.scripts-size-depth` 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 ScriptsSizeDepth
+
+__all__ = ["ScriptsSizeDepth"]

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

@@ -0,0 +1,127 @@
+"""LAY-014 — bound the CI scripts tree's size and nesting depth.
+
+Ported from `compliance_new/checks/layout/scripts-size-depth/check.sh`, whose
+own header records the five mechanisms already removed there (`--root`, `cd`,
+a `discover_files` walk, a self-comparing fixture exclusion, and the runner
+already narrowing the set before this gate ever sees it). None of that is
+reintroduced here: `graded()` reads exactly the `FileSet` it is handed, and the
+row's `engine.scope` (`<workflows>/scripts/**`, excluding its own
+`**/fixtures/**`) is what narrows that set before this class runs at all.
+
+Two measurements, both taken over the given set alone — never a walk:
+
+  LAY-014  a directory directly under the CI scripts root holding more than
+           `MAX_DIRECT_FILES` files.
+  LAY-014  a directory nested more than `MAX_SUBFOLDER_DEPTH` levels below
+           that same root.
+
+Both share the one rule id `check.sh` uses throughout (`RULE_ID=LAY-014`);
+there is no second id to split them onto.
+
+`structural()` carries the one probe that is not answered by the given set: a
+missing scripts root is an ABSENT path, so `graded()` could
+never see it — the shell version's `[ ! -d "$SCRIPTS_ROOT" ]` early exit. Since
+production's `engine.scope` guarantees a missing tree also means an empty given
+set, `structural()`'s single finding and an empty `graded()` combine to the
+same one-finding verdict the shell's early exit produced; nothing here depends
+on the order the two hooks run in.
+
+check.sh's awk carries a third arm — a set entry that does not start with
+`$SCRIPTS_ROOT/` at all — reported as its own finding rather than skipped. The
+row's own comment says the runner already narrows `ADL_CHANGED_FILES` to
+this exact scope before the gate runs, so that arm cannot fire in production;
+it is carried over anyway, unexercised, the same way `Placement._stray_artifact`
+carries over its own inert `relative.startswith("/")` guard — real logic in the
+source being ported, not reinvented.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Iterable
+from typing import ClassVar
+
+from ....core.check import Check
+from ....core.context import Context, FileSet
+from ....core.finding import Finding, Report
+
+
+class ScriptsSizeDepth(Check):
+    id: ClassVar[str] = "LAY-014"
+    rule: ClassVar[str] = "LAY-014"
+
+    MAX_DIRECT_FILES: ClassVar[int] = 15
+    MAX_SUBFOLDER_DEPTH: ClassVar[int] = 4
+
+    # `<workflows>` indirection, not the literal `.workflows/scripts` this held
+    # until 2026-09-15. That literal is a consumer path inside the package
+    # (K-42), and it was not a near-miss: enact-m5 keeps CI in `workflows/`
+    # while `.workflows/` is repo-controls' own install artefact, so the gate
+    # reported `missing .workflows/scripts` and then called all 44 real scripts
+    # "outside scripts root" — 45 findings, none of them true. The remedy it
+    # printed was "update SCRIPTS_ROOT in check.py": the gate asking the
+    # consumer to edit the shared package.
+    inputs: ClassVar[dict[str, str]] = {
+        "scripts_root": "<workflows>/scripts",
+    }
+
+    def _root(self, ctx: Context) -> str:
+        """Repository-relative, for both probing and display."""
+        return ctx.relative(ctx.inputs["scripts_root"])
+
+    def structural(self, ctx: Context) -> Iterable[Report]:
+        root = self._root(ctx)
+        if not ctx.inputs["scripts_root"].is_dir():
+            yield self.report(
+                root,
+                f"missing {root}",
+                f"create the {root} directory, or point "
+                "the workflows tree at the directory that holds it",
+            )
+
+    def graded(self, ctx: Context, files: FileSet) -> Iterable[Report]:
+        root = self._root(ctx)
+        prefix = f"{root}/"
+
+        direct_files: dict[str, int] = {}
+        deep_directories: dict[str, int] = {}
+        findings: list[Finding] = []
+
+        for relative in sorted(files):
+            if not relative.startswith(prefix):
+                # Unreachable once the row's engine.scope has narrowed the set
+                # (see module docstring) — carried over rather than dropped.
+                findings.append(self.report(
+                    relative,
+                    f"file is outside scripts root {root}",
+                    f"move it under {root}/, or point "
+                    "the workflows tree at the directory that holds it",
+                ))
+                continue
+
+            inside = relative[len(prefix):]
+            parts = inside.split("/")
+            depth = len(parts) - 1
+            directory = root if depth == 0 else "/".join([root, *parts[:-1]])
+            direct_files[directory] = direct_files.get(directory, 0) + 1
+            if depth > self.MAX_SUBFOLDER_DEPTH:
+                deep_directories[directory] = depth
+
+        for directory, count in direct_files.items():
+            if count > self.MAX_DIRECT_FILES:
+                findings.append(self.report(
+                    directory,
+                    f"has {count} direct files; limit is {self.MAX_DIRECT_FILES}",
+                    f"split the files in {directory} into subdirectories by "
+                    "responsibility",
+                ))
+
+        for directory, depth in deep_directories.items():
+            findings.append(self.report(
+                directory,
+                f"is {depth} levels below {root}; limit is "
+                f"{self.MAX_SUBFOLDER_DEPTH}",
+                f"flatten {directory} so nothing nests deeper than "
+                f"{self.MAX_SUBFOLDER_DEPTH} levels below {root}",
+            ))
+
+        yield from sorted(findings, key=lambda finding: finding.path)

package/packages/repo-controls/package/adl-compliance/src/adl_compliance/checks/layout/scripts_size_depth/fixtures/scripts-layout/.workflows/scripts/a/b/c/d/at-limit.sh

@@ -0,0 +1,3 @@
+#!/usr/bin/env bash
+# scripts-layout corpus: 4 levels below the root -- exactly the limit.
+true

package/packages/repo-controls/package/adl-compliance/src/adl_compliance/checks/layout/scripts_size_depth/fixtures/scripts-layout/.workflows/scripts/a/b/c/d/e/too-deep.sh

@@ -0,0 +1,3 @@
+#!/usr/bin/env bash
+# scripts-layout corpus: 5 levels below the root -- one past the limit.
+true

package/packages/repo-controls/package/adl-compliance/src/adl_compliance/checks/layout/scripts_size_depth/fixtures/scripts-layout/.workflows/scripts/direct-01.sh

@@ -0,0 +1,3 @@
+#!/usr/bin/env bash
+# scripts-layout corpus: a direct file under the scripts root.
+true

package/packages/repo-controls/package/adl-compliance/src/adl_compliance/checks/layout/scripts_size_depth/fixtures/scripts-layout/.workflows/scripts/direct-02.sh

@@ -0,0 +1,3 @@
+#!/usr/bin/env bash
+# scripts-layout corpus: a direct file under the scripts root.
+true

package/packages/repo-controls/package/adl-compliance/src/adl_compliance/checks/layout/scripts_size_depth/fixtures/scripts-layout/.workflows/scripts/direct-03.sh

@@ -0,0 +1,3 @@
+#!/usr/bin/env bash
+# scripts-layout corpus: a direct file under the scripts root.
+true

package/packages/repo-controls/package/adl-compliance/src/adl_compliance/checks/layout/scripts_size_depth/fixtures/scripts-layout/.workflows/scripts/direct-04.sh

@@ -0,0 +1,3 @@
+#!/usr/bin/env bash
+# scripts-layout corpus: a direct file under the scripts root.
+true

package/packages/repo-controls/package/adl-compliance/src/adl_compliance/checks/layout/scripts_size_depth/fixtures/scripts-layout/.workflows/scripts/direct-05.sh

@@ -0,0 +1,3 @@
+#!/usr/bin/env bash
+# scripts-layout corpus: a direct file under the scripts root.
+true

package/packages/repo-controls/package/adl-compliance/src/adl_compliance/checks/layout/scripts_size_depth/fixtures/scripts-layout/.workflows/scripts/direct-06.sh

@@ -0,0 +1,3 @@
+#!/usr/bin/env bash
+# scripts-layout corpus: a direct file under the scripts root.
+true

package/packages/repo-controls/package/adl-compliance/src/adl_compliance/checks/layout/scripts_size_depth/fixtures/scripts-layout/.workflows/scripts/direct-07.sh

@@ -0,0 +1,3 @@
+#!/usr/bin/env bash
+# scripts-layout corpus: a direct file under the scripts root.
+true

package/packages/repo-controls/package/adl-compliance/src/adl_compliance/checks/layout/scripts_size_depth/fixtures/scripts-layout/.workflows/scripts/direct-08.sh

@@ -0,0 +1,3 @@
+#!/usr/bin/env bash
+# scripts-layout corpus: a direct file under the scripts root.
+true

package/packages/repo-controls/package/adl-compliance/src/adl_compliance/checks/layout/scripts_size_depth/fixtures/scripts-layout/.workflows/scripts/direct-09.sh

@@ -0,0 +1,3 @@
+#!/usr/bin/env bash
+# scripts-layout corpus: a direct file under the scripts root.
+true

package/packages/repo-controls/package/adl-compliance/src/adl_compliance/checks/layout/scripts_size_depth/fixtures/scripts-layout/.workflows/scripts/direct-10.sh

@@ -0,0 +1,3 @@
+#!/usr/bin/env bash
+# scripts-layout corpus: a direct file under the scripts root.
+true

package/packages/repo-controls/package/adl-compliance/src/adl_compliance/checks/layout/scripts_size_depth/fixtures/scripts-layout/.workflows/scripts/direct-11.sh

@@ -0,0 +1,3 @@
+#!/usr/bin/env bash
+# scripts-layout corpus: a direct file under the scripts root.
+true

package/packages/repo-controls/package/adl-compliance/src/adl_compliance/checks/layout/scripts_size_depth/fixtures/scripts-layout/.workflows/scripts/direct-12.sh

@@ -0,0 +1,3 @@
+#!/usr/bin/env bash
+# scripts-layout corpus: a direct file under the scripts root.
+true

package/packages/repo-controls/package/adl-compliance/src/adl_compliance/checks/layout/scripts_size_depth/fixtures/scripts-layout/.workflows/scripts/direct-13.sh

@@ -0,0 +1,3 @@
+#!/usr/bin/env bash
+# scripts-layout corpus: a direct file under the scripts root.
+true

package/packages/repo-controls/package/adl-compliance/src/adl_compliance/checks/layout/scripts_size_depth/fixtures/scripts-layout/.workflows/scripts/direct-14.sh

@@ -0,0 +1,3 @@
+#!/usr/bin/env bash
+# scripts-layout corpus: a direct file under the scripts root.
+true

package/packages/repo-controls/package/adl-compliance/src/adl_compliance/checks/layout/scripts_size_depth/fixtures/scripts-layout/.workflows/scripts/direct-15.sh

@@ -0,0 +1,3 @@
+#!/usr/bin/env bash
+# scripts-layout corpus: a direct file under the scripts root.
+true

package/packages/repo-controls/package/adl-compliance/src/adl_compliance/checks/layout/scripts_size_depth/fixtures/scripts-layout/.workflows/scripts/direct-16.sh

@@ -0,0 +1,3 @@
+#!/usr/bin/env bash
+# scripts-layout corpus: a direct file under the scripts root.
+true