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

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

@@ -0,0 +1,461 @@
+"""LAY-009 — the `plans/features/az<id>-<slug>/` layout.
+
+Two committed corpora plus trees built at `tmp_path` for the individual
+branches. Nothing reads the repository this package lives in.
+
+The previous suite tested the `.plans/a_new|b_committed|c_done` lifecycle tree:
+filename dates, `plan_state` agreement with the directory, the eight
+executable-shape concepts, duplicate names across states. None of those rules
+exist any more — documents no longer move and state lives only on the board —
+so the tests were replaced rather than adapted.
+"""
+
+from __future__ import annotations
+
+import pathlib
+
+from helpers import corpus, corpus_files
+
+from adl_compliance.checks.layout.plans_layout import PlansLayout
+from adl_compliance.core.context import Context, FileSet
+from adl_compliance.core.verdict import Outcome, decide
+from adl_compliance.policy.registry import load
+
+CORPUS = corpus("layout", "plans-layout")
+CLEAN = CORPUS / "plans-layout-clean"
+VIOLATION = CORPUS / "plans-layout-violation"
+ROW = load().by_id("LAY-009")
+
+AZ = "https://dev.azure.com/org/proj/_workitems/edit"
+
+FEATURE = """---
+type: feature
+title: "A feature"
+status: New
+epic: {az}/320
+work_item: {az}/{{work_item}}
+last_update: 2026-09-15T03:20:00Z
+sources:
+  - docs/architecture/workflow-automation.md
+---
+
+# A feature
+""".format(az=AZ)
+
+ITEM = """---
+type: {{item_type}}
+title: "An item"
+status: New
+work_item: {az}/{{work_item}}
+last_update: 2026-09-15T03:20:00Z
+---
+
+# An item
+""".format(az=AZ)
+
+
+def graded_directly(root: pathlib.Path) -> object:
+    """LAY-009 straight through `decide`, matching the other layout suites."""
+    files = tuple(
+        str(p.relative_to(root)) for p in root.rglob("*") if p.is_file()
+    )
+    ctx = Context(row=ROW, root=root, inputs={"plans_root": root / "plans"})
+    check = PlansLayout()
+    findings = tuple(check.run(ctx, FileSet(paths=files)))
+    return decide(ROW, findings, advisories=())
+
+
+def build(root: pathlib.Path, files: dict[str, str]) -> pathlib.Path:
+    for relative, body in files.items():
+        path = root / relative
+        path.parent.mkdir(parents=True, exist_ok=True)
+        path.write_text(body, encoding="utf-8")
+    return root
+
+
+# ------------------------------------------------------------ committed corpora
+
+
+def test_a_conforming_tree_is_silent() -> None:
+    verdict = graded_directly(CLEAN)
+    assert verdict.outcome is Outcome.CLEAN, verdict.render()
+
+
+def test_the_violation_corpus_reports_each_disagreement() -> None:
+    verdict = graded_directly(VIOLATION)
+    assert verdict.outcome is Outcome.FINDINGS
+    messages = " | ".join(f.message for f in verdict.findings)
+    # spec work_item 999 vs directory az347, item work_item 352 vs filename
+    # az351, item feature az999 vs its actual directory, and a bad item_type.
+    assert "work_item 999 disagrees with az347" in messages, verdict.render()
+    assert "work_item 352 disagrees with az351" in messages, verdict.render()
+    assert "'chore' is not pbi or bug" in messages, verdict.render()
+
+
+# ------------------------------------------------------------------ structural
+
+
+def test_a_missing_plans_root_is_reported(tmp_path: pathlib.Path) -> None:
+    verdict = graded_directly(build(tmp_path, {"README.md": "x"}))
+    assert verdict.outcome is Outcome.FINDINGS
+    assert any("plans root is missing" in f.message for f in verdict.findings)
+
+
+def test_a_missing_features_directory_is_reported(tmp_path: pathlib.Path) -> None:
+    verdict = graded_directly(build(tmp_path, {"plans/AGENTS.md": "x"}))
+    assert any("features directory is missing" in f.message for f in verdict.findings)
+
+
+def test_a_leftover_lifecycle_directory_is_reported(tmp_path: pathlib.Path) -> None:
+    # A half-migrated repo should be told, not silently ignored.
+    verdict = graded_directly(
+        build(
+            tmp_path,
+            {
+                "plans/features/az1-x/spec.md": FEATURE.format(work_item=1),
+                "plans/a_new/26-09-15-old-plan.md": "# old",
+            },
+        )
+    )
+    assert any(
+        "lifecycle-state directory is no longer part of the layout" in f.message
+        for f in verdict.findings
+    ), verdict.render()
+
+
+# ----------------------------------------------------------------------- shape
+
+
+def test_an_unapproved_root_directory_is_reported(tmp_path: pathlib.Path) -> None:
+    verdict = graded_directly(
+        build(
+            tmp_path,
+            {
+                "plans/features/az1-x/spec.md": FEATURE.format(work_item=1),
+                "plans/archive/old.md": "# old",
+            },
+        )
+    )
+    assert any("must be features/ or templates/" in f.message for f in verdict.findings)
+
+
+def test_an_unapproved_root_file_is_reported(tmp_path: pathlib.Path) -> None:
+    verdict = graded_directly(
+        build(
+            tmp_path,
+            {
+                "plans/features/az1-x/spec.md": FEATURE.format(work_item=1),
+                "plans/NOTES.md": "# notes",
+            },
+        )
+    )
+    assert any("direct plans files must be" in f.message for f in verdict.findings)
+
+
+def test_a_loose_file_in_features_is_reported(tmp_path: pathlib.Path) -> None:
+    verdict = graded_directly(
+        build(
+            tmp_path,
+            {
+                "plans/features/az1-x/spec.md": FEATURE.format(work_item=1),
+                "plans/features/stray.md": "# stray",
+            },
+        )
+    )
+    assert any("one directory per Feature" in f.message for f in verdict.findings)
+
+
+def test_a_feature_directory_not_named_az_id_is_reported(tmp_path: pathlib.Path) -> None:
+    verdict = graded_directly(
+        build(tmp_path, {"plans/features/coverage/spec.md": FEATURE.format(work_item=1)})
+    )
+    assert any(
+        "must be named az<work item id>-<kebab-slug>" in f.message for f in verdict.findings
+    )
+
+
+def test_a_feature_directory_without_a_spec_is_reported(tmp_path: pathlib.Path) -> None:
+    verdict = graded_directly(
+        build(
+            tmp_path,
+            {
+                "plans/features/az1-x/items/az2-y.md": ITEM.format(item_type="pbi", work_item=2)
+            },
+        )
+    )
+    assert any("must hold a spec.md" in f.message for f in verdict.findings)
+
+
+def test_an_extra_file_beside_spec_is_reported(tmp_path: pathlib.Path) -> None:
+    verdict = graded_directly(
+        build(
+            tmp_path,
+            {
+                "plans/features/az1-x/spec.md": FEATURE.format(work_item=1),
+                "plans/features/az1-x/notes.md": "# notes",
+            },
+        )
+    )
+    # The message ENUMERATES what is allowed, so whoever hits it can correct the
+    # file without opening the check. A bare "not allowed" sends the reader here.
+    finding = next(f for f in verdict.findings if "Feature directory holds" in f.message)
+    assert finding.message == "a Feature directory holds spec.md, handoff.md, review.md, items/ only"
+    assert "rename it to one of handoff.md, review.md" in finding.fix
+
+
+def test_supporting_documents_are_permitted_beside_spec(tmp_path: pathlib.Path) -> None:
+    """handoff.md and review.md are named by ROLE, so a feature's supporting documents
+    sit at the same path in every feature. A topic-named file (CHANNELS-HANDOVER.md)
+    states the topic a second time and differently each time, which is the drift the
+    two-file rule existed to prevent -- so the set is closed, not opened."""
+    verdict = graded_directly(
+        build(
+            tmp_path,
+            {
+                "plans/features/az1-x/spec.md": FEATURE.format(work_item=1),
+                "plans/features/az1-x/handoff.md": "# handoff",
+                "plans/features/az1-x/review.md": "# review",
+            },
+        )
+    )
+    assert not [f for f in verdict.findings if "Feature directory holds" in f.message]
+
+
+def test_a_topic_named_supporting_file_is_still_reported(tmp_path: pathlib.Path) -> None:
+    verdict = graded_directly(
+        build(
+            tmp_path,
+            {
+                "plans/features/az1-x/spec.md": FEATURE.format(work_item=1),
+                "plans/features/az1-x/CHANNELS-HANDOVER.md": "# handover",
+            },
+        )
+    )
+    assert any("Feature directory holds" in f.message for f in verdict.findings)
+
+
+def test_an_item_not_named_az_id_is_reported(tmp_path: pathlib.Path) -> None:
+    verdict = graded_directly(
+        build(
+            tmp_path,
+            {
+                "plans/features/az1-x/spec.md": FEATURE.format(work_item=1),
+                "plans/features/az1-x/items/26-09-15-old-name.md": ITEM.format(item_type="pbi", work_item=2),
+            },
+        )
+    )
+    assert any(
+        "must be named az<work item id>-<kebab-slug>.md" in f.message
+        for f in verdict.findings
+    )
+
+
+# ----------------------------------------------------------------- frontmatter
+
+
+def test_a_spec_without_an_epic_is_reported(tmp_path: pathlib.Path) -> None:
+    verdict = graded_directly(
+        build(
+            tmp_path,
+            {
+                "plans/features/az1-x/spec.md": "---\ntype: Feature\nwork_item: 1\n---\n\n# x\n",
+            },
+        )
+    )
+    assert any("must name the Epic" in f.message for f in verdict.findings)
+
+
+def test_a_spec_work_item_disagreeing_with_its_directory_is_reported(
+    tmp_path: pathlib.Path,
+) -> None:
+    verdict = graded_directly(
+        build(tmp_path, {"plans/features/az1-x/spec.md": FEATURE.format(work_item=2)})
+    )
+    assert any(
+        "work_item 2 disagrees with az1" in f.message for f in verdict.findings
+    )
+
+
+def test_an_item_work_item_disagreeing_with_its_filename_is_reported(
+    tmp_path: pathlib.Path,
+) -> None:
+    # The silent rot this gate exists for: every tool keeps working, and the
+    # file simply describes a different work item than its name claims.
+    verdict = graded_directly(
+        build(
+            tmp_path,
+            {
+                "plans/features/az1-x/spec.md": FEATURE.format(work_item=1),
+                "plans/features/az1-x/items/az2-y.md": ITEM.format(item_type="pbi", work_item=3),
+            },
+        )
+    )
+    assert any(
+        "work_item 3 disagrees with az2" in f.message for f in verdict.findings
+    )
+
+
+def test_a_status_outside_the_board_vocabulary_is_reported(tmp_path: pathlib.Path) -> None:
+    # `status` mirrors the WORK ITEM's state, so draft/stable is wrong here.
+    verdict = graded_directly(
+        build(
+            tmp_path,
+            {
+                "plans/features/az1-x/spec.md": FEATURE.format(work_item=1).replace(
+                    "status: New", "status: draft"
+                )
+            },
+        )
+    )
+    assert any("is not a work item state" in f.message for f in verdict.findings)
+
+
+def test_a_bare_work_item_id_is_reported(tmp_path: pathlib.Path) -> None:
+    # The id is already in the filename; the field earns its place by being the
+    # link a reader can click through to the board.
+    verdict = graded_directly(
+        build(
+            tmp_path,
+            {
+                "plans/features/az1-x/spec.md": FEATURE.format(work_item=1).replace(
+                    f"work_item: {AZ}/1", "work_item: 1"
+                )
+            },
+        )
+    )
+    assert any("must be a board URL" in f.message for f in verdict.findings)
+
+
+def test_a_spec_without_sources_is_reported(tmp_path: pathlib.Path) -> None:
+    verdict = graded_directly(
+        build(
+            tmp_path,
+            {
+                "plans/features/az1-x/spec.md": FEATURE.format(work_item=1).replace(
+                    "sources:\n  - docs/architecture/workflow-automation.md\n", ""
+                )
+            },
+        )
+    )
+    assert any("must link the documents it derives from" in f.message for f in verdict.findings)
+
+
+def test_a_missing_last_update_is_reported(tmp_path: pathlib.Path) -> None:
+    verdict = graded_directly(
+        build(
+            tmp_path,
+            {
+                "plans/features/az1-x/spec.md": FEATURE.format(work_item=1).replace(
+                    "last_update: 2026-09-15T03:20:00Z\n", ""
+                )
+            },
+        )
+    )
+    assert any("missing last_update" in f.message for f in verdict.findings)
+
+
+def test_an_item_type_outside_pbi_and_bug_is_reported(tmp_path: pathlib.Path) -> None:
+    verdict = graded_directly(
+        build(
+            tmp_path,
+            {
+                "plans/features/az1-x/spec.md": FEATURE.format(work_item=1),
+                "plans/features/az1-x/items/az2-y.md": ITEM.format(item_type="task", work_item=2),
+            },
+        )
+    )
+    assert any("type 'task' is not pbi or bug" in f.message for f in verdict.findings)
+
+
+def test_a_supporting_document_must_carry_the_tree_s_frontmatter(tmp_path: pathlib.Path) -> None:
+    """A handoff without frontmatter is an undated wall of prose naming no work item
+    — readable today, unattributable in a month. That is the state the channels
+    handover was in at the repository root, and moving it must not preserve it."""
+    verdict = graded_directly(
+        build(
+            tmp_path,
+            {
+                "plans/features/az1-x/spec.md": FEATURE.format(work_item=1),
+                "plans/features/az1-x/handoff.md": "# handoff\n\nprose, no frontmatter\n",
+            },
+        )
+    )
+    messages = [f.message for f in verdict.findings if f.path.endswith("handoff.md")]
+    assert "missing title" in messages
+    assert "missing status" in messages
+    assert "missing last_update" in messages
+    assert any("work_item" in m for m in messages)
+
+
+def test_a_redeclared_plans_tree_still_catches_a_legacy_lifecycle_dir(
+    tmp_path: pathlib.Path,
+) -> None:
+    """The SILENT false pass `LEGACY` shipped with.
+
+    `LEGACY`'s three `plans/a_new`/`plans/b_committed`/`plans/c_done` entries
+    were hardcoded literals, probed with `ctx.path(legacy).is_dir()`. A
+    repository whose plans root is not the packaged default had a real,
+    still-unmigrated `<root>/a_new` directory fail that probe -- no finding,
+    indistinguishable from an already-complete migration.
+
+    A real `roadmap/a_new/leftover.md` under a redeclared plans root:
+    ungraded before the fix, caught after."""
+    root = tmp_path / "repo"
+    build(
+        root,
+        {
+            "roadmap/features/az1-x/spec.md": FEATURE.format(work_item=1),
+            "roadmap/a_new/leftover.md": "# a leftover plan from before the migration\n",
+        },
+    )
+    files = tuple(str(p.relative_to(root)) for p in root.rglob("*") if p.is_file())
+    ctx = Context(row=ROW, root=root, inputs={"plans_root": root / "roadmap"})
+    findings = tuple(PlansLayout().run(ctx, FileSet(paths=files)))
+    verdict = decide(ROW, findings, advisories=())
+    assert any(
+        f.path == "roadmap/a_new" and "no longer part of the layout" in f.message
+        for f in verdict.findings
+    ), (
+        f"a real unmigrated lifecycle directory under a redeclared plans root "
+        f"went unreported: {verdict.render()}"
+    )
+
+
+def test_ledger_md_is_allowed_at_the_plans_root(tmp_path: pathlib.Path) -> None:
+    """Owner ruling 2026-09-17: the plan-event ledger is Markdown.
+
+    Three gates held an opinion and they disagreed -- LAY-006 allowed
+    `*/LEDGER.md`, DOC-009 demanded `LEDGER.yaml` and called the Markdown form
+    legacy, and this list allowed only the YAML. A repository converting its
+    ledger satisfied two of them and failed the third.
+    """
+    verdict = graded_directly(
+        build(tmp_path, {
+            "plans/AGENTS.md": "x",
+            "plans/features/.keep": "",
+            "plans/templates/.keep": "",
+            "plans/LEDGER.md": "# Ledger\n\n| Date | Id |\n| --- | --- |\n",
+        })
+    )
+    assert not any("LEDGER" in f.message for f in verdict.findings), verdict.render()
+
+
+def test_ledger_yaml_at_the_plans_root_is_reported(tmp_path: pathlib.Path) -> None:
+    """The retired form is a finding, and the remedy names what IS allowed.
+
+    The message is derived from ROOT_ALLOWED_FILES rather than restated: the
+    hardcoded copy had drifted at both ends, naming `LEDGER.yaml` (no longer
+    allowed) and omitting `GAPS-AND-FINDINGS.md` (allowed all along).
+    """
+    verdict = graded_directly(
+        build(tmp_path, {
+            "plans/AGENTS.md": "x",
+            "plans/features/.keep": "",
+            "plans/templates/.keep": "",
+            "plans/LEDGER.yaml": "schema_version: 1\n",
+        })
+    )
+    assert verdict.outcome is Outcome.FINDINGS
+    rendered = verdict.render()
+    assert "LEDGER.yaml" in rendered, rendered
+    assert "LEDGER.md" in rendered, rendered

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

