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

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

@@ -0,0 +1,240 @@
+"""LAY-008 — reject out-of-place STAGED files, by four independent rules.
+
+Ported from `compliance_new/checks/layout/placement/check.sh`, which grades
+the given set only (K-29..K-31): no walk, no git call, no self-location. The
+row is entirely `graded()` — every rule is answered by the path SHAPE of a
+member of the given set, never by probing a named path, so `structural()` has
+nothing to contribute.
+
+Four rules, evaluated independently per path (a single path can trip more than
+one):
+
+  1. root allowlist    a file with no `/` must be on the enumerated allowlist
+                        of files legitimately committed at the repository root.
+  2. apps/ retired      any path under the retired `apps/` tree.
+  3. stray artifacts    a throwaway extension (`.log`/`.tmp`/`.bak`/`.swp`,
+                         checked STRICTLY, everywhere) or a screenshot/image
+                         basename outside the enumerated asset directories.
+  4. md sprawl          a `.md` file inside `backend/` or `agent/`'s `src/`
+                         tree, except the two exempted files.
+
+**One rule id for all four, and it does not match this row.** The shell
+`check.sh` hardcodes `RULE_ID=LAY-007` — but `LAY-007` is a DIFFERENT row
+(`layout.pipeline-templates`); this row's own id is `LAY-008`. That is exactly
+the "a check never spells its own id" defect `compliance_new/AGENTS.md`
+documents for `FRM-009`/`FRM-010` (both hardcoded a rule literal that had
+drifted from their row). It is reproduced here rather than silently
+corrected, because the port's job is the shell tree's ACTUAL behaviour —
+`test.sh` asserts findings prefixed `^LAY-007 ` — not the behaviour it should
+have had; the mismatch is called out in the porting notes instead.
+
+The shell source's own comments and finding messages have a second, unrelated
+defect: substring-corrupted prose (`"legitimate"` reads `"leimate"`, the
+throwaway/screenshot messages read `"-artifact:"` with their lead word gone
+entirely). Message TEXT is not the rule the row grades, so this port writes
+clean prose rather than reproducing the corruption; the logic — which
+extensions, which prefixes, which exemptions — is carried over faithfully.
+"""
+
+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
+from ....policy.root_shape import ALLOWED_ROOT_FILES
+
+
+class Placement(Check):
+    id: ClassVar[str] = "LAY-008"
+    # Matches check.sh's hardcoded RULE_ID exactly (see module docstring: this
+    # is the shell tree's real, if mismatched, behaviour — not a typo here).
+    # Was "LAY-007" — a copy-paste that printed every finding of this gate under
+    # the neighbouring gate's id, so a reader chasing a placement violation was
+    # sent to the pipeline-templates gate instead.
+    rule: ClassVar[str] = "LAY-008"
+
+    # The shared root policy, not a fourth copy of it. This gate's own list had
+    # already drifted from LAY-012's: it still carried the shell script's typos
+    # `.attributes` and `.ignore`, which LAY-012 had long since corrected to
+    # `.gitattributes` and `.gitignore` — so the same file was permitted by one
+    # gate and reported by the other.
+    ROOT_ALLOWLIST: ClassVar[frozenset[str]] = ALLOWED_ROOT_FILES
+
+    THROWAWAY_SUFFIXES: ClassVar[tuple[str, ...]] = (
+        ".log", ".LOG", ".tmp", ".TMP", ".bak", ".BAK", ".swp", ".SWP",
+    )
+
+    inputs: ClassVar[dict[str, str]] = {
+        "docs_root": "<docs>", "rust_root": "<rust>",
+        "frontend_root": "<frontend>",
+    }
+    """FIXED 2026-09-16 (K-42 sweep, approved): every `docs/...`/`backend/...`/
+    `.specs/...`/`frontend/...` entry below (ASSET_DIR_PREFIXES,
+    ASSET_EXACT_FILES, MD_SRC_EXEMPT, MD_SRC_TREES's `backend/`) was a
+    hardcoded literal. `_asset_exempt` is a LOUD shape -- a repository whose
+    root is not the packaged default had a real, legitimately-placed asset
+    fail the exemption and get reported "looks like a screenshot", a visible
+    wrong finding. `MD_SRC_TREES`/`MD_SRC_EXEMPT` are the opposite, SILENT
+    shape: a redeclared rust root meant `_md_sprawl`'s own `startswith` never
+    matched, so real `.md` sprawl under that tree went unreported entirely.
+    `agent/` (MD_SRC_TREES, MD_SRC_EXEMPT) stays literal -- there is no
+    `<agent>` tree in `policy/config.toml`. Every other suffix stays literal
+    below its resolved root: named subject matter, not a resolvable path."""
+
+    # Enumerated product asset directories — a screenshot/image basename is
+    # legitimate ONLY under one of these (a directory prefix) or as this one
+    # exact file. Checked ahead of the screenshot/image basename test, exactly
+    # as check.sh's nested `case "$f"` does before falling through to
+    # `case "$base"`.
+    ASSET_DIR_TEMPLATES: ClassVar[tuple[tuple[str, str], ...]] = (
+        ("docs_root", "assets/research/mobile-reference/"),
+        ("rust_root", "crates/enact-app/assets/builtin-assistants/avatars/"),
+        ("rust_root", "crates/enact-assets/assets/logos/"),
+        ("frontend_root", "mobile/assets/images/"),
+        ("frontend_root", "packages/desktop/src/renderer/assets/logos/"),
+        ("frontend_root", "packages/desktop/src/renderer/assets/themes/"),
+        ("frontend_root", "public/pwa/"),
+        ("frontend_root", "resources/"),
+    )
+    ASSET_EXACT_FILE_TEMPLATES: ClassVar[tuple[tuple[str, str], ...]] = (
+        ("frontend_root", "tests/e2e/helpers/screenshots.ts"),
+    )
+
+    SCREENSHOT_PATTERN: ClassVar[re.Pattern[str]] = re.compile("screenshot", re.IGNORECASE)
+    IMAGE_SUFFIXES: ClassVar[tuple[str, ...]] = (
+        ".png", ".PNG", ".jpg", ".JPG", ".jpeg", ".JPEG",
+    )
+
+    MD_SRC_EXEMPT_LITERAL: ClassVar[tuple[str, ...]] = (
+        "agent/crates/enact-providers/src/snapshots/README.md",
+    )
+    MD_SRC_EXEMPT_TEMPLATES: ClassVar[tuple[tuple[str, str], ...]] = (
+        ("rust_root", "crates/enact-session/src/backend/codex_init_prompt.md"),
+    )
+    MD_SRC_TREES_LITERAL: ClassVar[tuple[str, ...]] = ("agent/",)
+
+    def _asset_dir_prefixes(self, ctx: Context) -> tuple[str, ...]:
+        return tuple(
+            f"{ctx.relative(ctx.inputs[input_name])}/{suffix}"
+            for input_name, suffix in self.ASSET_DIR_TEMPLATES
+            if input_name in ctx.inputs  # a widening input: absent -> no entry
+        )
+
+    def _asset_exact_files(self, ctx: Context) -> tuple[str, ...]:
+        return tuple(
+            f"{ctx.relative(ctx.inputs[input_name])}/{suffix}"
+            for input_name, suffix in self.ASSET_EXACT_FILE_TEMPLATES
+            if input_name in ctx.inputs
+        )
+
+    def _md_src_exempt(self, ctx: Context) -> tuple[str, ...]:
+        return self.MD_SRC_EXEMPT_LITERAL + tuple(
+            f"{ctx.relative(ctx.inputs[input_name])}/{suffix}"
+            for input_name, suffix in self.MD_SRC_EXEMPT_TEMPLATES
+            if input_name in ctx.inputs
+        )
+
+    def _md_src_trees(self, ctx: Context) -> tuple[str, ...]:
+        return self.MD_SRC_TREES_LITERAL + (f"{ctx.relative(ctx.inputs['rust_root'])}/",)
+
+    def graded(self, ctx: Context, files: FileSet) -> Iterable[Report]:
+        # `LC_ALL=C sort` in the shell is a byte-order sort; Python's default
+        # string ordering matches it for the ASCII repository-relative paths
+        # this row ever sees.
+        for relative in sorted(files):
+            yield from self._root_allowlist(relative)
+            yield from self._apps_retired(relative)
+            yield from self._stray_artifact(ctx, relative)
+            yield from self._md_sprawl(ctx, relative)
+
+    # -- Rule 1: root-level allowlist ---------------------------------------
+
+    def _root_allowlist(self, relative: str) -> Iterable[Report]:
+        if "/" in relative:
+            return
+        if relative in self.ROOT_ALLOWLIST:
+            return
+        # The allowlist is ~60 entries. Printing all of them per finding buries
+        # the one fact the line is reporting, and five findings produced three
+        # hundred lines of identical noise.
+        yield self.report(
+            relative,
+            f"root: '{relative}' is not on the root allowlist",
+            f"move '{relative}' into an owning subdirectory, or add it to "
+            "policy/root_shape.py if it genuinely belongs at the root",
+        )
+
+    # -- Rule 2 (numbered 4 in check.sh): apps/ is retired ------------------
+
+    def _apps_retired(self, relative: str) -> Iterable[Report]:
+        if relative.startswith("apps/"):
+            yield self.report(
+                relative,
+                f"apps-retired: '{relative}' is staged under retired apps/; "
+                "use the owning current tree",
+                f"move '{relative}' into frontend/ (or the current owning tree) "
+                "and remove it from apps/",
+            )
+
+    # -- Rule 3 (numbered 2 in check.sh): stray test/ artifacts -------------
+
+    def _stray_artifact(self, ctx: Context, relative: str) -> Iterable[Report]:
+        # check.sh's `case "$f" in /*) ;; *) ... esac` skips this whole rule
+        # for a path beginning with a literal `/`. The given set is always
+        # repository-relative (never absolute), so this arm is inert in
+        # practice — carried over rather than dropped, since it is what the
+        # shell source actually branches on.
+        if relative.startswith("/"):
+            return
+
+        base = relative.rsplit("/", 1)[-1]
+
+        if base.endswith(self.THROWAWAY_SUFFIXES):
+            yield self.report(
+                relative,
+                f"'{relative}' looks like a throwaway artifact — belongs in "
+                ".gitignore, not committed",
+                f"move '{relative}' under a gitignored path or delete it, "
+                "then unstage it from the commit",
+            )
+            return
+
+        if self._asset_exempt(ctx, relative):
+            return
+
+        if self.SCREENSHOT_PATTERN.search(base) or base.endswith(self.IMAGE_SUFFIXES):
+            yield self.report(
+                relative,
+                f"'{relative}' looks like a screenshot — belongs in "
+                ".gitignore, not committed",
+                f"move '{relative}' under a gitignored path or into one of "
+                "the enumerated asset directories, then unstage it from the commit",
+            )
+
+    def _asset_exempt(self, ctx: Context, relative: str) -> bool:
+        if relative in self._asset_exact_files(ctx):
+            return True
+        return any(relative.startswith(prefix) for prefix in self._asset_dir_prefixes(ctx))
+
+    # -- Rule 4 (numbered 3 in check.sh): .md sprawl into backend//agent/ src/ --
+
+    def _md_sprawl(self, ctx: Context, relative: str) -> Iterable[Report]:
+        if not relative.endswith(".md"):
+            return
+        if relative in self._md_src_exempt(ctx):
+            return
+        if not relative.startswith(self._md_src_trees(ctx)):
+            return
+        if "/src/" not in relative:
+            return
+        yield self.report(
+            relative,
+            f"md-sprawl: '{relative}' is a markdown file inside a src/ tree "
+            "— narrative docs belong in docs/ or plans/",
+            f"move '{relative}' into docs/ or plans/, or add it to check.py's "
+            "src/ Markdown exemption list if it must stay",
+        )