@@ -0,0 +1,11 @@
+"""The `layout.profile-data` gate.
+
+A folder rather than a bare 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 ProfileData
+
+__all__ = ["ProfileData"]

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

@@ -0,0 +1,62 @@
+"""LAY-010 — every PostgreSQL migration under `ates` is named
+`NNN_slug.sql`.
+
+Ported from `compliance_new/checks/layout/profile-data/check.sh`, the
+`migration-filenames` branch retained from the old multi-mode
+`profile-data.sh` after its other three branches were superseded by their own
+engines (see that file's header). It takes no arguments and reads exactly the
+given set (already narrowed by the runner to the row's `engine.scope`,
+`<rust>/crates/**`, i.e. `<rust>/crates/**`); it performs no walk and no
+`git` call of its own.
+
+`RULE_ID` in check.sh is the literal `LAY-009`, not this row's own id
+(`LAY-010`) — a pre-existing mismatch in the shell source, not a typo
+introduced here. `compliance_new/AGENTS.md` names this exact failure mode
+("a check that hardcodes [an id] has a second copy of a fact, free to
+disagree with the row") for two OTHER gates; this one has the same shape and
+was not caught. check.sh's own test.sh asserts findings are reported under
+`LAY-009` (`rg -q '^LAY-009 '`), so that is the behaviour ported here —
+faithfully, not silently corrected, since fixing it is a registry/shell-tree
+change outside this port's scope.
+
+`*/migrations/*.sql` is a bash `case` pattern, not `engine.scope`: it is the
+rule's own subject-matter test (a migration is defined by living in a
+`migrations/` directory), applied to whatever the given set already narrowed
+to `<rust>/crates/**`. A `.sql` file elsewhere under `<rust>/crates/` is not
+a migration and carries no naming contract, so it is never graded — ported as
+a substring test rather than a glob library, since a repository-relative path
+never carries the leading `/` a `*` prefix of zero length would require.
+"""
+
+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, FileSet
+from ....core.finding import Report
+
+
+class ProfileData(Check):
+    id: ClassVar[str] = "LAY-010"
+    rule: ClassVar[str] = "LAY-009"  # see module docstring: verbatim from check.sh
+
+    NAME: ClassVar[re.Pattern[str]] = re.compile(r"^[0-9]{3}_[a-z0-9_]+\.sql$")
+    """Three digits, an underscore, then a lowercase/digit/underscore slug of
+    at least one character — check.sh's `^[0-9]{3}_[a-z0-9_]+\\.sql$`."""
+
+    def graded(self, ctx: Context, files: FileSet) -> Iterable[Report]:
+        for relative in sorted(files):
+            if "/migrations/" not in relative or not relative.endswith(".sql"):
+                continue  # not a migration: no naming contract applies
+            base = relative.rsplit("/", 1)[-1]
+            if self.NAME.match(base):
+                continue
+            yield self.report(
+                relative,
+                f"invalid migration filename: {relative}",
+                f"rename {relative} to match NNN_slug.sql "
+                "(three dis, underscore, lowercase slug)",
+            )

package/packages/repo-controls/package/adl-compliance/src/adl_compliance/checks/layout/profile_data/fixtures/migration-filenames/backend/crates/demo/NotAMigration.sql

@@ -0,0 +1 @@
+-- not a migration: lives outside migrations/

package/packages/repo-controls/package/adl-compliance/src/adl_compliance/checks/layout/profile_data/fixtures/migration-filenames/backend/crates/demo/migrations/0001_long_prefix.sql

@@ -0,0 +1 @@
+CREATE TABLE oops (id INT);

package/packages/repo-controls/package/adl-compliance/src/adl_compliance/checks/layout/profile_data/fixtures/migration-filenames/backend/crates/demo/migrations/001_init.sql

@@ -0,0 +1 @@
+CREATE TABLE demo (id INT PRIMARY KEY);

package/packages/repo-controls/package/adl-compliance/src/adl_compliance/checks/layout/profile_data/fixtures/migration-filenames/backend/crates/demo/migrations/002_add_index.sql

@@ -0,0 +1 @@
+CREATE INDEX demo_idx ON demo (id);

package/packages/repo-controls/package/adl-compliance/src/adl_compliance/checks/layout/profile_data/fixtures/migration-filenames/backend/crates/demo/migrations/003-dashed-slug.sql

@@ -0,0 +1 @@
+CREATE TABLE oops (id INT);

package/packages/repo-controls/package/adl-compliance/src/adl_compliance/checks/layout/profile_data/fixtures/migration-filenames/backend/crates/demo/migrations/004_MixedCase.sql

@@ -0,0 +1 @@
+CREATE TABLE oops (id INT);

package/packages/repo-controls/package/adl-compliance/src/adl_compliance/checks/layout/profile_data/fixtures/migration-filenames/backend/crates/demo/migrations/005_trailing space.sql

@@ -0,0 +1 @@
+CREATE TABLE oops (id INT);

package/packages/repo-controls/package/adl-compliance/src/adl_compliance/checks/layout/profile_data/fixtures/migration-filenames/backend/crates/demo/migrations/01_short_prefix.sql

@@ -0,0 +1 @@
+CREATE TABLE oops (id INT);

package/packages/repo-controls/package/adl-compliance/src/adl_compliance/checks/layout/profile_data/fixtures/migration-filenames/backend/crates/demo/migrations/not-a-migration.sql

@@ -0,0 +1 @@
+CREATE TABLE oops (id INT);

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

@@ -0,0 +1,116 @@
+"""LAY-010 — ported from `compliance_new/checks/layout/profile-data/test.sh`.
+
+ONE corpus, one file per malformed shape, ported byte-for-byte from the shell
+fixture (`fixtures/migration-filenames/backend/crates/demo/migrations/` plus
+one `.sql` file that lives outside a `migrations/` directory). Each case below
+hands over a SUBSET of that same corpus, exactly as test.sh's `state_set`
+narrows one given list per case — a lumped fixture would pass as long as ONE
+shape is caught, which is how a loosened pattern hides.
+"""
+
+from __future__ import annotations
+
+import pathlib
+
+import pytest
+
+from adl_compliance import runner
+from adl_compliance.checks.layout.profile_data import ProfileData
+from adl_compliance.core.verdict import Outcome
+from adl_compliance.policy.registry import load
+
+FIXTURES = pathlib.Path(__file__).parent / "fixtures"
+ROOT = FIXTURES / "migration-filenames"
+ROW = load().by_id("LAY-010")
+
+
+@pytest.fixture(autouse=True)
+def _wired(monkeypatch: pytest.MonkeyPatch) -> None:
+    # LAY-010 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 LAY-010 to this module's class —
+    # everything else (scope intersection, verdict decision) runs for real.
+    monkeypatch.setattr(runner, "lookup", lambda gate_id: ProfileData)
+
+
+DIR = "backend/crates/demo/migrations"
+OUTSIDE = "backend/crates/demo/NotAMigration.sql"
+
+INIT = f"{DIR}/001_init.sql"
+ADD_INDEX = f"{DIR}/002_add_index.sql"
+
+# The six malformed shapes test.sh's `reject` loop names, each with the
+# reason it names for that shape.
+MALFORMED = (
+    ("not-a-migration.sql", "a name with no numeric prefix"),
+    ("01_short_prefix.sql", "a two-digit prefix"),
+    ("0001_long_prefix.sql", "a four-digit prefix"),
+    ("003-dashed-slug.sql", "a dashed separator instead of an underscore"),
+    ("004_MixedCase.sql", "an uppercase slug"),
+    ("005_trailing space.sql", "a slug containing a space"),
+)
+
+CONFORMING = (INIT, ADD_INDEX, OUTSIDE)
+
+
+def run(given: tuple[str, ...]) -> object:
+    return runner.run(ROW, ROOT, given)
+
+
+def test_the_corpus_holds_nine_files() -> None:
+    on_disk = tuple(str(p.relative_to(ROOT)) for p in ROOT.rglob("*") if p.is_file())
+    assert len(on_disk) == 9, f"the corpus should hold 9 files, got {len(on_disk)}"
+
+
+def test_a_conforming_set_passes() -> None:
+    verdict = run(CONFORMING)
+    assert verdict.outcome is Outcome.CLEAN, verdict.render()
+    assert verdict.findings == ()
+
+
+@pytest.mark.parametrize("bad,why", MALFORMED, ids=[b for b, _ in MALFORMED])
+def test_each_malformed_shape_is_rejected(bad: str, why: str) -> None:
+    given = (*CONFORMING, f"{DIR}/{bad}")
+    verdict = run(given)
+    assert verdict.outcome is Outcome.FINDINGS, f"{why} was accepted: {bad}"
+    assert len(verdict.findings) == 1
+    finding = verdict.findings[0]
+    assert finding.rule == "LAY-009"  # check.sh's hardcoded RULE_ID; see check.py
+    assert finding.path == f"{DIR}/{bad}"
+    # The one name in every set that must never be reported: a .sql file
+    # outside a migrations/ directory has no naming contract.
+    assert OUTSIDE not in {f.path for f in verdict.findings}
+
+
+def test_the_whole_corpus_reports_all_six_malformed_names() -> None:
+    given = (*CONFORMING, *(f"{DIR}/{bad}" for bad, _ in MALFORMED))
+    verdict = run(given)
+    assert verdict.outcome is Outcome.FINDINGS
+    assert len(verdict.findings) == 6
+    assert {f.rule for f in verdict.findings} == {"LAY-009"}
+    reported = {f.path for f in verdict.findings}
+    assert reported == {f"{DIR}/{bad}" for bad, _ in MALFORMED}
+    # Isolation proof (test.sh): every reported path resolves inside the
+    # corpus, not some unrelated migrations/ directory elsewhere on disk.
+    for finding in verdict.findings:
+        assert (ROOT / finding.path).exists()
+
+
+def test_a_sql_file_outside_migrations_is_never_graded() -> None:
+    # OUTSIDE alone: a .sql file with no numeric prefix at all, but it does
+    # not live under a migrations/ directory, so it carries no naming
+    # contract and must stay silent.
+    verdict = run((OUTSIDE,))
+    assert verdict.outcome is Outcome.CLEAN, verdict.render()
+
+
+def test_no_files_given_is_could_not_run() -> None:
+    # The shell gate refuses to run at all with ADL_CHANGED_FILES unset
+    # (exit 2). This package has no "unset" state distinct from "empty" — the
+    # equivalent, framework-level could-not-run is an empty intersection over
+    # the whole visible tree (see core/runner.py's `exhaustive`, and
+    # RST-008's identically-shaped test).
+    verdict = runner.run(ROW, ROOT, (), exhaustive=True)
+    assert verdict.outcome is Outcome.COULD_NOT_RUN