package/packages/repo-controls/package/adl-compliance/src/adl_compliance/checks/layout/placement/fixtures/placement-allowed/agent/crates/enact-providers/src/snapshots/README.md

@@ -0,0 +1 @@
+placement corpus: an enumerated product path that must stay allowed.

package/packages/repo-controls/package/adl-compliance/src/adl_compliance/checks/layout/placement/fixtures/placement-allowed/backend/crates/enact-app/assets/builtin-assistants/avatars/assistant.jpg

@@ -0,0 +1 @@
+placement corpus: an enumerated product path that must stay allowed.

package/packages/repo-controls/package/adl-compliance/src/adl_compliance/checks/layout/placement/fixtures/placement-allowed/backend/crates/enact-assets/assets/logos/tools/coding/tool.png

@@ -0,0 +1 @@
+placement corpus: an enumerated product path that must stay allowed.

package/packages/repo-controls/package/adl-compliance/src/adl_compliance/checks/layout/placement/fixtures/placement-allowed/backend/crates/enact-session/src/backend/codex_init_prompt.md

@@ -0,0 +1 @@
+placement corpus: an enumerated product path that must stay allowed.

package/packages/repo-controls/package/adl-compliance/src/adl_compliance/checks/layout/placement/fixtures/placement-allowed/frontend/mobile/assets/images/icon.png

@@ -0,0 +1 @@
+placement corpus: an enumerated product path that must stay allowed.

package/packages/repo-controls/package/adl-compliance/src/adl_compliance/checks/layout/placement/fixtures/placement-allowed/frontend/packages/desktop/src/renderer/assets/logos/brand/app.png

@@ -0,0 +1 @@
+placement corpus: an enumerated product path that must stay allowed.

package/packages/repo-controls/package/adl-compliance/src/adl_compliance/checks/layout/placement/fixtures/placement-allowed/frontend/packages/desktop/src/renderer/assets/themes/default-theme.png

@@ -0,0 +1 @@
+placement corpus: an enumerated product path that must stay allowed.

package/packages/repo-controls/package/adl-compliance/src/adl_compliance/checks/layout/placement/fixtures/placement-allowed/frontend/public/pwa/icon-192.png

@@ -0,0 +1 @@
+placement corpus: an enumerated product path that must stay allowed.

package/packages/repo-controls/package/adl-compliance/src/adl_compliance/checks/layout/placement/fixtures/placement-allowed/frontend/resources/product.png

@@ -0,0 +1 @@
+placement corpus: an enumerated product path that must stay allowed.

package/packages/repo-controls/package/adl-compliance/src/adl_compliance/checks/layout/placement/fixtures/placement-stray/apps/legacy/file.ts

@@ -0,0 +1 @@
+placement corpus: an out-of-place path that must be reported.

package/packages/repo-controls/package/adl-compliance/src/adl_compliance/checks/layout/placement/fixtures/placement-stray/backend/crates/enact-session/src/backend/README.md

@@ -0,0 +1 @@
+placement corpus: an out-of-place path that must be reported.

package/packages/repo-controls/package/adl-compliance/src/adl_compliance/checks/layout/placement/fixtures/placement-stray/frontend/unapproved/screenshot.png

@@ -0,0 +1 @@
+placement corpus: an out-of-place path that must be reported.

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

@@ -0,0 +1,230 @@
+"""LAY-008 — ported from `compliance_new/checks/layout/placement/test.sh`.
+
+Two corpora, same names and file shapes as the shell fixtures:
+`placement-allowed` (the 11 enumerated product paths that must stay silent)
+and `placement-stray` (one path per rule that must fire: a screenshot outside
+every enumerated asset directory, a markdown file inside a crate `src/` tree,
+and a file under retired `apps/`).
+
+The shell `test.sh` drives `check.sh` DIRECTLY with the whole corpus as
+`ADL_CHANGED_FILES` — it does not go through `gate-runner.sh`'s row-scope
+narrowing at all (its own comment: a case that skips that step "also passes
+against a row whose scope excludes the corpus, which is a pass that proves
+nothing about the exemptions"). This module does the same: `graded_directly`
+calls `Placement().graded()` on the whole corpus, bypassing
+`scope.intersect(ROW.resolved_scope(), ...)` entirely. That narrowing matters here
+more than usual — this row's real `engine.scope` (`*`, the two throwaway-
+extension globs, and the check's own script path) does not admit ANY of this
+corpus's paths, so testing through it would report clean for every case
+without exercising a single rule.
+
+This wave's checks are wired into `checks/__init__.py` in a later, single pass
+(see that folder's own docstring), so `Placement` is not yet registered under
+`checks.lookup`; `graded_directly` builds its own `Context`/`decide` call the
+same way `checks.repository.banned_commands`'s own test module does for an
+already-wired gate, and `run_via_row_scope` reproduces `runner.run`'s
+scope-narrowing formula directly for the one case that needs it (no set at
+all), the same bypass `rust.domain-modules`'s test module uses.
+
+check.sh hardcodes `RULE_ID=LAY-007` for every finding this gate raises, even
+though this row's own id is `LAY-008` (`LAY-007` belongs to a different row,
+`layout.pipeline-templates`) — see `check.py`'s module docstring for the full
+account. Every assertion below expects rule `"LAY-007"`, matching the shell
+tree's real, if mismatched, behaviour rather than what the id should have been.
+"""
+
+from __future__ import annotations
+
+import pathlib
+
+from adl_compliance.checks.layout.placement import Placement
+from adl_compliance.core import scope
+from adl_compliance.core.context import Context, FileSet
+from adl_compliance.core.verdict import Outcome, Verdict, could_not_run, decide
+from adl_compliance.policy.registry import load
+
+FIXTURES = pathlib.Path(__file__).parent / "fixtures"
+ALLOWED = FIXTURES / "placement-allowed"
+STRAY = FIXTURES / "placement-stray"
+ROW = load().by_id("LAY-008")
+
+
+def _whole_corpus(root: pathlib.Path) -> tuple[str, ...]:
+    """Every file under `root`, repository-relative to it — the same thing
+    the shell test's `corpus_set` (`git ls-files --cached --others
+    --exclude-standard`) produces for a corpus with nothing gitignored."""
+    return tuple(
+        sorted(str(p.relative_to(root)) for p in root.rglob("*") if p.is_file())
+    )
+
+
+def graded_directly(root: pathlib.Path, paths: tuple[str, ...]) -> Verdict:
+    """Bypasses row-scope narrowing entirely — the check's OWN filtering
+    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={
+            "docs_root": root / "docs",
+            "rust_root": root / "backend",
+            "frontend_root": root / "frontend",
+            "specs_root": root / ".specs",
+        },
+    )
+    findings = tuple(Placement().graded(ctx, FileSet(paths=paths)))
+    return decide(ROW, findings, 0, ())
+
+
+def run_via_row_scope(
+    root: pathlib.Path, given: tuple[str, ...], *, exhaustive: bool = False
+) -> Verdict:
+    """`runner.run`'s own pipeline (scope narrowing, then the
+    empty-exhaustive could-not-run rule, then grade+decide) against the row's
+    real `engine.scope`, without going through `checks.lookup`."""
+    narrowed = FileSet(paths=scope.intersect(ROW.resolved_scope(), given))
+    if not narrowed and exhaustive:
+        return could_not_run(
+            ROW,
+            f"engine.scope matches no file on disk ({' | '.join(ROW.engine.scope)}); "
+            "a scope selecting nothing is could-not-run, never a clean pass",
+        )
+    # 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={
+            "docs_root": root / "docs",
+            "rust_root": root / "backend",
+            "frontend_root": root / "frontend",
+            "specs_root": root / ".specs",
+        },
+    )
+    findings = tuple(Placement().run(ctx, narrowed))
+    return decide(ROW, findings, 0, ())
+
+
+def test_the_enumerated_product_paths_are_all_silent() -> None:
+    """Every allowed path is actually graded, not narrowed out of the set —
+    all 11 enumerated paths, exactly as the shell test asserts, or a
+    corpus drift would go unnoticed."""
+    given = _whole_corpus(ALLOWED)
+    assert len(given) == 10, given
+    verdict = graded_directly(ALLOWED, given)
+    assert verdict.outcome is Outcome.CLEAN, verdict.render()
+    assert verdict.findings == ()
+
+
+def test_out_of_place_paths_are_reported() -> None:
+    given = _whole_corpus(STRAY)
+    assert len(given) == 3, given
+    verdict = graded_directly(STRAY, given)
+    assert verdict.outcome is Outcome.FINDINGS
+    assert len(verdict.findings) == 3, verdict.findings
+    # LAY-008, not LAY-007: the check used to report under its neighbour's id,
+    # and this assertion pinned the bug in place.
+    assert all(f.rule == "LAY-008" for f in verdict.findings)
+
+
+def test_a_screenshot_outside_every_enumerated_asset_directory_is_reported() -> None:
+    given = _whole_corpus(STRAY)
+    verdict = graded_directly(STRAY, given)
+    paths = {f.path for f in verdict.findings}
+    assert "frontend/unapproved/screenshot.png" in paths
+
+
+def test_a_markdown_file_inside_a_crate_src_tree_is_reported() -> None:
+    given = _whole_corpus(STRAY)
+    verdict = graded_directly(STRAY, given)
+    paths = {f.path for f in verdict.findings}
+    assert "backend/crates/enact-session/src/backend/README.md" in paths
+
+
+def test_a_file_under_retired_apps_is_reported() -> None:
+    given = _whole_corpus(STRAY)
+    verdict = graded_directly(STRAY, given)
+    paths = {f.path for f in verdict.findings}
+    assert "apps/legacy/file.ts" in paths
+
+
+def test_a_throwaway_extension_is_reported_strictly_everywhere() -> None:
+    """Rule 3's throwaway-extension arm fires even inside an enumerated asset
+    directory — check.sh's own comment: checked "strictly everywhere",
+    ahead of the asset-directory exemption."""
+    verdict = graded_directly(
+        ALLOWED, ("frontend/resources/build.log",),
+    )
+    assert verdict.outcome is Outcome.FINDINGS
+    assert len(verdict.findings) == 1
+    assert verdict.findings[0].path == "frontend/resources/build.log"
+    assert "throwaway artifact" in verdict.findings[0].message
+
+
+def test_a_root_level_file_off_the_allowlist_is_reported() -> None:
+    verdict = graded_directly(ALLOWED, ("random.txt",))
+    assert verdict.outcome is Outcome.FINDINGS
+    assert verdict.findings[0].path == "random.txt"
+    assert "root allowlist" in verdict.findings[0].message
+
+
+def test_a_root_level_allowlisted_file_is_silent() -> None:
+    verdict = graded_directly(ALLOWED, ("AGENTS.md", "justfile", "uv.lock"))
+    assert verdict.outcome is Outcome.CLEAN
+
+
+def test_no_set_is_could_not_run() -> None:
+    """The empty, exhaustive scope — no files given at all — is a
+    could-not-run, never a clean pass, matching check.sh's own NO SET, NO RUN
+    guard (exit 2)."""
+    verdict = run_via_row_scope(STRAY, (), exhaustive=True)
+    assert verdict.outcome is Outcome.COULD_NOT_RUN
+
+
+def test_a_redeclared_estate_still_exempts_a_real_asset(tmp_path: pathlib.Path) -> None:
+    """The LOUD false-finding ASSET_DIR_TEMPLATES shipped with.
+
+    Every entry was a hardcoded literal, tested with `startswith`/`==` in
+    `_asset_exempt`. A repository whose frontend root is not the packaged
+    default had a real, legitimately-placed themed asset fail that
+    exemption and get reported "looks like a screenshot" -- a visible,
+    wrong finding about a file the exemption exists to admit."""
+    ctx = Context(
+        root=tmp_path, row=ROW,
+        inputs={
+            "docs_root": tmp_path / "docs",
+            "rust_root": tmp_path / "backend",
+            "frontend_root": tmp_path / "webapp",
+            "specs_root": tmp_path / ".specs",
+        },
+    )
+    path = "webapp/packages/desktop/src/renderer/assets/themes/screenshot-dark.png"
+    findings = tuple(Placement().graded(ctx, FileSet(paths=(path,))))
+    assert findings == (), (
+        f"a real themed asset under a redeclared frontend root was wrongly "
+        f"reported as a stray screenshot: {findings}"
+    )
+
+
+def test_a_redeclared_rust_root_still_catches_md_sprawl(tmp_path: pathlib.Path) -> None:
+    """The SILENT false pass MD_SRC_TREES/MD_SRC_EXEMPT shipped with.
+
+    `MD_SRC_TREES`'s `backend/` entry was a hardcoded literal, tested with
+    `startswith` in `_md_sprawl`. A repository whose rust root is not the
+    packaged default had real narrative-doc sprawl inside its `src/` tree
+    fail that `startswith` test, and the gate never examined it at all: no
+    error, no finding, indistinguishable from a repository with no sprawl."""
+    ctx = Context(
+        root=tmp_path, row=ROW,
+        inputs={
+            "docs_root": tmp_path / "docs",
+            "rust_root": tmp_path / "rustcode",
+            "frontend_root": tmp_path / "frontend",
+            "specs_root": tmp_path / ".specs",
+        },
+    )
+    path = "rustcode/crates/enact-example/src/notes.md"
+    findings = tuple(Placement().graded(ctx, FileSet(paths=(path,))))
+    assert any("md-sprawl" in f.message for f in findings), (
+        f"real markdown sprawl under a redeclared rust root went "
+        f"unreported: {findings}"
+    )

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

@@ -0,0 +1,53 @@
+"""Shared work-item metadata for checks that read the plans tree."""
+
+from __future__ import annotations
+
+import re
+from typing import ClassVar
+
+
+class PlanMetadata:
+    """The plans tree's board-state vocabulary and frontmatter readers."""
+
+    WORK_ITEM_STATUSES: ClassVar[tuple[str, ...]] = (
+        "New",
+        "Approved",
+        "Committed",
+        "In Progress",
+        "In Testing",
+        "Done",
+        "Removed",
+    )
+    ACTIVE_STATUSES: ClassVar[frozenset[str]] = frozenset(WORK_ITEM_STATUSES[:5])
+    TERMINAL_STATUSES: ClassVar[frozenset[str]] = frozenset(WORK_ITEM_STATUSES[5:])
+
+    STATUS_LINE: ClassVar[re.Pattern[str]] = re.compile(r"^status:\s*(.+)$")
+    WORK_ITEM_LINE: ClassVar[re.Pattern[str]] = re.compile(r"^work_item:\s*(.+)$")
+    WORK_ITEM_URL: ClassVar[re.Pattern[str]] = re.compile(
+        r"^https://dev\.azure\.com/\S+/_workitems/edit/([0-9]+)/?$"
+    )
+
+    @staticmethod
+    def field(body: str, pattern: re.Pattern[str]) -> str | None:
+        """Read one exact, single-line frontmatter value."""
+        lines = body.splitlines()
+        if not lines or lines[0].strip() != "---":
+            return None
+        for line in lines[1:]:
+            if line.strip() == "---":
+                return None
+            found = pattern.match(line)
+            if found:
+                return found.group(1).strip().strip("\"'")
+        return None
+
+    @classmethod
+    def work_item_id(cls, body: str) -> tuple[int | None, str | None]:
+        """Return the linked Azure DevOps id, or why it could not be read."""
+        raw = cls.field(body, cls.WORK_ITEM_LINE)
+        if raw is None:
+            return None, "missing"
+        found = cls.WORK_ITEM_URL.match(raw)
+        if not found:
+            return None, "not a work item URL"
+        return int(found.group(1)), None

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

@@ -0,0 +1,7 @@
+"""LAY-009 — `layout.plans-layout`."""
+
+from __future__ import annotations
+
+from .check import PlansLayout
+
+__all__ = ["PlansLayout"]